betterproto2-compiler 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

betterproto2_compiler/compile/importing.py

@@ -55,6 +55,32 @@ def parse_source_type_name(field_type_name: str, request: PluginRequestCompiler)
     raise ValueError(f"can't find type name: {field_type_name}")
 
 
+def get_symbol_reference(
+    *,
+    package: str,
+    imports: set,
+    source_package: str,
+    symbol: str,
+) -> tuple[str, str | None]:
+    """
+    Return a Python symbol within a proto package. Adds the import if
+    necessary and returns it as well for usage. Unwraps well known type if required.
+    """
+    current_package: list[str] = package.split(".") if package else []
+    py_package: list[str] = source_package.split(".") if source_package else []
+
+    if py_package == current_package:
+        return (reference_sibling(symbol), None)
+
+    if py_package[: len(current_package)] == current_package:
+        return reference_descendent(current_package, imports, py_package, symbol)
+
+    if current_package[: len(py_package)] == py_package:
+        return reference_ancestor(current_package, imports, py_package, symbol)
+
+    return reference_cousin(current_package, imports, py_package, symbol)
+
+
 def get_type_reference(
     *,
     package: str,
@@ -73,30 +99,25 @@ def get_type_reference(
     if wrap and (source_package, source_type) in WRAPPED_TYPES:
         return WRAPPED_TYPES[(source_package, source_type)]
 
-    current_package: list[str] = package.split(".") if package else []
-    py_package: list[str] = source_package.split(".") if source_package else []
     py_type: str = pythonize_class_name(source_type)
-
-    if py_package == current_package:
-        return reference_sibling(py_type)
-
-    if py_package[: len(current_package)] == current_package:
-        return reference_descendent(current_package, imports, py_package, py_type)
-
-    if current_package[: len(py_package)] == py_package:
-        return reference_ancestor(current_package, imports, py_package, py_type)
-
-    return reference_cousin(current_package, imports, py_package, py_type)
+    (ref, _) = get_symbol_reference(
+        package=package,
+        imports=imports,
+        source_package=source_package,
+        symbol=py_type,
+    )
+    return ref
 
 
-def reference_absolute(imports: set[str], py_package: list[str], py_type: str) -> str:
+def reference_absolute(imports: set[str], py_package: list[str], py_type: str) -> tuple[str, str]:
     """
     Returns a reference to a python type located in the root, i.e. sys.path.
     """
     string_import = ".".join(py_package)
     string_alias = "__".join([safe_snake_case(name) for name in py_package])
-    imports.add(f"import {string_import} as {string_alias}")
-    return f"{string_alias}.{py_type}"
+    import_to_add = f"import {string_import} as {string_alias}"
+    imports.add(import_to_add)
+    return (f"{string_alias}.{py_type}", import_to_add)
 
 
 def reference_sibling(py_type: str) -> str:
@@ -106,7 +127,9 @@ def reference_sibling(py_type: str) -> str:
     return f"{py_type}"
 
 
-def reference_descendent(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
+def reference_descendent(
+    current_package: list[str], imports: set[str], py_package: list[str], py_type: str
+) -> tuple[str, str]:
     """
     Returns a reference to a python type in a package that is a descendent of the
     current package, and adds the required import that is aliased to avoid name
@@ -116,15 +139,19 @@ def reference_descendent(current_package: list[str], imports: set[str], py_packa
     string_from = ".".join(importing_descendent[:-1])
     string_import = importing_descendent[-1]
     if string_from:
-        string_alias = "_".join(importing_descendent)
-        imports.add(f"from .{string_from} import {string_import} as {string_alias}")
-        return f"{string_alias}.{py_type}"
+        string_alias = f"{'_'.join(importing_descendent)}"
+        import_to_add = f"from .{string_from} import {string_import} as {string_alias}"
+        imports.add(import_to_add)
+        return (f"{string_alias}.{py_type}", import_to_add)
     else:
-        imports.add(f"from . import {string_import}")
-        return f"{string_import}.{py_type}"
+        import_to_add = f"from . import {string_import}"
+        imports.add(import_to_add)
+        return (f"{string_import}.{py_type}", import_to_add)
 
 
-def reference_ancestor(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
+def reference_ancestor(
+    current_package: list[str], imports: set[str], py_package: list[str], py_type: str
+) -> tuple[str, str]:
     """
     Returns a reference to a python type in a package which is an ancestor to the
     current package, and adds the required import that is aliased (if possible) to avoid
@@ -137,15 +164,19 @@ def reference_ancestor(current_package: list[str], imports: set[str], py_package
         string_import = py_package[-1]
         string_alias = f"_{'_' * distance_up}{string_import}__"
         string_from = f"..{'.' * distance_up}"
-        imports.add(f"from {string_from} import {string_import} as {string_alias}")
-        return f"{string_alias}.{py_type}"
+        import_to_add = f"from {string_from} import {string_import} as {string_alias}"
+        imports.add(import_to_add)
+        return (f"{string_alias}.{py_type}", import_to_add)
     else:
         string_alias = f"{'_' * distance_up}{py_type}__"
-        imports.add(f"from .{'.' * distance_up} import {py_type} as {string_alias}")
-        return string_alias
+        import_to_add = f"from .{'.' * distance_up} import {py_type} as {string_alias}"
+        imports.add(import_to_add)
+        return (string_alias, import_to_add)
 
 
-def reference_cousin(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
+def reference_cousin(
+    current_package: list[str], imports: set[str], py_package: list[str], py_type: str
+) -> tuple[str, str]:
     """
     Returns a reference to a python type in a package that is not descendent, ancestor
     or sibling, and adds the required import that is aliased to avoid name conflicts.
@@ -161,5 +192,6 @@ def reference_cousin(current_package: list[str], imports: set[str], py_package:
         + "__".join([safe_snake_case(name) for name in py_package[len(shared_ancestry) :]])
         + "__"
     )
-    imports.add(f"from {string_from} import {string_import} as {string_alias}")
-    return f"{string_alias}.{py_type}"
+    import_to_add = f"from {string_from} import {string_import} as {string_alias}"
+    imports.add(import_to_add)
+    return (f"{string_alias}.{py_type}", import_to_add)

betterproto2_compiler/lib/google/protobuf/__init__.py

@@ -80,7 +80,7 @@ import dateutil.parser
 
 from ...message_pool import default_message_pool
 
-betterproto2.check_compiler_version("0.5.0")
+betterproto2.check_compiler_version("0.7.0")
 
 
 class FieldCardinality(betterproto2.Enum):

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

@@ -17,7 +17,7 @@ import betterproto2
 
 from ....message_pool import default_message_pool
 
-betterproto2.check_compiler_version("0.5.0")
+betterproto2.check_compiler_version("0.7.0")
 
 
 class CodeGeneratorResponseFeature(betterproto2.Enum):

betterproto2_compiler/plugin/compiler.py

@@ -33,17 +33,27 @@ def outputfile_compiler(output_file: OutputTemplate) -> str:
         loader=jinja2.FileSystemLoader(templates_folder),
         undefined=jinja2.StrictUndefined,
     )
-    # Load the body first so we have a compleate list of imports needed.
+
+    # List of the symbols that should appear in the `__all__` variable of the file
+    all: list[str] = []
+
+    def add_to_all(name: str) -> str:
+        all.append(name)
+        return name
+
+    env.filters["add_to_all"] = add_to_all
+
     body_template = env.get_template("template.py.j2")
     header_template = env.get_template("header.py.j2")
 
+    # Load the body first do know the symbols defined in the file
     code = body_template.render(output_file=output_file)
-    code = header_template.render(output_file=output_file, version=version) + "\n" + code
+    code = header_template.render(output_file=output_file, version=version, all=all) + "\n" + code
 
     try:
-        # Sort imports, delete unused ones
+        # Sort imports, delete unused ones, sort __all__
         code = subprocess.check_output(
-            ["ruff", "check", "--select", "I,F401,TCH005", "--fix", "--silent", "-"],
+            ["ruff", "check", "--select", "I,F401,TC005,RUF022", "--fix", "--silent", "-"],
             input=code,
             encoding="utf-8",
         )

betterproto2_compiler/plugin/models.py

@@ -53,6 +53,7 @@ from betterproto2_compiler.lib.google.protobuf import (
     MethodDescriptorProto,
     OneofDescriptorProto,
     ServiceDescriptorProto,
+    SourceCodeInfo,
 )
 from betterproto2_compiler.lib.google.protobuf.compiler import CodeGeneratorRequest
 from betterproto2_compiler.settings import Settings
@@ -216,6 +217,33 @@ class OutputTemplate:
         """
         return sorted([f.name for f in self.input_files])
 
+    def get_descriptor_name(self, source_file: FileDescriptorProto):
+        return f"{source_file.name.replace('/', '_').replace('.', '_').upper()}_DESCRIPTOR"
+
+    @property
+    def descriptors(self):
+        """Google protobuf library descriptors.
+
+        Returns
+        -------
+        str
+            A list of pool registrations for proto descriptors.
+        """
+        descriptors: list[str] = []
+
+        for f in self.input_files:
+            # Remove the source_code_info field since it is not needed at runtime.
+            source_code_info: SourceCodeInfo | None = f.source_code_info
+            f.source_code_info = None
+
+            descriptors.append(
+                f"{self.get_descriptor_name(f)} = default_google_proto_descriptor_pool.AddSerializedFile({bytes(f)})"
+            )
+
+            f.source_code_info = source_code_info
+
+        return "\n".join(descriptors)
+
 
 @dataclass(kw_only=True)
 class MessageCompiler(ProtoContentBase):
@@ -223,6 +251,7 @@ class MessageCompiler(ProtoContentBase):
 
     output_file: OutputTemplate
     proto_obj: DescriptorProto
+    prefixed_proto_name: str
     fields: list["FieldCompiler"] = field(default_factory=list)
     oneofs: list["OneofCompiler"] = field(default_factory=list)
     builtins_types: set[str] = field(default_factory=set)
@@ -233,7 +262,7 @@ class MessageCompiler(ProtoContentBase):
 
     @property
     def py_name(self) -> str:
-        return pythonize_class_name(self.proto_name)
+        return pythonize_class_name(self.prefixed_proto_name)
 
     @property
     def deprecated(self) -> bool:
@@ -266,6 +295,17 @@ class MessageCompiler(ProtoContentBase):
 
         return methods_source
 
+    @property
+    def descriptor_name(self) -> str:
+        """Google protobuf library descriptor name.
+
+        Returns
+        -------
+        str
+            The Python name of the descriptor to reference.
+        """
+        return self.output_file.get_descriptor_name(self.source_file)
+
 
 def is_map(proto_field_obj: FieldDescriptorProto, parent_message: DescriptorProto) -> bool:
     """True if proto_field_obj is a map, otherwise False."""
@@ -353,8 +393,7 @@ class FieldCompiler(ProtoContentBase):
 
     @property
     def field_type(self) -> FieldType:
-        # TODO it should be possible to remove constructor
-        return FieldType(self.proto_obj.type)
+        return self.proto_obj.type
 
     @property
     def packed(self) -> bool:
@@ -411,12 +450,46 @@ class FieldCompiler(ProtoContentBase):
     def unwrapped_py_type(self) -> str:
         return self._py_type(wrap=False)
 
+    @property
+    def annotations(self) -> list[str]:
+        """List of the Pydantic annotation to add to the field."""
+        assert self.output_file.settings.pydantic_dataclasses
+
+        annotations = []
+
+        if self.proto_obj.type in (FieldType.TYPE_INT32, FieldType.TYPE_SFIXED32, FieldType.TYPE_SINT32):
+            annotations.append("pydantic.Field(ge=-2**31, le=2**31 - 1)")
+
+        elif self.proto_obj.type in (FieldType.TYPE_UINT32, FieldType.TYPE_FIXED32):
+            annotations.append("pydantic.Field(ge=0, le=2**32 - 1)")
+
+        elif self.proto_obj.type in (FieldType.TYPE_INT64, FieldType.TYPE_SFIXED64, FieldType.TYPE_SINT64):
+            annotations.append("pydantic.Field(ge=-2**63, le=2**63 - 1)")
+
+        elif self.proto_obj.type in (FieldType.TYPE_UINT64, FieldType.TYPE_FIXED64):
+            annotations.append("pydantic.Field(ge=0, le=2**64 - 1)")
+
+        elif self.proto_obj.type == FieldType.TYPE_FLOAT:
+            annotations.append("pydantic.AfterValidator(betterproto2.validators.validate_float32)")
+
+        elif self.proto_obj.type == FieldType.TYPE_STRING:
+            annotations.append("pydantic.AfterValidator(betterproto2.validators.validate_string)")
+
+        return annotations
+
     @property
     def annotation(self) -> str:
         py_type = self.py_type
 
         if self.use_builtins:
             py_type = f"builtins.{py_type}"
+
+        # Add the pydantic annotation if needed
+        if self.output_file.settings.pydantic_dataclasses:
+            annotations = self.annotations
+            if annotations:
+                py_type = f"typing.Annotated[{py_type}, {', '.join(annotations)}]"
+
         if self.repeated:
             return f"list[{py_type}]"
         if self.optional:
@@ -529,6 +602,7 @@ class EnumDefinitionCompiler(ProtoContentBase):
 
     output_file: OutputTemplate
     proto_obj: EnumDescriptorProto
+    prefixed_proto_name: str
     entries: list["EnumDefinitionCompiler.EnumEntry"] = field(default_factory=list)
 
     @dataclass(unsafe_hash=True, kw_only=True)
@@ -556,12 +630,23 @@ class EnumDefinitionCompiler(ProtoContentBase):
 
     @property
     def py_name(self) -> str:
-        return pythonize_class_name(self.proto_name)
+        return pythonize_class_name(self.prefixed_proto_name)
 
     @property
     def deprecated(self) -> bool:
         return bool(self.proto_obj.options and self.proto_obj.options.deprecated)
 
+    @property
+    def descriptor_name(self) -> str:
+        """Google protobuf library descriptor name.
+
+        Returns
+        -------
+        str
+            The Python name of the descriptor to reference.
+        """
+        return self.output_file.get_descriptor_name(self.source_file)
+
 
 @dataclass(kw_only=True)
 class ServiceCompiler(ProtoContentBase):

betterproto2_compiler/plugin/parser.py

@@ -35,20 +35,21 @@ from .models import (
 
 def traverse(
     proto_file: FileDescriptorProto,
-) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int]], None, None]:
+) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int], str], None, None]:
     # Todo: Keep information about nested hierarchy
     def _traverse(
         path: list[int],
         items: list[EnumDescriptorProto] | list[DescriptorProto],
         prefix: str = "",
-    ) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int]], None, None]:
+    ) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int], str], None, None]:
         for i, item in enumerate(items):
             # Adjust the name since we flatten the hierarchy.
