betterproto2-compiler 0.0.2__tar.gz → 0.1.0__tar.gz

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: betterproto2_compiler
-Version: 0.0.2
+Version: 0.1.0
 Summary: Compiler for betterproto2
 Home-page: https://github.com/betterproto/python-betterproto2-compiler
 License: MIT

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "betterproto2_compiler"
-version = "0.0.2"
+version = "0.1.0"
 description = "Compiler for betterproto2"
 authors = ["Adrien Vannson <adrien.vannson@protonmail.com>", "Daniel G. Taylor <danielgtaylor@gmail.com>"]
 readme = "README.md"
@@ -34,10 +34,10 @@ pytest = "^6.2.5"
 protobuf = "^4"
 
 [tool.poetry.scripts]
-protoc-gen-python_betterproto = "betterproto2_compiler.plugin:main"
+protoc-gen-python_betterproto2 = "betterproto2_compiler.plugin:main"
 
 [tool.ruff]
-extend-exclude = ["tests/output_*"]
+extend-exclude = ["tests/output_*", "src/betterproto2_compiler/lib"]
 target-version = "py310"
 line-length = 120
 
@@ -52,7 +52,11 @@ select = [
     "SIM102", # Simplify return or yield statements
     "SIM103", # Simplify list/set/dict comprehensions
 
+    "UP",
+
     "I",
+
+    "COM812", # Trailing commas
 ]
 
 
@@ -61,6 +65,10 @@ combine-as-imports = true
 
 # Dev workflow tasks
 
+[tool.poe.tasks.test]
+cmd = "pytest"
+help = "Run tests"
+
 [tool.poe.tasks.generate]
 script = "tests.generate:main"
 help = "Generate test cases"
@@ -74,8 +82,8 @@ sequence = ["_format", "_sort-imports"]
 help = "Format the source code, and sort the imports"
 
 [tool.poe.tasks.check]
-sequence = ["_check-format", "_check-imports"]
-help = "Check that the source code is formatted and the imports sorted"
+sequence = ["_check-format", "_check-ruff-lint"]
+help = "Check that the source code is formatted and the code passes the linter"
 
 [tool.poe.tasks._format]
 cmd = "ruff format src tests"
@@ -89,9 +97,9 @@ help = "Sort the imports"
 cmd = "ruff format --diff src tests"
 help = "Check that the source code is formatted"
 
-[tool.poe.tasks._check-imports]
-cmd = "ruff check --select I src tests"
-help = "Check that the imports are sorted"
+[tool.poe.tasks._check-ruff-lint]
+cmd = "ruff check src tests"
+help = "Check the code with the Ruff linter"
 
 [tool.poe.tasks.generate_lib]
 cmd = """

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/compile/importing.py

@@ -3,11 +3,6 @@ from __future__ import annotations
 import os
 from typing import (
     TYPE_CHECKING,
-    Dict,
-    List,
-    Set,
-    Tuple,
-    Type,
 )
 
 from ..casing import safe_snake_case
@@ -18,7 +13,7 @@ if TYPE_CHECKING:
     from ..plugin.models import PluginRequestCompiler
     from ..plugin.typing_compiler import TypingCompiler
 
-WRAPPER_TYPES: Dict[str, Type] = {
+WRAPPER_TYPES: dict[str, type] = {
     ".google.protobuf.DoubleValue": google_protobuf.DoubleValue,
     ".google.protobuf.FloatValue": google_protobuf.FloatValue,
     ".google.protobuf.Int32Value": google_protobuf.Int32Value,
@@ -31,7 +26,7 @@ WRAPPER_TYPES: Dict[str, Type] = {
 }
 
 
-def parse_source_type_name(field_type_name: str, request: "PluginRequestCompiler") -> Tuple[str, str]:
+def parse_source_type_name(field_type_name: str, request: PluginRequestCompiler) -> tuple[str, str]:
     """
     Split full source type name into package and type name.
     E.g. 'root.package.Message' -> ('root.package', 'Message')
