betterproto2-compiler 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

betterproto2_compiler/lib/google/protobuf/compiler/__init__.py

@@ -1,5 +1,5 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# sources: google/protobuf/compiler/plugin.proto
+# sources: plugin.proto
 # plugin: python-betterproto2
 # This file has been @generated
 
@@ -11,18 +11,13 @@ __all__ = (
     "Version",
 )
 
-
 from dataclasses import dataclass
-from typing import (
-    List,
-    Optional,
-)
 
 import betterproto2
 
 from ....message_pool import default_message_pool
 
-betterproto2.check_compiler_version("0.3.0")
+betterproto2.check_compiler_version("0.5.0")
 
 
 class CodeGeneratorResponseFeature(betterproto2.Enum):
@@ -43,7 +38,7 @@ class CodeGeneratorRequest(betterproto2.Message):
     An encoded CodeGeneratorRequest is written to the plugin's stdin.
     """
 
-    file_to_generate: "List[str]" = betterproto2.field(1, betterproto2.TYPE_STRING, repeated=True)
+    file_to_generate: "list[str]" = betterproto2.field(1, betterproto2.TYPE_STRING, repeated=True)
     """
     The .proto files that were explicitly listed on the command-line.  The
     code generator should generate code only for these files.  Each file's
@@ -55,7 +50,7 @@ class CodeGeneratorRequest(betterproto2.Message):
     The generator parameter passed on the command-line.
     """
 
-    proto_file: "List[__protobuf__.FileDescriptorProto]" = betterproto2.field(
+    proto_file: "list[__protobuf__.FileDescriptorProto]" = betterproto2.field(
         15, betterproto2.TYPE_MESSAGE, repeated=True
     )
     """
@@ -80,7 +75,7 @@ class CodeGeneratorRequest(betterproto2.Message):
     fully qualified.
     """
 
-    source_file_descriptors: "List[__protobuf__.FileDescriptorProto]" = betterproto2.field(
+    source_file_descriptors: "list[__protobuf__.FileDescriptorProto]" = betterproto2.field(
         17, betterproto2.TYPE_MESSAGE, repeated=True
     )
     """
@@ -89,7 +84,7 @@ class CodeGeneratorRequest(betterproto2.Message):
     files_to_generate.
     """
 
-    compiler_version: "Optional[Version]" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True)
+    compiler_version: "Version | None" = betterproto2.field(3, betterproto2.TYPE_MESSAGE, optional=True)
     """
     The version number of protocol compiler.
     """
@@ -122,7 +117,23 @@ class CodeGeneratorResponse(betterproto2.Message):
     This is a bitwise "or" of values from the Feature enum.
     """
 
-    file: "List[CodeGeneratorResponseFile]" = betterproto2.field(15, betterproto2.TYPE_MESSAGE, repeated=True)
+    minimum_edition: "int" = betterproto2.field(3, betterproto2.TYPE_INT32)
+    """
+    The minimum edition this plugin supports.  This will be treated as an
+    Edition enum, but we want to allow unknown values.  It should be specified
+    according the edition enum value, *not* the edition number.  Only takes
+    effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
+    """
+
+    maximum_edition: "int" = betterproto2.field(4, betterproto2.TYPE_INT32)
+    """
+    The maximum edition this plugin supports.  This will be treated as an
+    Edition enum, but we want to allow unknown values.  It should be specified
+    according the edition enum value, *not* the edition number.  Only takes
+    effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
+    """
+
+    file: "list[CodeGeneratorResponseFile]" = betterproto2.field(15, betterproto2.TYPE_MESSAGE, repeated=True)
 
 
 default_message_pool.register_message("google.protobuf.compiler", "CodeGeneratorResponse", CodeGeneratorResponse)
@@ -139,7 +150,7 @@ class CodeGeneratorResponseFile(betterproto2.Message):
     The file name, relative to the output directory.  The name must not
     contain "." or ".." components and must be relative, not be absolute (so,
     the file cannot lie outside the output directory).  "/" must be used as
-    the path separator, not "\".
+    the path separator, not "\\".
 
     If the name is omitted, the content will be appended to the previous
     file.  This allows the generator to break large files into small chunks,
@@ -195,7 +206,7 @@ class CodeGeneratorResponseFile(betterproto2.Message):
     The file contents.
     """
 
-    generated_code_info: "Optional[__protobuf__.GeneratedCodeInfo]" = betterproto2.field(
+    generated_code_info: "__protobuf__.GeneratedCodeInfo | None" = betterproto2.field(
         16, betterproto2.TYPE_MESSAGE, optional=True
     )
     """

