betterproto2-compiler 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

betterproto2_compiler/known_types/__init__.py

@@ -13,13 +13,14 @@ from .google_values import (
     UInt32Value,
     UInt64Value,
 )
+from .struct import ListValue, Struct, Value
 from .timestamp import Timestamp
 
 # For each (package, message name), lists the methods that should be added to the message definition.
 # The source code of the method is read from the `known_types` folder. If imports are needed, they can be directly added
 # to the template file: they will automatically be removed if not necessary.
 KNOWN_METHODS: dict[tuple[str, str], list[Callable]] = {
-    ("google.protobuf", "Any"): [Any.pack, Any.unpack, Any.to_dict],
+    ("google.protobuf", "Any"): [Any.pack, Any.unpack, Any.to_dict, Any.from_dict],
     ("google.protobuf", "Timestamp"): [
         Timestamp.from_datetime,
         Timestamp.to_datetime,
@@ -92,6 +93,18 @@ KNOWN_METHODS: dict[tuple[str, str], list[Callable]] = {
         BytesValue.from_wrapped,
         BytesValue.to_wrapped,
     ],
+    ("google.protobuf", "Struct"): [
+        Struct.from_dict,
+        Struct.to_dict,
+    ],
+    ("google.protobuf", "ListValue"): [
+        ListValue.from_dict,
+        ListValue.to_dict,
+    ],
+    ("google.protobuf", "Value"): [
+        Value.from_dict,
+        Value.to_dict,
+    ],
 }
 
 # A wrapped type is the type of a message that is automatically replaced by a known Python type.

betterproto2_compiler/known_types/any.py

@@ -8,7 +8,8 @@ default_message_pool = betterproto2.MessagePool()  # Only for typing purpose
 
 
 class Any(VanillaAny):
-    def pack(self, message: betterproto2.Message, message_pool: "betterproto2.MessagePool | None" = None) -> None:
+    @classmethod
+    def pack(cls, message: betterproto2.Message, message_pool: "betterproto2.MessagePool | None" = None) -> "Any":
         """
         Pack the given message in the `Any` object.
 
@@ -17,8 +18,10 @@ class Any(VanillaAny):
         """
         message_pool = message_pool or default_message_pool
 
-        self.type_url = message_pool.type_to_url[type(message)]
-        self.value = bytes(message)
+        type_url = message_pool.type_to_url[type(message)]
+        value = bytes(message)
+
+        return cls(type_url=type_url, value=value)
 
     def unpack(self, message_pool: "betterproto2.MessagePool | None" = None) -> betterproto2.Message | None:
         """
@@ -54,3 +57,21 @@ class Any(VanillaAny):
             output["value"] = value.to_dict(**kwargs)
 
         return output
+
+    # TODO typing
+    @classmethod
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
+        value = dict(value)  # Make a copy
+
+        type_url = value.pop("@type", None)
+        msg_cls = default_message_pool.url_to_type.get(type_url, None)
+
+        if not msg_cls:
+            raise TypeError(f"Can't unpack unregistered type: {type_url}")
+
+        if not msg_cls.to_dict == betterproto2.Message.to_dict:
+            value = value["value"]
+
+        return cls(
+            type_url=type_url, value=bytes(msg_cls.from_dict(value, ignore_unknown_fields=ignore_unknown_fields))
+        )

betterproto2_compiler/known_types/duration.py

@@ -30,7 +30,7 @@ class Duration(VanillaDuration):
 
     # TODO typing
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, str):
             if not re.match(r"^\d+(\.\d+)?s$", value):
                 raise ValueError(f"Invalid duration string: {value}")
@@ -38,7 +38,7 @@ class Duration(VanillaDuration):
             seconds = float(value[:-1])
             return Duration(seconds=int(seconds), nanos=int((seconds - int(seconds)) * 1e9))
 
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     # TODO typing
     def to_dict(

betterproto2_compiler/known_types/struct.py

@@ -0,0 +1,111 @@
+import typing
+
+import betterproto2
+
+from betterproto2_compiler.lib.google.protobuf import (
+    ListValue as VanillaListValue,
+    NullValue,
+    Struct as VanillaStruct,
+    Value as VanillaValue,
+)
+
+
+class Struct(VanillaStruct):
+    # TODO typing
+    @classmethod
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
+        assert isinstance(value, dict)
+
+        fields: dict[str, Value] = {}
+
+        for key, val in value.items():
+            fields[key] = Value.from_dict(val)
+
+        return cls(fields=fields)  # type: ignore[reportArgumentType]
+
+    # TODO typing
+    def to_dict(
+        self,
+        *,
+        output_format: betterproto2.OutputFormat = betterproto2.OutputFormat.PROTO_JSON,
+        casing: betterproto2.Casing = betterproto2.Casing.CAMEL,
+        include_default_values: bool = False,
+    ) -> dict[str, typing.Any] | typing.Any:
+        # If the output format is PYTHON, we should have kept the wrapped type without building the real class
+        assert output_format == betterproto2.OutputFormat.PROTO_JSON
+
+        return {
+            key: value.to_dict(
+                output_format=output_format, casing=casing, include_default_values=include_default_values
+            )
+            for key, value in self.fields.items()
+        }
+
+
+# We can't use the unwrap mechanism to support directly using a Python object due to the None case: it would then be
+# impossible to distinguish between the absence of the message and a None value.
+class Value(VanillaValue):
+    # TODO typing
+    @classmethod
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
+        match value:
+            case bool() as b:
+                return cls(bool_value=b)
+            case int() | float() as num:
+                return cls(number_value=num)
+            case str() as s:
+                return cls(string_value=s)
+            case list() as l:
+                return cls(list_value=ListValue.from_dict(l))
+            case dict() as d:
+                return cls(struct_value=Struct.from_dict(d))
+            case None:
+                return cls(null_value=NullValue.NULL_VALUE)
+        raise ValueError(f"Unknown value type: {type(value)}")
+
+    # TODO typing
+    def to_dict(
+        self,
+        *,
+        output_format: betterproto2.OutputFormat = betterproto2.OutputFormat.PROTO_JSON,
+        casing: betterproto2.Casing = betterproto2.Casing.CAMEL,
+        include_default_values: bool = False,
+    ) -> dict[str, typing.Any] | typing.Any:
+        # If the output format is PYTHON, we should have kept the wrapped type without building the real class
+        assert output_format == betterproto2.OutputFormat.PROTO_JSON
+
+        match self:
+            case Value(null_value=NullValue.NULL_VALUE):
+                return None
+            case Value(bool_value=bool(b)):
+                return b
+            case Value(number_value=int(num)) | Value(number_value=float(num)):
+                return num
+            case Value(string_value=str(s)):
+                return s
+            case Value(list_value=ListValue(values=l)):
+                return [v.to_dict() for v in l]
+            case Value(struct_value=Struct(fields=f)):
+                return {k: v.to_dict() for k, v in f.items()}
+
+        raise ValueError("Invalid value")
+
+
+class ListValue(VanillaListValue):
+    # TODO typing
+    @classmethod
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
+        return cls(values=[Value.from_dict(v) for v in value])
+
+    # TODO typing
+    def to_dict(
+        self,
+        *,
+        output_format: betterproto2.OutputFormat = betterproto2.OutputFormat.PROTO_JSON,
+        casing: betterproto2.Casing = betterproto2.Casing.CAMEL,
+        include_default_values: bool = False,
+    ) -> dict[str, typing.Any] | typing.Any:
+        # If the output format is PYTHON, we should have kept the wrapped type without building the real class
+        assert output_format == betterproto2.OutputFormat.PROTO_JSON
+
+        return [value.to_dict() for value in self.values]

betterproto2_compiler/known_types/timestamp.py

@@ -55,13 +55,13 @@ class Timestamp(VanillaTimestamp):
 
     # TODO typing
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, str):
             dt = dateutil.parser.isoparse(value)
             dt = dt.astimezone(datetime.timezone.utc)
             return Timestamp.from_datetime(dt)
 
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     # TODO typing
     def to_dict(

betterproto2_compiler/lib/__init__.py

@@ -0,0 +1,12 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# sources: protobuf.proto
+# plugin: python-betterproto2
+# This file has been @generated
+
+__all__ = ()
+
+
+import betterproto2
+
+_COMPILER_VERSION = "0.8.0"
+betterproto2.check_compiler_version(_COMPILER_VERSION)