@@ -77,7 +72,7 @@ def get_type_reference(
     imports: set,
     source_type: str,
     typing_compiler: TypingCompiler,
-    request: "PluginRequestCompiler",
+    request: PluginRequestCompiler,
     unwrap: bool = True,
     pydantic: bool = False,
 ) -> str:
@@ -98,16 +93,16 @@ def get_type_reference(
 
     source_package, source_type = parse_source_type_name(source_type, request)
 
-    current_package: List[str] = package.split(".") if package else []
-    py_package: List[str] = source_package.split(".") if source_package else []
+    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)
 
     compiling_google_protobuf = current_package == ["google", "protobuf"]
     importing_google_protobuf = py_package == ["google", "protobuf"]
     if importing_google_protobuf and not compiling_google_protobuf:
-        py_package = ["betterproto", "lib"] + (["pydantic"] if pydantic else []) + py_package
+        py_package = ["betterproto2", "lib"] + (["pydantic"] if pydantic else []) + py_package
 
-    if py_package[:1] == ["betterproto"]:
+    if py_package[:1] == ["betterproto2"]:
         return reference_absolute(imports, py_package, py_type)
 
     if py_package == current_package:
@@ -122,7 +117,7 @@ def get_type_reference(
     return reference_cousin(current_package, imports, py_package, py_type)
 
 
-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) -> str:
     """
     Returns a reference to a python type located in the root, i.e. sys.path.
     """
@@ -139,7 +134,7 @@ 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) -> 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
@@ -157,7 +152,7 @@ def reference_descendent(current_package: List[str], imports: Set[str], py_packa
         return f"{string_import}.{py_type}"
 
 
-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) -> 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
@@ -178,7 +173,7 @@ def reference_ancestor(current_package: List[str], imports: Set[str], py_package
         return string_alias
 
 
-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) -> 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.

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/lib/pydantic/google/protobuf/__init__.py

@@ -2401,13 +2401,13 @@ class Value(betterproto2_compiler.Message):
     )
     """Represents a null value."""
 
-    number_value: Optional[float] = betterproto2_compiler.double_field(2, optional=True, group="kind")
+    number_value: float | None = betterproto2_compiler.double_field(2, optional=True, group="kind")
     """Represents a double value."""
 
-    string_value: Optional[str] = betterproto2_compiler.string_field(3, optional=True, group="kind")
+    string_value: str | None = betterproto2_compiler.string_field(3, optional=True, group="kind")
     """Represents a string value."""
 
-    bool_value: Optional[bool] = betterproto2_compiler.bool_field(4, optional=True, group="kind")
+    bool_value: bool | None = betterproto2_compiler.bool_field(4, optional=True, group="kind")
     """Represents a boolean value."""
 
     struct_value: Optional["Struct"] = betterproto2_compiler.message_field(5, optional=True, group="kind")

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/lib/std/google/protobuf/__init__.py

@@ -78,7 +78,6 @@ from typing import (
     Dict,
     List,
     Mapping,
-    Optional,
 )
 
 import betterproto2
@@ -1022,7 +1021,7 @@ class FieldDescriptorProto(betterproto2.Message):
     TODO(kenton):  Base-64 encode?
     """
 
-    oneof_index: Optional[int] = betterproto2.int32_field(9, optional=True)
+    oneof_index: int | None = betterproto2.int32_field(9, optional=True)
     """
     If set, gives the index of a oneof in the containing type's oneof_decl
     list.  This field is a member of that oneof.

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/plugin/compiler.py

@@ -1,6 +1,7 @@
 import os.path
 import subprocess
 import sys
+from importlib import metadata
 
 from .module_validation import ModuleValidator
 
@@ -14,7 +15,7 @@ except ImportError as err:
         "Please ensure that you've installed betterproto as "
         '`pip install "betterproto[compiler]"` so that compiler dependencies '
         "are included."
