Remove to_pydict (#62)

* Remove to_pydict

* Add kwargs variable

* Fix bug

Author: AdrienVannson

src/betterproto2/__init__.py

@@ -21,6 +21,7 @@
     timedelta,
     timezone,
 )
+from enum import IntEnum
 from io import BytesIO
 from itertools import count
 from typing import (
@@ -560,6 +561,15 @@ def _get_cls_by_field(cls: Type["Message"], fields: Iterable[dataclasses.Field])
         return field_cls
 
 
+class OutputFormat(IntEnum):
+    """
+    Chosen output format for the `Message.to_dict` method.
+    """
+
+    PYTHON = 1
+    PROTO_JSON = 2
+
+
 class Message(ABC):
     """
     The base class for protobuf messages, all generated messages will inherit from
@@ -606,10 +616,6 @@ def __repr__(self) -> str:
         ]
         return f"{self.__class__.__name__}({', '.join(parts)})"
 
-    # def __rich_repr__(self) -> Iterable[Tuple[str, Any, Any]]:
-    #     for field_name in self._betterproto.sorted_field_names:
-    #         yield field_name, self.__getattribute__(field_name), PLACEHOLDER
-
     def __bool__(self) -> bool:
         """True if the message has any fields with non-default values."""
         return any(
@@ -946,9 +952,15 @@ def FromString(cls: Type[T], data: bytes) -> T:
         """
         return cls().parse(data)
 
-    def to_dict(self, casing: Casing = Casing.CAMEL, include_default_values: bool = False) -> Dict[str, Any]:
+    def to_dict(
+        self,
+        *,
+        output_format: OutputFormat = OutputFormat.PROTO_JSON,
+        casing: Casing = Casing.CAMEL,
+        include_default_values: bool = False,
+    ) -> Dict[str, Any]:
         """
-        Returns a JSON serializable dict representation of this object.
+        Return a dict representation of the message.
 
         Parameters
         -----------
@@ -965,6 +977,12 @@ def to_dict(self, casing: Casing = Casing.CAMEL, include_default_values: bool =
         Dict[:class:`str`, Any]
             The JSON serializable dict representation of this object.
         """
+        kwargs = {  # For recursive calls
+            "output_format": output_format,
+            "casing": casing,
+            "include_default_values": include_default_values,
+        }
+
         output: Dict[str, Any] = {}
         field_types = self._type_hints()
         for field_name, meta in self._betterproto.meta_by_field_name.items():
@@ -973,74 +991,87 @@ def to_dict(self, casing: Casing = Casing.CAMEL, include_default_values: bool =
             cased_name = casing(field_name).rstrip("_")  # type: ignore
             if meta.proto_type == TYPE_MESSAGE:
                 if isinstance(value, datetime):
-                    output[cased_name] = _Timestamp.timestamp_to_json(value)
+                    if output_format == OutputFormat.PROTO_JSON:
+                        output[cased_name] = _Timestamp.timestamp_to_json(value)
+                    else:
+                        output[cased_name] = value
                 elif isinstance(value, timedelta):
-                    output[cased_name] = _Duration.delta_to_json(value)
+                    if output_format == OutputFormat.PROTO_JSON:
+                        output[cased_name] = _Duration.delta_to_json(value)
+                    else:
+                        output[cased_name] = value
+
                 elif meta.wraps:
                     if value is not None or include_default_values:
                         output[cased_name] = value
                 elif field_is_repeated:
                     # Convert each item.
-                    cls = self._betterproto.cls_by_field[field_name]
-                    if cls == datetime:
-                        value = [_Timestamp.timestamp_to_json(i) for i in value]
-                    elif cls == timedelta:
-                        value = [_Duration.delta_to_json(i) for i in value]
+                    if output_format == OutputFormat.PYTHON:
+                        value = [i.to_dict(**kwargs) for i in value]
                     else:
-                        value = [i.to_dict(casing, include_default_values) for i in value]
+                        cls = self._betterproto.cls_by_field[field_name]
+                        if cls == datetime:
+                            value = [_Timestamp.timestamp_to_json(i) for i in value]
+                        elif cls == timedelta:
+                            value = [_Duration.delta_to_json(i) for i in value]
+                        else:
+                            value = [i.to_dict(**kwargs) for i in value]
                     if value or include_default_values:
                         output[cased_name] = value
                 elif value is None:
                     if include_default_values:
-                        output[cased_name] = value
+                        output[cased_name] = None
                 else:
-                    output[cased_name] = value.to_dict(casing, include_default_values)
+                    output[cased_name] = value.to_dict(**kwargs)
             elif meta.proto_type == TYPE_MAP:
                 output_map = {**value}
                 for k in value:
                     if hasattr(value[k], "to_dict"):
-                        output_map[k] = value[k].to_dict(casing, include_default_values)
+                        output_map[k] = value[k].to_dict(**kwargs)
 
                 if value or include_default_values:
                     output[cased_name] = output_map
             elif value != self._get_field_default(field_name) or include_default_values:
-                if meta.proto_type in INT_64_TYPES:
-                    if field_is_repeated:
-                        output[cased_name] = [str(n) for n in value]
-                    elif value is None:
-                        if include_default_values:
-                            output[cased_name] = value
-                    else:
-                        output[cased_name] = str(value)
-                elif meta.proto_type == TYPE_BYTES:
-                    if field_is_repeated:
-                        output[cased_name] = [b64encode(b).decode("utf8") for b in value]
-                    elif value is None and include_default_values:
-                        output[cased_name] = value
-                    else:
-                        output[cased_name] = b64encode(value).decode("utf8")
-                elif meta.proto_type == TYPE_ENUM:
-                    if field_is_repeated:
-                        enum_class = field_types[field_name].__args__[0]
-                        if isinstance(value, typing.Iterable) and not isinstance(value, str):
-                            output[cased_name] = [enum_class(el).name for el in value]
+                if output_format == OutputFormat.PROTO_JSON:
+                    if meta.proto_type in INT_64_TYPES:
+                        if field_is_repeated:
+                            output[cased_name] = [str(n) for n in value]
+                        elif value is None:
+                            if include_default_values:
+                                output[cased_name] = value
                         else:
-                            # transparently upgrade single value to repeated
-                            output[cased_name] = [enum_class(value).name]
-                    elif value is None:
-                        if include_default_values:
+                            output[cased_name] = str(value)
+                    elif meta.proto_type == TYPE_BYTES:
+                        if field_is_repeated:
+                            output[cased_name] = [b64encode(b).decode("utf8") for b in value]
+                        elif value is None and include_default_values:
                             output[cased_name] = value
-                    elif meta.optional:
-                        enum_class = field_types[field_name].__args__[0]
-                        output[cased_name] = enum_class(value).name
-                    else:
-                        enum_class = field_types[field_name]  # noqa
-                        output[cased_name] = enum_class(value).name
-                elif meta.proto_type in (TYPE_FLOAT, TYPE_DOUBLE):
-                    if field_is_repeated:
-                        output[cased_name] = [_dump_float(n) for n in value]
+                        else:
+                            output[cased_name] = b64encode(value).decode("utf8")
+                    elif meta.proto_type == TYPE_ENUM:
+                        if field_is_repeated:
+                            enum_class = field_types[field_name].__args__[0]
+                            if isinstance(value, typing.Iterable) and not isinstance(value, str):
+                                output[cased_name] = [enum_class(el).name for el in value]
+                            else:
+                                # transparently upgrade single value to repeated
+                                output[cased_name] = [enum_class(value).name]
+                        elif value is None:
+                            if include_default_values:
+                                output[cased_name] = value
+                        elif meta.optional:
+                            enum_class = field_types[field_name].__args__[0]
+                            output[cased_name] = enum_class(value).name
+                        else:
+                            enum_class = field_types[field_name]  # noqa
+                            output[cased_name] = enum_class(value).name
+                    elif meta.proto_type in (TYPE_FLOAT, TYPE_DOUBLE):
+                        if field_is_repeated:
+                            output[cased_name] = [_dump_float(n) for n in value]
+                        else:
+                            output[cased_name] = _dump_float(value)
                     else:
-                        output[cased_name] = _dump_float(value)
+                        output[cased_name] = value
                 else:
                     output[cased_name] = value
         return output
@@ -1188,69 +1219,6 @@ def from_json(self: T, value: Union[str, bytes]) -> T:
         """
         return self.from_dict(json.loads(value))
 
-    def to_pydict(self, casing: Casing = Casing.CAMEL, include_default_values: bool = False) -> Dict[str, Any]:
-        """
-        Returns a python dict representation of this object.
-
-        Parameters
-        -----------
-        casing: :class:`Casing`
-            The casing to use for key values. Default is :attr:`Casing.CAMEL` for
-            compatibility purposes.
-        include_default_values: :class:`bool`
-            If ``True`` will include the default values of fields. Default is ``False``.
-            E.g. an ``int32`` field will be included with a value of ``0`` if this is
-            set to ``True``, otherwise this would be ignored.
-
-        Returns
-        --------
-        Dict[:class:`str`, Any]
-            The python dict representation of this object.
-        """
-        output: Dict[str, Any] = {}
-        for field_name, meta in self._betterproto.meta_by_field_name.items():
-            field_is_repeated = meta.repeated
-            value = getattr(self, field_name)
-            cased_name = casing(field_name).rstrip("_")  # type: ignore
-            if meta.proto_type == TYPE_MESSAGE:
-                if isinstance(value, datetime):
-                    if (
-                        value != DATETIME_ZERO
-                        or include_default_values
-                        or self._include_default_value_for_oneof(field_name=field_name, meta=meta)
-                    ):
-                        output[cased_name] = value
-                elif isinstance(value, timedelta):
-                    if (
-                        value != timedelta(0)
-                        or include_default_values
-                        or self._include_default_value_for_oneof(field_name=field_name, meta=meta)
-                    ):
-                        output[cased_name] = value
-                elif meta.wraps:
-                    if value is not None or include_default_values:
-                        output[cased_name] = value
-                elif field_is_repeated:
-                    # Convert each item.
-                    value = [i.to_pydict(casing, include_default_values) for i in value]
-                    if value or include_default_values:
-                        output[cased_name] = value
-                elif value is None:
-                    if include_default_values:
-                        output[cased_name] = None
-                else:
-                    output[cased_name] = value.to_pydict(casing, include_default_values)
-            elif meta.proto_type == TYPE_MAP:
-                for k in value:
-                    if hasattr(value[k], "to_pydict"):
-                        value[k] = value[k].to_pydict(casing, include_default_values)
-
-                if value or include_default_values:
-                    output[cased_name] = value
-            elif value != self._get_field_default(field_name) or include_default_values:
-                output[cased_name] = value
-        return output
-
     def from_pydict(self: T, value: Mapping[str, Any]) -> T:
         """
         Parse the key/value pairs into the current message instance. This returns the

tests/test_features.py

@@ -10,6 +10,7 @@
 from unittest.mock import ANY
 
 import betterproto2
+from betterproto2 import OutputFormat
 
 
 def test_class_init():
@@ -18,7 +19,7 @@ def test_class_init():
     foo = Foo(name="foo", child=Bar(name="bar"))
 
     assert foo.to_dict() == {"name": "foo", "child": {"name": "bar"}}
-    assert foo.to_pydict() == {"name": "foo", "child": {"name": "bar"}}
+    assert foo.to_dict(output_format=OutputFormat.PYTHON) == {"name": "foo", "child": {"name": "bar"}}
 
 
 def test_enum_as_int_json():
@@ -35,7 +36,7 @@ def test_enum_as_int_json():
     # Similar expectations for pydict
     enum_msg = EnumMsg().from_dict({"enum": 1})
     assert enum_msg.enum == Enum.ONE
-    assert enum_msg.to_pydict() == {"enum": Enum.ONE}
+    assert enum_msg.to_dict(output_format=OutputFormat.PYTHON) == {"enum": Enum.ONE}
 
 
 def test_unknown_fields():
@@ -127,25 +128,13 @@ def test_dict_casing():
         "snakeCase": 3,
         "kabobCase": 4,
     }
-    assert msg.to_pydict() == {
-        "pascalCase": 1,
-        "camelCase": 2,
-        "snakeCase": 3,
-        "kabobCase": 4,
-    }
 
     assert msg.to_dict(casing=betterproto2.Casing.SNAKE) == {
         "pascal_case": 1,
         "camel_case": 2,
         "snake_case": 3,
         "kabob_case": 4,
     }
-    assert msg.to_pydict(casing=betterproto2.Casing.SNAKE) == {
-        "pascal_case": 1,
-        "camel_case": 2,
-        "snake_case": 3,
-        "kabob_case": 4,
-    }
 
 
 def test_optional_flag():
@@ -173,12 +162,16 @@ def test_optional_datetime_to_dict():
     }
 
     # Check pydict serialization
