betterproto2-compiler 0.6.0__tar.gz → 0.7.1__tar.gz

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/.gitignore

@@ -6,7 +6,8 @@
 .pytest_cache
 .python-version
 build/
-tests/output_*
+*/tests/output_*
+*/tests/outputs/*
 **/__pycache__
 dist
 **/*.egg-info
@@ -18,4 +19,4 @@ output
 .asv
 venv
 .devcontainer
-.ruff_cache
+.ruff_cache

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: betterproto2_compiler
-Version: 0.6.0
+Version: 0.7.1
 Summary: Compiler for betterproto2
 Project-URL: Documentation, https://betterproto.github.io/python-betterproto2/
 Project-URL: Repository, https://github.com/betterproto/python-betterproto2
@@ -8,7 +8,7 @@ Author-email: Adrien Vannson <adrien.vannson@protonmail.com>, "Daniel G. Taylor"
 License-Expression: MIT
 Keywords: compiler,gRPC,protobuf
 Requires-Python: <4.0,>=3.10
-Requires-Dist: betterproto2[grpclib]<0.7,>=0.6.0
+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'

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "betterproto2_compiler"
-version = "0.6.0"
+version = "0.7.1"
 description = "Compiler for betterproto2"
 authors = [
     { name = "Adrien Vannson", email = "adrien.vannson@protonmail.com" },
@@ -15,7 +15,7 @@ keywords = [
 requires-python = ">=3.10,<4.0"
 dependencies = [
     # TODO use the version from the current repo?
-    "betterproto2[grpclib]>=0.6.0,<0.7",
+    "betterproto2[grpclib]>=0.7.0,<0.8",
     "ruff~=0.9.3",
     "jinja2>=3.0.3",
     "typing-extensions>=4.7.1,<5",
@@ -60,7 +60,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.ruff]
-extend-exclude = ["tests/output_*", "src/betterproto2_compiler/lib"]
+extend-exclude = ["tests/outputs", "src/betterproto2_compiler/lib"]
 target-version = "py310"
 line-length = 120
 
@@ -88,7 +88,8 @@ cmd = "pytest"
 help = "Run tests"
 
 [tool.poe.tasks.generate]
-sequence = ["_generate_tests", "_generate_tests_lib"]
+# sequence = ["_generate_tests", "_generate_tests_lib"]
+sequence = ["_generate_tests"]
 help = "Generate test cases"
 
 [tool.poe.tasks._generate_tests]
@@ -122,6 +123,20 @@ python -m grpc.tools.protoc \
     google/protobuf/timestamp.proto \
     google/protobuf/type.proto \
     google/protobuf/wrappers.proto
+
+python -m grpc.tools.protoc \
+    --python_betterproto2_out=tests/output_betterproto_descriptor \
+    --python_betterproto2_opt=google_protobuf_descriptors \
+    google/protobuf/any.proto \
+    google/protobuf/api.proto \
+    google/protobuf/duration.proto \
+    google/protobuf/empty.proto \
+    google/protobuf/field_mask.proto \
+    google/protobuf/source_context.proto \
+    google/protobuf/struct.proto \
+    google/protobuf/timestamp.proto \
+    google/protobuf/type.proto \
+    google/protobuf/wrappers.proto
 """
 
 [tool.poe.tasks.typecheck]

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/src/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-0.6.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/known_types/google_values.py

@@ -24,10 +24,10 @@ class BoolValue(VanillaBoolValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, bool):
             return BoolValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -48,10 +48,10 @@ class Int32Value(VanillaInt32Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return Int32Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -72,10 +72,10 @@ class Int64Value(VanillaInt64Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return Int64Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -96,10 +96,10 @@ class UInt32Value(VanillaUInt32Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return UInt32Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -120,10 +120,10 @@ class UInt64Value(VanillaUInt64Value):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, int):
             return UInt64Value(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -144,10 +144,10 @@ class FloatValue(VanillaFloatValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, float):
             return FloatValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -168,10 +168,10 @@ class DoubleValue(VanillaDoubleValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, float):
             return DoubleValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -192,10 +192,10 @@ class StringValue(VanillaStringValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, str):
             return StringValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,
@@ -216,10 +216,10 @@ class BytesValue(VanillaBytesValue):
         return self.value
 
     @classmethod
-    def from_dict(cls, value):
+    def from_dict(cls, value, *, ignore_unknown_fields: bool = False):
         if isinstance(value, bytes):
             return BytesValue(value=value)
-        return super().from_dict(value)
+        return super().from_dict(value, ignore_unknown_fields=ignore_unknown_fields)
 
     def to_dict(
         self,

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/src/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.6.0")
+betterproto2.check_compiler_version("0.7.0")
 
 
 class FieldCardinality(betterproto2.Enum):

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/src/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.6.0")
+betterproto2.check_compiler_version("0.7.0")
 
 
 class CodeGeneratorResponseFeature(betterproto2.Enum):

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/plugin/models.py

@@ -34,10 +34,10 @@ from dataclasses import (
 
 from betterproto2 import unwrap
 
+from betterproto2_compiler import casing
 from betterproto2_compiler.compile.importing import get_type_reference, parse_source_type_name
 from betterproto2_compiler.compile.naming import (
     pythonize_class_name,
-    pythonize_enum_member_name,
     pythonize_field_name,
     pythonize_method_name,
 )
@@ -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."""
@@ -562,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)
@@ -569,32 +610,74 @@ class EnumDefinitionCompiler(ProtoContentBase):
         """Representation of an Enum entry."""
 
         name: str
+        proto_name: str
         value: int
         comment: str
 
     def __post_init__(self) -> None:
-        # Get entries/allowed values for this Enum
         self.entries = [
             self.EnumEntry(
-                name=pythonize_enum_member_name(entry_proto_value.name, self.proto_obj.name),
+                name=entry_proto_value.name,
+                proto_name=entry_proto_value.name,
                 value=entry_proto_value.number,
                 comment=get_comment(proto_file=self.source_file, path=self.path + [2, entry_number]),
             )
             for entry_number, entry_proto_value in enumerate(self.proto_obj.value)
         ]
 
+        if not self.entries:
+            return
+
+        # Remove enum prefixes
+        enum_name: str = self.proto_obj.name
+
+        enum_name_reduced = enum_name.replace("_", "").lower()
+
+        first_entry = self.entries[0].name
+
+        # Find the potential common prefix
+        enum_prefix = ""
+        for i in range(len(first_entry)):
+            if first_entry[: i + 1].replace("_", "").lower() == enum_name_reduced:
+                enum_prefix = f"{first_entry[: i + 1]}_"
+                break
+
+        should_rename = enum_prefix and all(entry.name.startswith(enum_prefix) for entry in self.entries)
+
+        if should_rename:
+            for entry in self.entries:
+                entry.name = entry.name[len(enum_prefix) :]
+
+        for entry in self.entries:
+            entry.name = casing.sanitize_name(entry.name)
+
     @property
     def proto_name(self) -> str:
         return self.proto_obj.name
 
     @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)
+
+    @property
+    def has_renamed_entries(self) -> bool:
+        return any(entry.proto_name != entry.name for entry in self.entries)
+
 
 @dataclass(kw_only=True)
 class ServiceCompiler(ProtoContentBase):

{betterproto2_compiler-0.6.0 → betterproto2_compiler-0.7.1}/src/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-0.6.0 → betterproto2_compiler-0.7.1}/src/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-0.6.0 → betterproto2_compiler-0.7.1}/src/betterproto2_compiler/templates/header.py.j2

@@ -32,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:
@@ -45,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)