betterproto2_compiler/plugin/models.py

@@ -26,14 +26,12 @@ such as a pythonized name, that will be calculated from proto_obj.
 
 import builtins
 import inspect
-import re
 from collections.abc import Iterator
 from dataclasses import (
     dataclass,
     field,
 )
 
-import betterproto2
 from betterproto2 import unwrap
 
 from betterproto2_compiler.compile.importing import get_type_reference, parse_source_type_name
@@ -43,7 +41,7 @@ from betterproto2_compiler.compile.naming import (
     pythonize_field_name,
     pythonize_method_name,
 )
-from betterproto2_compiler.known_types import KNOWN_METHODS
+from betterproto2_compiler.known_types import KNOWN_METHODS, WRAPPED_TYPES
 from betterproto2_compiler.lib.google.protobuf import (
     DescriptorProto,
     EnumDescriptorProto,
@@ -318,8 +316,14 @@ class FieldCompiler(ProtoContentBase):
     @property
     def betterproto_field_args(self) -> list[str]:
         args = []
-        if self.field_wraps:
-            args.append(f"wraps={self.field_wraps}")
+
+        if self.field_type == FieldDescriptorProtoType.TYPE_MESSAGE and self.is_wrapped:
+            unwrap_type = self.unwrapped_py_type
+
+            # Without the lambda function, the type is evaluated right away, which fails since the corresponding
+            # import is placed at the end of the file to avoid circular imports.
+            args.append(f"unwrap=lambda: {unwrap_type}")
+
         if self.optional:
             args.append("optional=True")
         elif self.repeated:
@@ -338,16 +342,6 @@ class FieldCompiler(ProtoContentBase):
             self.py_type == self.py_name and self.py_name in dir(builtins)
         )
 
-    @property
-    def field_wraps(self) -> str | None:
-        """Returns betterproto wrapped field type or None."""
-        match_wrapper = re.match(r"\.google\.protobuf\.(.+)Value$", self.proto_obj.type_name)
-        if match_wrapper:
-            wrapped_type = "TYPE_" + match_wrapper.group(1).upper()
-            if hasattr(betterproto2, wrapped_type):
-                return f"betterproto2.{wrapped_type}"
-        return None
-
     @property
     def repeated(self) -> bool:
         return self.proto_obj.label == FieldDescriptorProtoLabel.LABEL_REPEATED
@@ -378,7 +372,13 @@ class FieldCompiler(ProtoContentBase):
         return self.proto_obj.name
 
     @property
-    def py_type(self) -> str:
+    def is_wrapped(self) -> bool:
+        assert self.field_type == FieldDescriptorProtoType.TYPE_MESSAGE
+        type_package, type_name = parse_source_type_name(self.proto_obj.type_name, self.output_file.parent_request)
+
+        return (type_package, type_name) in WRAPPED_TYPES
+
+    def _py_type(self, wrap: bool) -> str:
         """String representation of Python type."""
         if self.proto_obj.type in PROTO_FLOAT_TYPES:
             return "float"
@@ -397,14 +397,24 @@ class FieldCompiler(ProtoContentBase):
                 imports=self.output_file.imports_end,
                 source_type=self.proto_obj.type_name,
                 request=self.output_file.parent_request,
+                wrap=wrap,
                 settings=self.output_file.settings,
             )
         else:
             raise NotImplementedError(f"Unknown type {self.proto_obj.type}")
 
+    @property
+    def py_type(self) -> str:
+        return self._py_type(wrap=True)
+
+    @property
+    def unwrapped_py_type(self) -> str:
+        return self._py_type(wrap=False)
+
     @property
     def annotation(self) -> str:
         py_type = self.py_type
+
         if self.use_builtins:
             py_type = f"builtins.{py_type}"
         if self.repeated:
@@ -432,6 +442,8 @@ class OneOfFieldCompiler(FieldCompiler):
 class MapEntryCompiler(FieldCompiler):
     py_k_type: str = ""
     py_v_type: str = ""
+    unwrap_v: str | None = None
+
     proto_k_type: str = ""
     proto_v_type: str = ""
 
@@ -441,18 +453,30 @@ class MapEntryCompiler(FieldCompiler):
         for nested in self.message.proto_obj.nested_type:
             if nested.name.replace("_", "").lower() == map_entry and unwrap(nested.options).map_entry:
                 # Get Python types
+                assert nested.field[0].name == "key"
                 self.py_k_type = FieldCompiler(
                     source_file=self.source_file,
                     proto_obj=nested.field[0],  # key
                     path=[],
                     message=self.message,
                 ).py_type