-    assert OptionalDatetimeMsg().to_pydict() == {}
-    assert OptionalDatetimeMsg().to_pydict(include_default_values=True) == {"field": None}
-    assert OptionalDatetimeMsg(field=datetime(2020, 1, 1)).to_pydict() == {"field": datetime(2020, 1, 1)}
-    assert OptionalDatetimeMsg(field=datetime(2020, 1, 1)).to_pydict(include_default_values=True) == {
+    assert OptionalDatetimeMsg().to_dict(output_format=OutputFormat.PYTHON) == {}
+    assert OptionalDatetimeMsg().to_dict(include_default_values=True, output_format=OutputFormat.PYTHON) == {
+        "field": None
+    }
+    assert OptionalDatetimeMsg(field=datetime(2020, 1, 1)).to_dict(output_format=OutputFormat.PYTHON) == {
         "field": datetime(2020, 1, 1)
     }
+    assert OptionalDatetimeMsg(field=datetime(2020, 1, 1)).to_dict(
+        include_default_values=True, output_format=OutputFormat.PYTHON
+    ) == {"field": datetime(2020, 1, 1)}
 
 
 def test_to_json_default_values():
@@ -218,7 +211,7 @@ def test_to_dict_default_values():
         "someBool": False,
     }
 
-    assert test.to_pydict(include_default_values=True) == {
+    assert test.to_dict(include_default_values=True, output_format=OutputFormat.PYTHON) == {
         "someInt": 0,
         "someDouble": 0.0,
         "someStr": "",
@@ -263,7 +256,7 @@ def test_to_dict_default_values():
         }
     )
 
-    assert test.to_pydict(include_default_values=True) == {
+    assert test.to_dict(include_default_values=True, output_format=OutputFormat.PYTHON) == {
         "someInt": 2,
         "someDouble": 1.2,
         "someStr": "hello",
@@ -284,7 +277,7 @@ def test_to_dict_datetime_values():
 
     test = TimeMsg().from_pydict({"timestamp": datetime(year=2020, month=1, day=1), "duration": timedelta(days=1)})
 
-    assert test.to_pydict() == {
+    assert test.to_dict(output_format=OutputFormat.PYTHON) == {
         "timestamp": datetime(year=2020, month=1, day=1),
         "duration": timedelta(days=1),
     }