-        "\033[0m"
+        "\033[0m",
     )
     raise SystemExit(1)
 
@@ -24,6 +25,8 @@ from .models import OutputTemplate
 def outputfile_compiler(output_file: OutputTemplate) -> str:
     templates_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "templates"))
 
+    version = metadata.version("betterproto2_compiler")
+
     env = jinja2.Environment(
         trim_blocks=True,
         lstrip_blocks=True,
@@ -35,7 +38,7 @@ def outputfile_compiler(output_file: OutputTemplate) -> str:
     header_template = env.get_template("header.py.j2")
 
     code = body_template.render(output_file=output_file)
-    code = header_template.render(output_file=output_file) + "\n" + code
+    code = header_template.render(output_file=output_file, version=version) + "\n" + code
 
     # Sort imports, delete unused ones
     code = subprocess.check_output(

{betterproto2_compiler-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/plugin/models.py

@@ -31,22 +31,17 @@ 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_compiler
+import betterproto2
+
 from betterproto2_compiler.compile.naming import (
     pythonize_class_name,
     pythonize_field_name,
@@ -58,6 +53,7 @@ from betterproto2_compiler.lib.google.protobuf import (
     FieldDescriptorProto,
     FieldDescriptorProtoLabel,
     FieldDescriptorProtoType,
+    FieldDescriptorProtoType as FieldType,
     FileDescriptorProto,
     MethodDescriptorProto,
 )
@@ -145,7 +141,7 @@ PROTO_PACKED_TYPES = (
 
 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:
@@ -181,10 +177,10 @@ class ProtoContentBase:
 
     source_file: FileDescriptorProto
     typing_compiler: TypingCompiler
-    path: List[int]
-    parent: Union["betterproto2_compiler.Message", "OutputTemplate"]
+    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."""
@@ -224,10 +220,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
@@ -249,11 +245,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)
@@ -289,9 +285,9 @@ 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)
+    builtins_types: set[str] = field(default_factory=set)
 
     def __post_init__(self) -> None:
         # Add message to output file
@@ -327,11 +323,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)
         )
 
 
@@ -346,7 +340,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
 
@@ -373,8 +367,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
@@ -389,13 +383,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}")
@@ -403,9 +400,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
@@ -415,29 +412,31 @@ 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:
             wrapped_type = "TYPE_" + match_wrapper.group(1).upper()
-            if hasattr(betterproto2_compiler, wrapped_type):
+            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 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:
@@ -499,7 +498,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}"')
@@ -508,8 +507,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 = ""
 
@@ -546,13 +545,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:
@@ -568,7 +571,7 @@ 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:
@@ -596,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
@@ -618,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-0.0.2 → betterproto2_compiler-0.1.0}/src/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-0.0.2 → betterproto2_compiler-0.1.0}/src/betterproto2_compiler/plugin/parser.py

@@ -1,12 +1,6 @@
 import pathlib
 import sys
-from typing import (
-    Generator,
-    List,
-    Set,
-    Tuple,
-    Union,
-)
+from collections.abc import Generator
 
 from betterproto2_compiler.lib.google.protobuf import (
     DescriptorProto,
@@ -45,13 +39,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 +76,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 +139,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 +153,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
@@ -183,7 +178,7 @@ def _make_one_of_field_compiler(
     source_file: "FileDescriptorProto",
     parent: MessageCompiler,
     proto_obj: "FieldDescriptorProto",
-    path: List[int],
+    path: list[int],
 ) -> FieldCompiler:
     return OneOfFieldCompiler(
         source_file=source_file,
@@ -196,7 +191,7 @@ def _make_one_of_field_compiler(
 
 def read_protobuf_type(
     item: DescriptorProto,
-    path: List[int],
+    path: list[int],
     source_file: "FileDescriptorProto",
     output_package: OutputTemplate,
 ) -> None: