betterproto2-compiler 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

betterproto2_compiler/plugin/models.py

@@ -31,36 +31,32 @@ reference to `A` to `B`'s `fields` attribute.
 
 import builtins
 import re
+from collections.abc import Iterable, Iterator
 from dataclasses import (
     dataclass,
     field,
 )
 from typing import (
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Type,
     Union,
 )
 
 import betterproto2
-
-from betterproto2_compiler.compile.naming import (
-    pythonize_class_name,
-    pythonize_field_name,
-    pythonize_method_name,
-)
-from betterproto2_compiler.lib.google.protobuf import (
+from betterproto2.lib.google.protobuf import (
     DescriptorProto,
     EnumDescriptorProto,
     FieldDescriptorProto,
     FieldDescriptorProtoLabel,
     FieldDescriptorProtoType,
+    FieldDescriptorProtoType as FieldType,
     FileDescriptorProto,
     MethodDescriptorProto,
+    OneofDescriptorProto,
+)
+
+from betterproto2_compiler.compile.naming import (
+    pythonize_class_name,
+    pythonize_field_name,
+    pythonize_method_name,
 )
 from betterproto2_compiler.lib.google.protobuf.compiler import CodeGeneratorRequest
 
@@ -122,31 +118,9 @@ PROTO_PACKED_TYPES = (
 )
 
 
-# TODO patch again to make field optional
-# def monkey_patch_oneof_index():
-#     """
-#     The compiler message types are written for proto2, but we read them as proto3.
-#     For this to work in the case of the oneof_index fields, which depend on being able
-#     to tell whether they were set, we have to treat them as oneof fields. This method
-#     monkey patches the generated classes after the fact to force this behaviour.
-#     """
-#     object.__setattr__(
-#         FieldDescriptorProto.__dataclass_fields__["oneof_index"].metadata[
-#             "betterproto"
-#         ],
-#         "group",
-#         "oneof_index",
-#     )
-#     object.__setattr__(
-#         Field.__dataclass_fields__["oneof_index"].metadata["betterproto"],
-#         "group",
-#         "oneof_index",
-#     )
-
-
 def get_comment(
     proto_file: "FileDescriptorProto",
-    path: List[int],
+    path: list[int],
 ) -> str:
     for sci_loc in proto_file.source_code_info.location:
         if list(sci_loc.path) == path:
@@ -182,10 +156,10 @@ class ProtoContentBase:
 
     source_file: FileDescriptorProto
     typing_compiler: TypingCompiler
-    path: List[int]
+    path: list[int]
     parent: Union["betterproto2.Message", "OutputTemplate"]
 
-    __dataclass_fields__: Dict[str, object]
+    __dataclass_fields__: dict[str, object]
 
     def __post_init__(self) -> None:
         """Checks that no fake default fields were left as placeholders."""
@@ -225,10 +199,10 @@ class ProtoContentBase:
 @dataclass
 class PluginRequestCompiler:
     plugin_request_obj: CodeGeneratorRequest
-    output_packages: Dict[str, "OutputTemplate"] = field(default_factory=dict)
+    output_packages: dict[str, "OutputTemplate"] = field(default_factory=dict)
 
     @property
-    def all_messages(self) -> List["MessageCompiler"]:
+    def all_messages(self) -> list["MessageCompiler"]:
         """All of the messages in this request.
 
         Returns
@@ -250,11 +224,11 @@ class OutputTemplate:
 
     parent_request: PluginRequestCompiler
     package_proto_obj: FileDescriptorProto
-    input_files: List[str] = field(default_factory=list)
-    imports_end: Set[str] = field(default_factory=set)
-    messages: Dict[str, "MessageCompiler"] = field(default_factory=dict)
-    enums: Dict[str, "EnumDefinitionCompiler"] = field(default_factory=dict)
-    services: Dict[str, "ServiceCompiler"] = field(default_factory=dict)
+    input_files: list[str] = field(default_factory=list)
+    imports_end: set[str] = field(default_factory=set)
+    messages: dict[str, "MessageCompiler"] = field(default_factory=dict)
+    enums: dict[str, "EnumDefinitionCompiler"] = field(default_factory=dict)
+    services: dict[str, "ServiceCompiler"] = field(default_factory=dict)
     pydantic_dataclasses: bool = False
     output: bool = True
     typing_compiler: TypingCompiler = field(default_factory=DirectImportTypingCompiler)
@@ -290,9 +264,10 @@ class MessageCompiler(ProtoContentBase):
     typing_compiler: TypingCompiler
     parent: Union["MessageCompiler", OutputTemplate] = PLACEHOLDER
     proto_obj: DescriptorProto = PLACEHOLDER
-    path: List[int] = PLACEHOLDER
-    fields: List[Union["FieldCompiler", "MessageCompiler"]] = field(default_factory=list)
-    builtins_types: Set[str] = field(default_factory=set)
+    path: list[int] = PLACEHOLDER
+    fields: list[Union["FieldCompiler", "MessageCompiler"]] = field(default_factory=list)
+    oneofs: list["OneofCompiler"] = field(default_factory=list)
+    builtins_types: set[str] = field(default_factory=set)
 
     def __post_init__(self) -> None:
         # Add message to output file
@@ -328,11 +303,9 @@ class MessageCompiler(ProtoContentBase):
     @property
     def has_message_field(self) -> bool:
         return any(
-            (
-                field.proto_obj.type in PROTO_MESSAGE_TYPES
-                for field in self.fields
-                if isinstance(field.proto_obj, FieldDescriptorProto)
-            )
+            field.proto_obj.type in PROTO_MESSAGE_TYPES
+            for field in self.fields
+            if isinstance(field.proto_obj, FieldDescriptorProto)
         )
 
 
@@ -347,7 +320,7 @@ def is_map(proto_field_obj: FieldDescriptorProto, parent_message: DescriptorProt
         map_entry = f"{proto_field_obj.name.replace('_', '').lower()}entry"
         if message_type == map_entry:
             for nested in parent_message.nested_type:  # parent message
-                if nested.name.replace("_", "").lower() == map_entry and nested.options.map_entry:
+                if nested.name.replace("_", "").lower() == map_entry and nested.options and nested.options.map_entry:
                     return True
     return False
 
@@ -374,8 +347,8 @@ def is_oneof(proto_field_obj: FieldDescriptorProto) -> bool:
 class FieldCompiler(ProtoContentBase):
     source_file: FileDescriptorProto
     typing_compiler: TypingCompiler
-    path: List[int] = PLACEHOLDER
-    builtins_types: Set[str] = field(default_factory=set)
+    path: list[int] = PLACEHOLDER
+    builtins_types: set[str] = field(default_factory=set)
 
     parent: MessageCompiler = PLACEHOLDER
     proto_obj: FieldDescriptorProto = PLACEHOLDER
@@ -390,13 +363,16 @@ class FieldCompiler(ProtoContentBase):
         """Construct string representation of this field as a field."""
         name = f"{self.py_name}"
         field_args = ", ".join(([""] + self.betterproto_field_args) if self.betterproto_field_args else [])
-        betterproto_field_type = f"betterproto2.{self.field_type}_field({self.proto_obj.number}{field_args})"
+
+        betterproto_field_type = (
+            f"betterproto2.field({self.proto_obj.number}, betterproto2.{str(self.field_type)}{field_args})"
+        )
         if self.py_name in dir(builtins):
             self.parent.builtins_types.add(self.py_name)
         return f'{name}: "{self.annotation}" = {betterproto_field_type}'
 
     @property
-    def betterproto_field_args(self) -> List[str]:
+    def betterproto_field_args(self) -> list[str]:
         args = []
         if self.field_wraps:
             args.append(f"wraps={self.field_wraps}")
@@ -404,9 +380,9 @@ class FieldCompiler(ProtoContentBase):
             args.append("optional=True")
         if self.repeated:
             args.append("repeated=True")
-        if self.field_type == "enum":
+        if self.field_type == FieldType.TYPE_ENUM:
             t = self.py_type
-            args.append(f"enum_default_value=lambda: {t}.try_value(0)")
+            args.append(f"default_factory=lambda: {t}.try_value(0)")
         return args
 
     @property
@@ -416,7 +392,7 @@ class FieldCompiler(ProtoContentBase):
         )
 
     @property
-    def field_wraps(self) -> Optional[str]:
+    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:
@@ -428,17 +404,19 @@ class FieldCompiler(ProtoContentBase):
     @property
     def repeated(self) -> bool:
         return self.proto_obj.label == FieldDescriptorProtoLabel.LABEL_REPEATED and not is_map(
-            self.proto_obj, self.parent
+            self.proto_obj,
+            self.parent,
         )
 
     @property
     def optional(self) -> bool:
-        return self.proto_obj.proto3_optional or (self.field_type == "message" and not self.repeated)
+        # TODO not for maps
+        return self.proto_obj.proto3_optional or (self.field_type == FieldType.TYPE_MESSAGE and not self.repeated)
 
     @property
-    def field_type(self) -> str:
-        """String representation of proto field type."""
-        return FieldDescriptorProtoType(self.proto_obj.type).name.lower().replace("type_", "")
+    def field_type(self) -> FieldType:
+        # TODO it should be possible to remove constructor
+        return FieldType(self.proto_obj.type)
 
     @property
     def packed(self) -> bool:
@@ -500,7 +478,7 @@ class OneOfFieldCompiler(FieldCompiler):
         return True
 
     @property
-    def betterproto_field_args(self) -> List[str]:
+    def betterproto_field_args(self) -> list[str]:
         args = super().betterproto_field_args
         group = self.parent.proto_obj.oneof_decl[self.proto_obj.oneof_index].name
         args.append(f'group="{group}"')
@@ -509,8 +487,8 @@ class OneOfFieldCompiler(FieldCompiler):
 
 @dataclass
 class MapEntryCompiler(FieldCompiler):
-    py_k_type: Optional[Type] = None
-    py_v_type: Optional[Type] = None
+    py_k_type: type | None = None
+    py_v_type: type | None = None
     proto_k_type: str = ""
     proto_v_type: str = ""
 
@@ -547,13 +525,17 @@ class MapEntryCompiler(FieldCompiler):
 
         raise ValueError("can't find enum")
 
-    @property
-    def betterproto_field_args(self) -> List[str]:
-        return [f"betterproto2.{self.proto_k_type}", f"betterproto2.{self.proto_v_type}"]
-
-    @property
-    def field_type(self) -> str:
-        return "map"
+    def get_field_string(self) -> str:
+        """Construct string representation of this field as a field."""
+        betterproto_field_type = (
+            f"betterproto2.field({self.proto_obj.number}, "
+            "betterproto2.TYPE_MAP, "
+            f"map_types=(betterproto2.{self.proto_k_type}, "
+            f"betterproto2.{self.proto_v_type}))"
+        )
+        if self.py_name in dir(builtins):
+            self.parent.builtins_types.add(self.py_name)
+        return f'{self.py_name}: "{self.annotation}" = {betterproto_field_type}'
 
     @property
     def annotation(self) -> str:
@@ -564,12 +546,32 @@ class MapEntryCompiler(FieldCompiler):
         return False  # maps cannot be repeated
 
 
+@dataclass
+class OneofCompiler(ProtoContentBase):
+    source_file: FileDescriptorProto
+    typing_compiler: TypingCompiler
+    path: list[int] = PLACEHOLDER
+
+    parent: MessageCompiler = PLACEHOLDER
+    proto_obj: OneofDescriptorProto = PLACEHOLDER
+
+    def __post_init__(self) -> None:
+        # Add oneof to message
+        if isinstance(self.parent, MessageCompiler):  # TODO why?
+            self.parent.oneofs.append(self)
+        super().__post_init__()
+
+    @property
+    def name(self) -> str:
+        return self.proto_obj.name
+
+
 @dataclass
 class EnumDefinitionCompiler(MessageCompiler):
     """Representation of a proto Enum definition."""
 
     proto_obj: EnumDescriptorProto = PLACEHOLDER
-    entries: List["EnumDefinitionCompiler.EnumEntry"] = PLACEHOLDER
+    entries: list["EnumDefinitionCompiler.EnumEntry"] = PLACEHOLDER
 
     @dataclass(unsafe_hash=True)
     class EnumEntry:
@@ -597,8 +599,8 @@ class ServiceCompiler(ProtoContentBase):
     source_file: FileDescriptorProto
     parent: OutputTemplate = PLACEHOLDER
     proto_obj: DescriptorProto = PLACEHOLDER
-    path: List[int] = PLACEHOLDER
-    methods: List["ServiceMethodCompiler"] = field(default_factory=list)
+    path: list[int] = PLACEHOLDER
+    methods: list["ServiceMethodCompiler"] = field(default_factory=list)
 
     def __post_init__(self) -> None:
         # Add service to output file
@@ -619,7 +621,7 @@ class ServiceMethodCompiler(ProtoContentBase):
     source_file: FileDescriptorProto
     parent: ServiceCompiler
     proto_obj: MethodDescriptorProto
-    path: List[int] = PLACEHOLDER
+    path: list[int] = PLACEHOLDER
 
     def __post_init__(self) -> None:
         # Add method to service

betterproto2_compiler/plugin/module_validation.py

@@ -1,15 +1,10 @@
 import re
 from collections import defaultdict
+from collections.abc import Iterator
 from dataclasses import (
     dataclass,
     field,
 )
-from typing import (
-    Dict,
-    Iterator,
-    List,
-    Tuple,
-)
 
 
 @dataclass
@@ -17,7 +12,7 @@ class ModuleValidator:
     line_iterator: Iterator[str]
     line_number: int = field(init=False, default=0)
 
-    collisions: Dict[str, List[Tuple[int, str]]] = field(init=False, default_factory=lambda: defaultdict(list))
+    collisions: dict[str, list[tuple[int, str]]] = field(init=False, default_factory=lambda: defaultdict(list))
 
     def add_import(self, imp: str, number: int, full_line: str):
         """

betterproto2_compiler/plugin/parser.py

@@ -1,20 +1,14 @@
 import pathlib
 import sys
-from typing import (
-    Generator,
-    List,
-    Set,
-    Tuple,
-    Union,
-)
+from collections.abc import Generator
 
-from betterproto2_compiler.lib.google.protobuf import (
+from betterproto2.lib.google.protobuf import (
     DescriptorProto,
     EnumDescriptorProto,
-    FieldDescriptorProto,
     FileDescriptorProto,
     ServiceDescriptorProto,
 )
+
 from betterproto2_compiler.lib.google.protobuf.compiler import (
     CodeGeneratorRequest,
     CodeGeneratorResponse,
@@ -28,6 +22,7 @@ from .models import (
     FieldCompiler,
     MapEntryCompiler,
     MessageCompiler,
+    OneofCompiler,
     OneOfFieldCompiler,
     OutputTemplate,
     PluginRequestCompiler,
@@ -45,13 +40,13 @@ from .typing_compiler import (
 
 def traverse(
     proto_file: FileDescriptorProto,
-) -> Generator[Tuple[Union[EnumDescriptorProto, DescriptorProto], List[int]], None, None]:
+) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int]], None, None]:
     # Todo: Keep information about nested hierarchy
     def _traverse(
-        path: List[int],
-        items: Union[List[EnumDescriptorProto], List[DescriptorProto]],
+        path: list[int],
+        items: list[EnumDescriptorProto] | list[DescriptorProto],
         prefix: str = "",
-    ) -> Generator[Tuple[Union[EnumDescriptorProto, DescriptorProto], List[int]], None, None]:
+    ) -> Generator[tuple[EnumDescriptorProto | DescriptorProto, list[int]], 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
@@ -82,7 +77,8 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
         if output_package_name not in request_data.output_packages:
             # Create a new output if there is no output for this package
             request_data.output_packages[output_package_name] = OutputTemplate(
-                parent_request=request_data, package_proto_obj=proto_file
+                parent_request=request_data,
+                package_proto_obj=proto_file,
             )
         # Add this input file to the output corresponding to this package
         request_data.output_packages[output_package_name].input_files.append(proto_file)
@@ -144,7 +140,7 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
             service.ready()
 
     # Generate output files
-    output_paths: Set[pathlib.Path] = set()
+    output_paths: set[pathlib.Path] = set()
     for output_package_name, output_package in request_data.output_packages.items():
         if not output_package.output:
             continue
@@ -158,7 +154,7 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
                 name=str(output_path),
                 # Render and then format the output file
                 content=outputfile_compiler(output_file=output_package),
-            )
+            ),
         )
 
     # Make each output directory a package with __init__ file