-            # Todo: don't change the name, but include full name in returned tuple
             should_rename = not isinstance(item, DescriptorProto) or not item.options or not item.options.map_entry
 
-            item.name = next_prefix = f"{prefix}.{item.name}" if prefix and should_rename else item.name
-            yield item, [*path, i]
+            # Record prefixed name but *do not* mutate original file.
+            # We use this prefixed name to create pythonized names.
+            prefixed_name = next_prefix = f"{prefix}.{item.name}" if prefix and should_rename else item.name
+            yield item, [*path, i], prefixed_name
 
             if isinstance(item, DescriptorProto):
                 # Get nested types.
@@ -81,6 +82,7 @@ def get_settings(plugin_options: list[str]) -> Settings:
 
     return Settings(
         pydantic_dataclasses="pydantic_dataclasses" in plugin_options,
+        google_protobuf_descriptors="google_protobuf_descriptors" in plugin_options,
         client_generation=client_generation,
         server_generation=server_generation,
     )
@@ -109,12 +111,13 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
     # get the references to input/output messages for each service
     for output_package_name, output_package in request_data.output_packages.items():
         for proto_input_file in output_package.input_files:
-            for item, path in traverse(proto_input_file):
+            for item, path, prefixed_proto_name in traverse(proto_input_file):
                 read_protobuf_type(
                     source_file=proto_input_file,
                     item=item,
                     path=path,
                     output_package=output_package,
+                    prefixed_proto_name=prefixed_proto_name,
                 )
 
     # Read Services