-                self.py_v_type = FieldCompiler(
+
+                assert nested.field[1].name == "value"
+                value_field_compiler = FieldCompiler(
                     source_file=self.source_file,
                     proto_obj=nested.field[1],  # value
                     path=[],
                     message=self.message,
-                ).py_type
+                )
+
+                self.py_v_type = value_field_compiler.py_type
+                if (
+                    value_field_compiler.field_type == FieldDescriptorProtoType.TYPE_MESSAGE
+                    and value_field_compiler.is_wrapped
+                ):
+                    self.unwrap_v = value_field_compiler.unwrapped_py_type
+                else:
+                    self.unwrap_v = None
 
                 # Get proto types
                 self.proto_k_type = unwrap(FieldDescriptorProtoType(nested.field[0].type).name)
@@ -463,11 +487,19 @@ class MapEntryCompiler(FieldCompiler):
 
     def get_field_string(self) -> str:
         """Construct string representation of this field as a field."""
+        proto_type_1 = f"betterproto2.{self.proto_k_type}"
+        proto_type_2 = f"betterproto2.{self.proto_v_type}"
+
+        unwrap_2 = ""
+        if self.unwrap_v:
+            unwrap_2 = f", unwrap_2=lambda: {self.unwrap_v}"
+
         betterproto_field_type = (
-            f"betterproto2.field({self.proto_obj.number}, "
+            "betterproto2.field("
+            f"{self.proto_obj.number}, "
             "betterproto2.TYPE_MAP, "
-            f"map_types=(betterproto2.{self.proto_k_type}, "
-            f"betterproto2.{self.proto_v_type}))"
+            f"map_meta=betterproto2.map_meta({proto_type_1}, {proto_type_2}{unwrap_2})"
+            ")"
         )
         if self.py_name in dir(builtins):
             self.message.builtins_types.add(self.py_name)
@@ -581,7 +613,7 @@ class ServiceMethodCompiler(ProtoContentBase):
             imports=self.parent.output_file.imports_end,
             source_type=self.proto_obj.input_type,
             request=self.parent.output_file.parent_request,
-            unwrap=False,
+            wrap=False,
             settings=self.parent.output_file.settings,
         )
 
@@ -608,7 +640,7 @@ class ServiceMethodCompiler(ProtoContentBase):
             imports=self.parent.output_file.imports_end,
             source_type=self.proto_obj.output_type,
             request=self.parent.output_file.parent_request,
-            unwrap=False,
+            wrap=False,
             settings=self.parent.output_file.settings,
         )
 

betterproto2_compiler/plugin/parser.py

@@ -14,7 +14,7 @@ from betterproto2_compiler.lib.google.protobuf.compiler import (
     CodeGeneratorResponseFeature,
     CodeGeneratorResponseFile,
 )