@@ -178,25 +174,9 @@ def generate_code(request: CodeGeneratorRequest) -> CodeGeneratorResponse:
     return response
 
 
-def _make_one_of_field_compiler(
-    output_package: OutputTemplate,
-    source_file: "FileDescriptorProto",
-    parent: MessageCompiler,
-    proto_obj: "FieldDescriptorProto",
-    path: List[int],
-) -> FieldCompiler:
-    return OneOfFieldCompiler(
-        source_file=source_file,
-        parent=parent,
-        proto_obj=proto_obj,
-        path=path,
-        typing_compiler=output_package.typing_compiler,
-    )
-
-
 def read_protobuf_type(
     item: DescriptorProto,
-    path: List[int],
+    path: list[int],
     source_file: "FileDescriptorProto",
     output_package: OutputTemplate,
 ) -> None:
@@ -222,7 +202,13 @@ def read_protobuf_type(
                     typing_compiler=output_package.typing_compiler,
                 )
             elif is_oneof(field):
-                _make_one_of_field_compiler(output_package, source_file, message_data, field, path + [2, index])
+                OneOfFieldCompiler(
+                    source_file=source_file,
+                    parent=message_data,
+                    proto_obj=field,
+                    path=path + [2, index],
+                    typing_compiler=output_package.typing_compiler,
+                )
             else:
                 FieldCompiler(
                     source_file=source_file,
@@ -231,6 +217,16 @@ def read_protobuf_type(
                     path=path + [2, index],
                     typing_compiler=output_package.typing_compiler,
                 )
+
+        for index, oneof in enumerate(item.oneof_decl):
+            OneofCompiler(
+                source_file=source_file,
+                typing_compiler=output_package.typing_compiler,
+                path=path + [8, index],
+                parent=message_data,
+                proto_obj=oneof,
+            )
+
     elif isinstance(item, EnumDescriptorProto):
         # Enum
         EnumDefinitionCompiler(

betterproto2_compiler/plugin/typing_compiler.py

@@ -1,15 +1,11 @@
 import abc
+import builtins
 from collections import defaultdict
+from collections.abc import Iterator
 from dataclasses import (
     dataclass,
     field,
 )
-from typing import (
-    Dict,
-    Iterator,
-    Optional,
-    Set,
-)
 
 
 class TypingCompiler(metaclass=abc.ABCMeta):
@@ -42,7 +38,7 @@ class TypingCompiler(metaclass=abc.ABCMeta):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def imports(self) -> Dict[str, Optional[Set[str]]]:
+    def imports(self) -> builtins.dict[str, set[str] | None]:
         """
         Returns either the direct import as a key with none as value, or a set of
         values to import from the key.
@@ -63,7 +59,7 @@ class TypingCompiler(metaclass=abc.ABCMeta):
 
 @dataclass
 class DirectImportTypingCompiler(TypingCompiler):
-    _imports: Dict[str, Set[str]] = field(default_factory=lambda: defaultdict(set))
+    _imports: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set))
 
     def optional(self, type_: str) -> str:
         self._imports["typing"].add("Optional")
@@ -93,7 +89,7 @@ class DirectImportTypingCompiler(TypingCompiler):
         self._imports["typing"].add("AsyncIterator")
         return f"AsyncIterator[{type_}]"
 
-    def imports(self) -> Dict[str, Optional[Set[str]]]:
+    def imports(self) -> builtins.dict[str, set[str] | None]:
         return {k: v if v else None for k, v in self._imports.items()}
 
 
@@ -129,7 +125,7 @@ class TypingImportTypingCompiler(TypingCompiler):
         self._imported = True
         return f"typing.AsyncIterator[{type_}]"
 
-    def imports(self) -> Dict[str, Optional[Set[str]]]:
+    def imports(self) -> builtins.dict[str, set[str] | None]:
         if self._imported:
             return {"typing": None}
         return {}
@@ -137,7 +133,7 @@ class TypingImportTypingCompiler(TypingCompiler):
 
 @dataclass
 class NoTyping310TypingCompiler(TypingCompiler):
-    _imports: Dict[str, Set[str]] = field(default_factory=lambda: defaultdict(set))
+    _imports: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set))
 
     def optional(self, type_: str) -> str:
         return f"{type_} | None"
@@ -163,5 +159,5 @@ class NoTyping310TypingCompiler(TypingCompiler):
         self._imports["collections.abc"].add("AsyncIterator")
         return f"AsyncIterator[{type_}]"
 
-    def imports(self) -> Dict[str, Optional[Set[str]]]:
+    def imports(self) -> builtins.dict[str, set[str] | None]:
         return {k: v if v else None for k, v in self._imports.items()}

betterproto2_compiler/templates/header.py.j2

@@ -48,3 +48,5 @@ if TYPE_CHECKING:
     import grpclib.server
     from betterproto2.grpc.grpclib_client import MetadataLike
     from grpclib.metadata import Deadline
+
+betterproto2.check_compiler_version("{{ version }}")

betterproto2_compiler/templates/template.py.j2

@@ -32,9 +32,16 @@ class {{ enum.py_name }}(betterproto2.Enum):
 @dataclass(eq=False, repr=False)
 {% endif %}
 class {{ message.py_name }}(betterproto2.Message):
-    {% if message.comment %}
+    {% if message.comment or message.oneofs %}
     """
     {{ message.comment | indent(4) }}
+
+    {% if message.oneofs %}
+    Oneofs:
+        {% for oneof in message.oneofs %}
+        - {{ oneof.name }}: {{ oneof.comment | indent(12) }}
+        {% endfor %}
+    {% endif %}
     """
     {% endif %}
 

{betterproto2_compiler-0.0.3.dist-info → betterproto2_compiler-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: betterproto2_compiler
-Version: 0.0.3
+Version: 0.1.1
 Summary: Compiler for betterproto2
 Home-page: https://github.com/betterproto/python-betterproto2-compiler
 License: MIT
@@ -14,7 +14,7 @@ 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 (==0.0.2)
+Requires-Dist: betterproto2 (>=0.1.1,<0.2.0)
 Requires-Dist: grpclib (>=0.4.1,<0.5.0)
 Requires-Dist: jinja2 (>=3.0.3)
 Requires-Dist: ruff (>=0.7.4,<0.8.0)

betterproto2_compiler-0.1.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+betterproto2_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/casing.py,sha256=bMdI4W0hfYh6kV-DQIqFEjSfGYEqUtPciAzP64z5HLQ,3587
+betterproto2_compiler/compile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/compile/importing.py,sha256=JgvVFlWiA8zeb8L_pcAbxH61tDGNNNx18kVXRrfmIlo,7400
+betterproto2_compiler/compile/naming.py,sha256=zf0VOmNojzyv33upOGelGxjZTEDE8JULEEED5_3inHg,562
+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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/lib/google/protobuf/compiler/__init__.py,sha256=CX9UOXUUZD8GpeS7CWb1JTJoPIKi2e6lH7BCw6RJ8uI,9285
+betterproto2_compiler/plugin/__init__.py,sha256=L3pW0b4CvkM5x53x_sYt1kYiSFPO0_vaeH6EQPq9FAM,43
+betterproto2_compiler/plugin/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
+betterproto2_compiler/plugin/compiler.py,sha256=jICLI4-5rAOkWQI1v5j7JqIvoao-ZM9szMuq0OBRteA,2138
+betterproto2_compiler/plugin/main.py,sha256=Q9PmcJqXuYYFe51l7AqHVzJrHqi2LWCUu80CZSQOOwk,1469
+betterproto2_compiler/plugin/models.py,sha256=RfHRt8Iw_v9q-Rpi58VNHkcDfED5TwHWur2O4wr1Z8Q,24482
+betterproto2_compiler/plugin/module_validation.py,sha256=RdPFwdmkbD6NKADaHC5eaPix_pz-yGxHvYJj8Ev48fA,4822
+betterproto2_compiler/plugin/parser.py,sha256=AZihuRp7XCTKG04YNJcthR9fmarllfkPSfLS0l9exLI,9668
+betterproto2_compiler/plugin/plugin.bat,sha256=lfLT1WguAXqyerLLsRL6BfHA0RqUE6QG79v-1BYVSpI,48
+betterproto2_compiler/plugin/typing_compiler.py,sha256=IK6m4ggHXK7HL98Ed_WjvQ_yeWfIpf_fIBZ9SA8UcyM,4873
+betterproto2_compiler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+betterproto2_compiler/templates/header.py.j2,sha256=nxqsengMcM_IRqQYNVntPQ0gUFUPCy_1P1mcoLvbDos,1464
+betterproto2_compiler/templates/template.py.j2,sha256=R_9a5IvX2wU6yKzcdjj-uMb09askExrShu4UX2ayQO8,8911
+betterproto2_compiler-0.1.1.dist-info/LICENSE.md,sha256=Pgl2pReU-2yw2miGeQ55UFlyzqAZ_EpYVyZ2nWjwRv4,1121
+betterproto2_compiler-0.1.1.dist-info/METADATA,sha256=G9d9cnAsNG8x00x3wWxDDcWZdXOaZyaitkblivnE8lw,1170
+betterproto2_compiler-0.1.1.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+betterproto2_compiler-0.1.1.dist-info/entry_points.txt,sha256=re3Qg8lLljbVobeeKH2f1FVQZ114wfZkGv3zCZTD8Ok,84
+betterproto2_compiler-0.1.1.dist-info/RECORD,,

{betterproto2_compiler-0.0.3.dist-info → betterproto2_compiler-0.1.1.dist-info}/WHEEL

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

betterproto2_compiler-0.1.1.dist-info/entry_points.txt

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

betterproto2_compiler/_types.py

@@ -1,13 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    TypeVar,
-)
-
-if TYPE_CHECKING:
-    from grpclib._typing import IProtoMessage
-
-    from . import Message
-
-# Bound type variable to allow methods to return `self` of subclasses
-T = TypeVar("T", bound="Message")
-ST = TypeVar("ST", bound="IProtoMessage")