@@ -168,6 +171,15 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
         )
     )
 
+    if settings.google_protobuf_descriptors:
+        response.file.append(
+            CodeGeneratorResponseFile(
+                name="google_proto_descriptor_pool.py",
+                content="from google.protobuf import descriptor_pool\n\n"
+                + "default_google_proto_descriptor_pool = descriptor_pool.DescriptorPool()\n",
+            )
+        )
+
     for output_package_name in sorted(output_paths.union(init_files)):
         print(f"Writing {output_package_name}", file=sys.stderr)
 
@@ -179,6 +191,7 @@ def read_protobuf_type(
     path: list[int],
     source_file: "FileDescriptorProto",
     output_package: OutputTemplate,
+    prefixed_proto_name: str,
 ) -> None:
     if isinstance(item, DescriptorProto):
         if item.options and item.options.map_entry:
@@ -188,10 +201,11 @@ def read_protobuf_type(
         message_data = MessageCompiler(
             source_file=source_file,
             output_file=output_package,
+            prefixed_proto_name=prefixed_proto_name,
             proto_obj=item,
             path=path,
         )
-        output_package.messages[message_data.proto_name] = message_data
+        output_package.messages[message_data.prefixed_proto_name] = message_data
 
         for index, field in enumerate(item.field):
             if is_map(field, item):
@@ -243,10 +257,11 @@ def read_protobuf_type(
         enum = EnumDefinitionCompiler(
             source_file=source_file,
             output_file=output_package,
+            prefixed_proto_name=prefixed_proto_name,
             proto_obj=item,
             path=path,
         )
-        output_package.enums[enum.proto_name] = enum
+        output_package.enums[enum.prefixed_proto_name] = enum
 
 
 def read_protobuf_service(

betterproto2_compiler/settings.py

@@ -68,6 +68,7 @@ class ServerGeneration(StrEnum):
 @dataclass
 class Settings:
     pydantic_dataclasses: bool
+    google_protobuf_descriptors: bool
 
     client_generation: ClientGeneration
     server_generation: ServerGeneration

betterproto2_compiler/templates/header.py.j2

@@ -6,15 +6,8 @@
 # This file has been @generated
 
 __all__ = (
-    {% for _, enum in output_file.enums|dictsort(by="key") %}
-        "{{ enum.py_name }}",
-    {%- endfor -%}
-    {% for _, message in output_file.messages|dictsort(by="key") %}
-        "{{ message.py_name }}",
-    {%- endfor -%}
-    {% for _, service in output_file.services|dictsort(by="key") %}
-        "{{ service.py_name }}Stub",
-        "{{ service.py_name }}Base",
+    {%- for name in all -%}
+    "{{ name }}",
     {%- endfor -%}
 )
 
@@ -28,6 +21,7 @@ import typing
 from typing import TYPE_CHECKING
 
 {% if output_file.settings.pydantic_dataclasses %}
+import pydantic
 from pydantic.dataclasses import dataclass
 from pydantic import model_validator
 {%- else -%}
@@ -38,12 +32,19 @@ import betterproto2
 from betterproto2.grpc.grpclib_server import ServiceBase
 import grpc
 import grpclib
+from google.protobuf.descriptor import Descriptor, EnumDescriptor
 
 {# Import the message pool of the generated code. #}
 {% if output_file.package %}
 from {{ "." * output_file.package.count(".") }}..message_pool import default_message_pool
+{% if output_file.settings.google_protobuf_descriptors %}
+from {{ "." * output_file.package.count(".") }}..google_proto_descriptor_pool import default_google_proto_descriptor_pool
+{% endif %}
 {% else %}
 from .message_pool import default_message_pool
+{% if output_file.settings.google_protobuf_descriptors %}
+from .google_proto_descriptor_pool import default_google_proto_descriptor_pool
+{% endif %}
 {% endif %}
 
 if TYPE_CHECKING:
@@ -51,4 +52,5 @@ if TYPE_CHECKING:
     from betterproto2.grpc.grpclib_client import MetadataLike
     from grpclib.metadata import Deadline
 
-betterproto2.check_compiler_version("{{ version }}")
+_COMPILER_VERSION="{{ version }}"
+betterproto2.check_compiler_version(_COMPILER_VERSION)

betterproto2_compiler/templates/service_stub.py.j2

@@ -1,4 +1,4 @@
-class {% block class_name %}{% endblock %}({% block inherit_from %}{% endblock %}):
+class {% filter add_to_all %}{% block class_name %}{% endblock %}{% endfilter %}({% block inherit_from %}{% endblock %}):
     {% block service_docstring scoped %}
     {% if service.comment %}
     """

betterproto2_compiler/templates/template.py.j2

@@ -1,11 +1,18 @@
 {% for _, enum in output_file.enums|dictsort(by="key") %}
-class {{ enum.py_name }}(betterproto2.Enum):
+class {{ enum.py_name | add_to_all }}(betterproto2.Enum):
     {% if enum.comment %}
     """
     {{ enum.comment | indent(4) }}
     """
     {% endif %}
 
+    {% if output_file.settings.google_protobuf_descriptors %}
+    {# Add descriptor class property to be more drop-in compatible with other libraries. #}
+    @betterproto2.classproperty
+    def DESCRIPTOR(self) -> EnumDescriptor:
+        return {{ enum.descriptor_name }}.enum_types_by_name['{{ enum.prefixed_proto_name }}']
+    {% endif %}
+
     {% for entry in enum.entries %}
     {{ entry.name }} = {{ entry.value }}
     {% if entry.comment %}
@@ -31,7 +38,7 @@ class {{ enum.py_name }}(betterproto2.Enum):
 {% else %}
 @dataclass(eq=False, repr=False)
 {% endif %}
-class {{ message.py_name }}(betterproto2.Message):
+class {{ message.py_name | add_to_all }}(betterproto2.Message):
     {% if message.comment or message.oneofs %}
     """
     {{ message.comment | indent(4) }}
@@ -45,6 +52,13 @@ class {{ message.py_name }}(betterproto2.Message):
     """
     {% endif %}
 
+    {% if output_file.settings.google_protobuf_descriptors %}
+    {# Add descriptor class property to be more drop-in compatible with other libraries. #}
+    @betterproto2.classproperty
+    def DESCRIPTOR(self) -> Descriptor:
+        return {{ message.descriptor_name }}.message_types_by_name['{{ message.prefixed_proto_name }}']
+    {% endif %}
+
     {% for field in message.fields %}
     {{ field.get_field_string() }}
     {% if field.comment %}
@@ -81,7 +95,7 @@ class {{ message.py_name }}(betterproto2.Message):
     {{ method_source }}
     {% endfor %}
 
-default_message_pool.register_message("{{ output_file.package }}", "{{ message.proto_name }}", {{ message.py_name }})
+default_message_pool.register_message("{{ output_file.package }}", "{{ message.prefixed_proto_name }}", {{ message.py_name }})
 
 
 {% endfor %}
@@ -102,9 +116,14 @@ default_message_pool.register_message("{{ output_file.package }}", "{{ message.p
 {{ i }}
 {% endfor %}
 
+{% if output_file.settings.google_protobuf_descriptors %}
+{# Add descriptors to Google protobuf's default pool to be more drop-in compatible with other libraries. #}
+{{ output_file.descriptors }}
+{% endif %}
+
 {% if output_file.settings.server_generation == "async" %}
 {% for _, service in output_file.services|dictsort(by="key") %}
-class {{ service.py_name }}Base(ServiceBase):
+class {{ (service.py_name + "Base") | add_to_all }}(ServiceBase):
     {% if service.comment %}
     """
     {{ service.comment | indent(4) }}
@@ -127,6 +146,10 @@ class {{ service.py_name }}Base(ServiceBase):
         {% endif %}
 
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+        {% if method.server_streaming %}
+        {# yielding here changes the return type from a coroutine to an async_generator #}
+        yield {{ method.py_output_message_type }}()
+        {% endif %}
 
     {% endfor %}
 

betterproto2_compiler-0.7.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: betterproto2_compiler
+Version: 0.7.0
+Summary: Compiler for betterproto2
+Project-URL: Documentation, https://betterproto.github.io/python-betterproto2/
+Project-URL: Repository, https://github.com/betterproto/python-betterproto2
+Author-email: Adrien Vannson <adrien.vannson@protonmail.com>, "Daniel G. Taylor" <danielgtaylor@gmail.com>
+License-Expression: MIT
+Keywords: compiler,gRPC,protobuf
+Requires-Python: <4.0,>=3.10
+Requires-Dist: betterproto2[grpclib]<0.8,>=0.7.0
+Requires-Dist: jinja2>=3.0.3
+Requires-Dist: ruff~=0.9.3
+Requires-Dist: strenum<0.5,>=0.4.15; python_version == '3.10'
+Requires-Dist: typing-extensions<5,>=4.7.1

{betterproto2_compiler-0.5.1.dist-info → betterproto2_compiler-0.7.0.dist-info}/RECORD

@@ -1,7 +1,9 @@
 betterproto2_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 betterproto2_compiler/casing.py,sha256=HSXLXAOqZzEnu-tC1SZjpW0LIjzdPqUNJEwy1BHzfgg,3056
+betterproto2_compiler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/settings.py,sha256=Y867wBQad2EunzlsZEd0OjPaXGwzqcBmPKYMG9Q_2Dw,2014
 betterproto2_compiler/compile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-betterproto2_compiler/compile/importing.py,sha256=cJZ1BqjSHaDwXlfseH7f73pMnBZTiqLyOQfQfyganVM,6256
+betterproto2_compiler/compile/importing.py,sha256=yfIJ7oEXR1Ghe5meGzOE0ORf1Sr7Xa2Pr_slOw-rT3s,7137
 betterproto2_compiler/compile/naming.py,sha256=zf0VOmNojzyv33upOGelGxjZTEDE8JULEEED5_3inHg,562
 betterproto2_compiler/known_types/__init__.py,sha256=nrWckuv4hGhL8-tW7V5TD5qXs1Sa5vC7zMusGnz7jsE,3485
 betterproto2_compiler/known_types/any.py,sha256=E3OoAoUU9xrGHmYEvF0YnrwQdTUuY4h54XbKU0eGxQ8,1897
@@ -9,27 +11,24 @@ betterproto2_compiler/known_types/duration.py,sha256=M-qsFeiHsw5Z_AoSata1ZUjfkho
 betterproto2_compiler/known_types/google_values.py,sha256=7JoPXVs6cVg_ihIWlWIDElSSuW0BymRnPHerz1bFuH4,6688
 betterproto2_compiler/known_types/timestamp.py,sha256=y1sNWG2Q0FWv6nIte1UTifFVCsryp7T8foXZqp4qhQQ,3409
 betterproto2_compiler/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-betterproto2_compiler/lib/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-betterproto2_compiler/lib/google/protobuf/__init__.py,sha256=yC7k_A1XA9-CPzhIaJfWJSIBpqyaLx7IVVuvXrqD-iQ,102114
-betterproto2_compiler/lib/google/protobuf/compiler/__init__.py,sha256=IriT5naeEkcxA-R2EpzOGBMLVGgVO6CXqvrR8HVaR28,9600
 betterproto2_compiler/lib/message_pool.py,sha256=4-cRhhiM6bmfpUJZ8qxc8LEyqHBHpLCcotjbyZxl7JM,71
+betterproto2_compiler/lib/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/lib/google/protobuf/__init__.py,sha256=r5R69Q9iYg8FZX6J6pCY6xnOTxgl_-zz2Xwn4uGGPyw,102114
+betterproto2_compiler/lib/google/protobuf/compiler/__init__.py,sha256=SaJT2xsLVFPvTd12R2V2wjEWeP4JewKMPJlIKeyZ2Mk,9600
 betterproto2_compiler/plugin/__init__.py,sha256=L3pW0b4CvkM5x53x_sYt1kYiSFPO0_vaeH6EQPq9FAM,43
 betterproto2_compiler/plugin/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
-betterproto2_compiler/plugin/compiler.py,sha256=3sPbCtdzjAGftVvoGe5dvxE8uTzJ78hABA-_f-1rEUo,2471
+betterproto2_compiler/plugin/compiler.py,sha256=9jZcNlwxWLUQlZyCLKG33P2xCoJgqaIQHIgcZM40JGY,2730
 betterproto2_compiler/plugin/main.py,sha256=b1jDEdG1Iau-4cPq89uSjU0SHwC278SxqwiuFwIF8fA,1288
-betterproto2_compiler/plugin/models.py,sha256=rzCKsdoV-0QCwmRN82x2QZ6029W9EAAJCFbLGMkVoz8,22215
+betterproto2_compiler/plugin/models.py,sha256=gZ0nIvZbmHJ6OKyQ0gEsbZ1DRicABIOLMge1nyFkOCY,25212
 betterproto2_compiler/plugin/module_validation.py,sha256=JnP8dSN83eJJVDP_UPJsHzq7E7Md3lah0PnKXDbFW5Q,4808
-betterproto2_compiler/plugin/parser.py,sha256=XJd7n78E6Gnv04L1faGyTCOV3v0sv1eD5-AenNhPDMQ,10197
+betterproto2_compiler/plugin/parser.py,sha256=GHVZGpC_lxvQRGgDaJTCS4ab9sUST7XAef2wj2UKqOg,10966
 betterproto2_compiler/plugin/plugin.bat,sha256=lfLT1WguAXqyerLLsRL6BfHA0RqUE6QG79v-1BYVSpI,48
-betterproto2_compiler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-betterproto2_compiler/settings.py,sha256=ggLU8qYTTACwdNN94cSznQchu-fJSJxZz041FXRwq7Y,1976
-betterproto2_compiler/templates/header.py.j2,sha256=nTUJ-BioeTTCrEr2ZbxPPUl6iBqHOxXr_NAVOGa8jYg,1622
-betterproto2_compiler/templates/service_stub.py.j2,sha256=r0AefgNbDCh-iDgFNV7aNx8fNe5kQY-8TNew-T_tUXc,929
+betterproto2_compiler/templates/header.py.j2,sha256=4C88YH5jtEzlBcUP054rk6lK5pQ1n5_TCzlH_3VrztY,1754
+betterproto2_compiler/templates/service_stub.py.j2,sha256=2fhbty6uw57EyxOskGcNlZjIjGELMKWY--pvq5ZEjFw,967
 betterproto2_compiler/templates/service_stub_async.py.j2,sha256=JNOAa8FPhzYS5D0zi0DPESVEwAjkdFsVQZ008Qi4JmE,2968
 betterproto2_compiler/templates/service_stub_sync.py.j2,sha256=V7HJIQJEgivX8VEBt7Ju6cXG5FeeCY9QyYMy1kicElM,2642
-betterproto2_compiler/templates/template.py.j2,sha256=kP1TMTK7BCv6sEFTGXPZs_jg39lC_IdvKTFWPHm8BgU,5415
-betterproto2_compiler-0.5.1.dist-info/LICENSE.md,sha256=Pgl2pReU-2yw2miGeQ55UFlyzqAZ_EpYVyZ2nWjwRv4,1121
-betterproto2_compiler-0.5.1.dist-info/METADATA,sha256=7wZ7cc4n5R4S9lnl2jBYY89Hib9WynJySv0zFk_3zjM,1225
-betterproto2_compiler-0.5.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-betterproto2_compiler-0.5.1.dist-info/entry_points.txt,sha256=re3Qg8lLljbVobeeKH2f1FVQZ114wfZkGv3zCZTD8Ok,84
-betterproto2_compiler-0.5.1.dist-info/RECORD,,
+betterproto2_compiler/templates/template.py.j2,sha256=1leU6V5AmlgPvKYCjBYYeVPAnfvcDrl9KQHgiuNiigo,6572
+betterproto2_compiler-0.7.0.dist-info/METADATA,sha256=rHB3App3Zkmtp7OKB8vlesiZRaz7Ba7tdb5XzwSA5wk,658
+betterproto2_compiler-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+betterproto2_compiler-0.7.0.dist-info/entry_points.txt,sha256=MXDaz7YfiaWx8KiSzArjUPLt6eTlMRbqzE4jCjXozuI,85
+betterproto2_compiler-0.7.0.dist-info/RECORD,,

{betterproto2_compiler-0.5.1.dist-info → betterproto2_compiler-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

betterproto2_compiler-0.7.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+protoc-gen-python_betterproto2 = betterproto2_compiler.plugin:main

betterproto2_compiler-0.5.1.dist-info/LICENSE.md

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Daniel G. Taylor
-Copyright (c) 2024 The betterproto contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

betterproto2_compiler-0.5.1.dist-info/METADATA

@@ -1,36 +0,0 @@
-Metadata-Version: 2.3
-Name: betterproto2_compiler
-Version: 0.5.1
-Summary: Compiler for betterproto2
-License: MIT
-Keywords: protobuf,gRPC,compiler
-Author: Adrien Vannson
-Author-email: adrien.vannson@protonmail.com
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: betterproto2[grpclib] (>=0.5.1,<0.6.0)
-Requires-Dist: jinja2 (>=3.0.3)
-Requires-Dist: ruff (>=0.9.3,<0.10.0)
-Requires-Dist: strenum (>=0.4.15,<0.5.0) ; python_version == "3.10"
-Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
-Project-URL: Documentation, https://betterproto.github.io/python-betterproto2-compiler/
-Project-URL: Repository, https://github.com/betterproto/python-betterproto2-compiler
-Description-Content-Type: text/markdown
-
-# Betterproto2 compiler
-
-![](https://github.com/betterproto/python-betterproto2-compiler/actions/workflows/ci.yml/badge.svg)
-
-
-
-## License
-
-Copyright © 2019 Daniel G. Taylor
-
-Copyright © 2024 The betterproto contributors
-

betterproto2_compiler-0.5.1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-protoc-gen-python_betterproto2=betterproto2_compiler.plugin:main
-