-from betterproto2_compiler.settings import Settings
+from betterproto2_compiler.settings import ClientGeneration, ServerGeneration, Settings
 
 from .compiler import outputfile_compiler
 from .models import (
@@ -60,8 +60,29 @@ def traverse(
 
 
 def get_settings(plugin_options: list[str]) -> Settings:
+    # Synchronous clients are suitable for most users
+    client_generation = ClientGeneration.SYNC
+    server_generation = ServerGeneration.NONE
+
+    for opt in plugin_options:
+        if opt.startswith("client_generation="):
+            name = opt.split("=")[1]
+            try:
+                client_generation = ClientGeneration(name)
+            except ValueError:
+                raise ValueError(f"Invalid client_generation option: {name}")
+
+        if opt.startswith("server_generation="):
+            name = opt.split("=")[1]
+            try:
+                server_generation = ServerGeneration(name)
+            except ValueError:
+                raise ValueError(f"Invalid server_generation option: {name}")
+
     return Settings(
         pydantic_dataclasses="pydantic_dataclasses" in plugin_options,
+        client_generation=client_generation,
+        server_generation=server_generation,
     )
 
 

betterproto2_compiler/settings.py

@@ -1,6 +1,73 @@
+import sys
 from dataclasses import dataclass
 
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from strenum import StrEnum
+
+
+class ClientGeneration(StrEnum):
+    NONE = "none"
+    """Clients are not generated."""
+
+    SYNC = "sync"
+    """Only synchronous clients are generated."""
+
+    ASYNC = "async"
+    """Only asynchronous clients are generated."""
+
+    SYNC_ASYNC = "sync_async"
+    """Both synchronous and asynchronous clients are generated.
+
+    Asynchronous clients are generated with the Async suffix."""
+
+    ASYNC_SYNC = "async_sync"
+    """Both synchronous and asynchronous clients are generated.
+
+    Synchronous clients are generated with the Sync suffix."""
+
+    SYNC_ASYNC_NO_DEFAULT = "sync_async_no_default"
+    """Both synchronous and asynchronous clients are generated.
+
+    Synchronous clients are generated with the Sync suffix, and asynchronous clients are generated with the Async
+    suffix."""
+
+    @property
+    def is_sync_generated(self) -> bool:
+        return self in {
+            ClientGeneration.SYNC,
+            ClientGeneration.SYNC_ASYNC,
+            ClientGeneration.ASYNC_SYNC,
+            ClientGeneration.SYNC_ASYNC_NO_DEFAULT,
+        }
+
+    @property
+    def is_async_generated(self) -> bool:
+        return self in {
+            ClientGeneration.ASYNC,
+            ClientGeneration.SYNC_ASYNC,
+            ClientGeneration.ASYNC_SYNC,
+            ClientGeneration.SYNC_ASYNC_NO_DEFAULT,
+        }
+
+    @property
+    def is_sync_prefixed(self) -> bool:
+        return self in {ClientGeneration.ASYNC_SYNC, ClientGeneration.SYNC_ASYNC_NO_DEFAULT}
+
+    @property
+    def is_async_prefixed(self) -> bool:
+        return self in {ClientGeneration.SYNC_ASYNC, ClientGeneration.SYNC_ASYNC_NO_DEFAULT}
+
+
+class ServerGeneration(StrEnum):
+    NONE = "none"
+    ASYNC = "async"
+
 
 @dataclass
 class Settings:
     pydantic_dataclasses: bool
+
+    client_generation: ClientGeneration
+    server_generation: ServerGeneration

betterproto2_compiler/templates/header.py.j2

@@ -18,10 +18,12 @@ __all__ = (
     {%- endfor -%}
 )
 
+import re
 import builtins
 import datetime
+import dateutil.parser
 import warnings
-from collections.abc import AsyncIterable, AsyncIterator, Iterable
+from collections.abc import AsyncIterable, AsyncIterator, Iterable, Iterator
 import typing
 from typing import TYPE_CHECKING
 
@@ -33,10 +35,9 @@ from dataclasses import dataclass
 {% endif %}
 
 import betterproto2
-{% if output_file.services %}
 from betterproto2.grpc.grpclib_server import ServiceBase
+import grpc
 import grpclib
-{% endif %}
 
 {# Import the message pool of the generated code. #}
 {% if output_file.package %}

betterproto2_compiler/templates/service_stub.py.j2

@@ -0,0 +1,32 @@
+class {% block class_name %}{% endblock %}({% block inherit_from %}{% endblock %}):
+    {% block service_docstring scoped %}
+    {% if service.comment %}
+    """
+    {{ service.comment | indent(4) }}
+    """
+    {% elif not service.methods %}
+    pass
+    {% endif %}
+    {% endblock %}
+
+    {% block class_content %}{% endblock %}
+
+    {% for method in service.methods %}
+    {% block method_definition scoped required %}{% endblock %}
+        {% block method_docstring scoped %}
+        {% if method.comment %}
+        """
+        {{ method.comment | indent(8) }}
+        """
+        {% endif %}
+        {% endblock %}
+
+        {% block deprecation_warning scoped %}
+        {% if method.deprecated %}
+        warnings.warn("{{ service.py_name }}.{{ method.py_name }} is deprecated", DeprecationWarning)
+        {% endif %}
+        {% endblock %}
+
+        {% block method_body scoped required %}{% endblock %}
+
+    {% endfor %}

betterproto2_compiler/templates/service_stub_async.py.j2

@@ -0,0 +1,86 @@
+{% extends "service_stub.py.j2" %}
+
+{# Class definition #}
+{% block class_name %}{{ service.py_name }}{% if output_file.settings.client_generation.is_async_prefixed %}Async{% endif %}Stub{% endblock %}
+{% block inherit_from %}betterproto2.ServiceStub{% endblock %}
+
+{# Methods definition #}
+{% block method_definition %}
+    async def {{ method.py_name }}(self
+        {%- if not method.client_streaming -%}
+            , message:
+                {%- if method.is_input_msg_empty -%}
+                    "{{ method.py_input_message_type }} | None" = None
+                {%- else -%}
+                    "{{ method.py_input_message_type }}"
+                {%- endif -%}
+        {%- else -%}
+            {# Client streaming: need a request iterator instead #}
+            , messages: "AsyncIterable[{{ method.py_input_message_type }}] | Iterable[{{ method.py_input_message_type }}]"
+        {%- endif -%}
+            ,
+            *
+            , timeout: "float | None" = None
+            , deadline: "Deadline | None" = None
+            , metadata: "MetadataLike | None" = None
+            ) -> "{% if method.server_streaming %}AsyncIterator[{{ method.py_output_message_type }}]{% else %}{{ method.py_output_message_type }}{% endif %}":
+{% endblock %}
+
+{% block method_body %}
+    {% if method.server_streaming %}
+      {% if method.client_streaming %}
+        async for response in self._stream_stream(
+            "{{ method.route }}",
+            messages,
+            {{ method.py_input_message_type }},
+            {{ method.py_output_message_type }},
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        ):
+            yield response
+      {% else %}
+        {% if method.is_input_msg_empty %}
+        if message is None:
+            message = {{ method.py_input_message_type }}()
+
+        {% endif %}
+        async for response in self._unary_stream(
+            "{{ method.route }}",
+            message,
+            {{ method.py_output_message_type }},
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        ):
+            yield response
+
+      {% endif %}
+    {% else %}
+      {% if method.client_streaming %}
+        return await self._stream_unary(
+            "{{ method.route }}",
+            messages,
+            {{ method.py_input_message_type }},
+            {{ method.py_output_message_type }},
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+      {% else %}
+        {% if method.is_input_msg_empty %}
+        if message is None:
+            message = {{ method.py_input_message_type }}()
+
+        {% endif %}
+        return await self._unary_unary(
+            "{{ method.route }}",
+            message,
+            {{ method.py_output_message_type }},
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+      {% endif %}
+    {% endif %}
+{% endblock %}

betterproto2_compiler/templates/service_stub_sync.py.j2

@@ -0,0 +1,72 @@
+{% extends "service_stub.py.j2" %}
+
+{# Class definition #}
+{% block class_name %}{{ service.py_name }}{% if output_file.settings.client_generation.is_sync_prefixed %}Sync{% endif %}Stub{% endblock %}
+
+{% block class_content %}
+    {# TODO move to parent class #}
+    def __init__(self, channel: grpc.Channel):
+        self._channel = channel
+{% endblock %}
+
+{# Methods definition #}
+{% block method_definition %}
+    def {{ method.py_name }}(self
+        {%- if not method.client_streaming -%}
+            , message:
+                {%- if method.is_input_msg_empty -%}
+                    "{{ method.py_input_message_type }} | None" = None
+                {%- else -%}
+                    "{{ method.py_input_message_type }}"
+                {%- endif -%}
+        {%- else -%}
+            {# Client streaming: need a request iterator instead #}
+            , messages: "Iterable[{{ method.py_input_message_type }}]"
+        {%- endif -%}
+            ) -> "{% if method.server_streaming %}Iterator[{{ method.py_output_message_type }}]{% else %}{{ method.py_output_message_type }}{% endif %}":
+{% endblock %}
+
+{% block method_body %}
+    {% if method.server_streaming %}
+      {% if method.client_streaming %}
+        for response in self._channel.stream_stream(
+            "{{ method.route }}",
+            {{ method.py_input_message_type }}.SerializeToString,
+            {{ method.py_output_message_type }}.FromString,
+        )(iter(messages)):
+            yield response
+      {% else %}
+        {% if method.is_input_msg_empty %}
+        if message is None:
+            message = {{ method.py_input_message_type }}()
+
+        {% endif %}
+        for response in self._channel.unary_stream(
+            "{{ method.route }}",
+            {{ method.py_input_message_type }}.SerializeToString,
+            {{ method.py_output_message_type }}.FromString,
+        )(message):
+            yield response
+
+      {% endif %}
+    {% else %}
+      {% if method.client_streaming %}
+        return self._channel.stream_unary(
+            "{{ method.route }}",
+            {{ method.py_input_message_type }}.SerializeToString,
+            {{ method.py_output_message_type }}.FromString,
+        )(iter(messages))
+      {% else %}
+        {% if method.is_input_msg_empty %}
+        if message is None:
+            message = {{ method.py_input_message_type }}()
+
+        {% endif %}
+        return self._channel.unary_unary(
+            "{{ method.route }}",
+            {{ method.py_input_message_type }}.SerializeToString,
+            {{ method.py_output_message_type }}.FromString,
+        )(message)
+      {% endif %}
+    {% endif %}
+{% endblock %}