betterproto2-compiler 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

betterproto2_compiler/compile/importing.py

@@ -83,7 +83,7 @@ def get_type_reference(
     if unwrap:
         if source_type in WRAPPER_TYPES:
             wrapped_type = type(WRAPPER_TYPES[source_type]().value)
-            return settings.typing_compiler.optional(wrapped_type.__name__)
+            return f"{wrapped_type.__name__} | None"
 
         if source_type == ".google.protobuf.Duration":
             return "datetime.timedelta"

betterproto2_compiler/known_types/any.py

@@ -1,3 +1,5 @@
+import typing
+
 import betterproto2
 
 from betterproto2_compiler.lib.google.protobuf import Any as VanillaAny
@@ -18,19 +20,37 @@ class Any(VanillaAny):
         self.type_url = message_pool.type_to_url[type(message)]
         self.value = bytes(message)
 
-    def unpack(self, message_pool: "betterproto2.MessagePool | None" = None) -> betterproto2.Message:
+    def unpack(self, message_pool: "betterproto2.MessagePool | None" = None) -> betterproto2.Message | None:
         """
         Return the message packed inside the `Any` object.
 
         The target message type must be registered in the message pool, which is done automatically when the module
         defining the message type is imported.
         """
+        if not self.type_url:
+            return None
+
         message_pool = message_pool or default_message_pool
 
-        message_type = message_pool.url_to_type[self.type_url]
+        try:
+            message_type = message_pool.url_to_type[self.type_url]
+        except KeyError:
+            raise TypeError(f"Can't unpack unregistered type: {self.type_url}")
 
         return message_type().parse(self.value)
 
-    def to_dict(self) -> dict:  # pyright: ignore [reportIncompatibleMethodOverride]
-        # TOOO improve when dict is updated
-        return {"@type": self.type_url, "value": self.unpack().to_dict()}
+    def to_dict(self, **kwargs) -> dict[str, typing.Any]:
+        # TODO allow passing a message pool to `to_dict`
+        output: dict[str, typing.Any] = {"@type": self.type_url}
+
+        value = self.unpack()
+
+        if value is None:
+            return output
+
+        if type(value).to_dict == betterproto2.Message.to_dict:
+            output.update(value.to_dict(**kwargs))
+        else:
+            output["value"] = value.to_dict(**kwargs)
+
+        return output

betterproto2_compiler/known_types/timestamp.py

@@ -37,9 +37,9 @@ class Timestamp(VanillaTimestamp):
             return f"{result}Z"
         if (nanos % 1e6) == 0:
             # Serialize 3 fractional digits.
-            return f"{result}.{int(nanos // 1e6) :03d}Z"
+            return f"{result}.{int(nanos // 1e6):03d}Z"
         if (nanos % 1e3) == 0:
             # Serialize 6 fractional digits.
-            return f"{result}.{int(nanos // 1e3) :06d}Z"
+            return f"{result}.{int(nanos // 1e3):06d}Z"
         # Serialize 9 fractional digits.
         return f"{result}.{nanos:09d}"

betterproto2_compiler/lib/google/protobuf/__init__.py

@@ -724,35 +724,6 @@ class Any(betterproto2.Message):
     Must be a valid serialized protocol buffer of the above specified type.
     """
 
-    def pack(self, message: betterproto2.Message, message_pool: "betterproto2.MessagePool | None" = None) -> None:
-        """
-        Pack the given message in the `Any` object.
-
-        The message type must be registered in the message pool, which is done automatically when the module defining
-        the message type is imported.
-        """
-        message_pool = message_pool or default_message_pool
-
-        self.type_url = message_pool.type_to_url[type(message)]
-        self.value = bytes(message)
-
-    def unpack(self, message_pool: "betterproto2.MessagePool | None" = None) -> betterproto2.Message:
-        """
-        Return the message packed inside the `Any` object.
-
-        The target message type must be registered in the message pool, which is done automatically when the module
-        defining the message type is imported.
-        """
-        message_pool = message_pool or default_message_pool
-
-        message_type = message_pool.url_to_type[self.type_url]
-
-        return message_type().parse(self.value)
-
-    def to_dict(self) -> dict:  # pyright: ignore [reportIncompatibleMethodOverride]
-        # TOOO improve when dict is updated
-        return {"@type": self.type_url, "value": self.unpack().to_dict()}
-
 
 default_message_pool.register_message("google.protobuf", "Any", Any)
 

betterproto2_compiler/plugin/models.py

@@ -57,7 +57,6 @@ from betterproto2_compiler.lib.google.protobuf import (
     ServiceDescriptorProto,
 )
 from betterproto2_compiler.lib.google.protobuf.compiler import CodeGeneratorRequest
-from betterproto2_compiler.plugin.typing_compiler import TypingCompiler
 from betterproto2_compiler.settings import Settings
 
 # Organize proto types into categories
@@ -251,14 +250,6 @@ class MessageCompiler(ProtoContentBase):
     def has_oneof_fields(self) -> bool:
         return any(isinstance(field, OneOfFieldCompiler) for field in self.fields)
 
-    @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)
-        )
-
     @property
     def custom_methods(self) -> list[str]:
         """
@@ -298,7 +289,6 @@ def is_oneof(proto_field_obj: FieldDescriptorProto) -> bool:
 
 @dataclass(kw_only=True)
 class FieldCompiler(ProtoContentBase):
-    typing_compiler: TypingCompiler
     builtins_types: set[str] = field(default_factory=set)
 
     message: MessageCompiler
@@ -413,9 +403,9 @@ class FieldCompiler(ProtoContentBase):
         if self.use_builtins:
             py_type = f"builtins.{py_type}"
         if self.repeated:
-            return self.typing_compiler.list(py_type)
+            return f"list[{py_type}]"
         if self.optional:
-            return self.typing_compiler.optional(py_type)
+            return f"{py_type} | None"
         return py_type
 
 
@@ -449,14 +439,12 @@ class MapEntryCompiler(FieldCompiler):
                 self.py_k_type = FieldCompiler(
                     source_file=self.source_file,
                     proto_obj=nested.field[0],  # key
-                    typing_compiler=self.typing_compiler,
                     path=[],
                     message=self.message,
                 ).py_type
                 self.py_v_type = FieldCompiler(
                     source_file=self.source_file,
                     proto_obj=nested.field[1],  # value
-                    typing_compiler=self.typing_compiler,
                     path=[],
                     message=self.message,
                 ).py_type
@@ -482,7 +470,7 @@ class MapEntryCompiler(FieldCompiler):
 
     @property
     def annotation(self) -> str:
-        return self.typing_compiler.dict(self.py_k_type, self.py_v_type)
+        return f"dict[{self.py_k_type}, {self.py_v_type}]"
 
     @property
     def repeated(self) -> bool:

betterproto2_compiler/plugin/parser.py

@@ -31,11 +31,6 @@ from .models import (
     is_map,
     is_oneof,
 )
-from .typing_compiler import (
-    DirectImportTypingCompiler,
-    NoTyping310TypingCompiler,
-    TypingImportTypingCompiler,
-)
 
 
 def traverse(
@@ -65,25 +60,7 @@ def traverse(
 
 
 def get_settings(plugin_options: list[str]) -> Settings:
-    # Gather any typing generation options.
-    typing_opts = [opt[len("typing.") :] for opt in plugin_options if opt.startswith("typing.")]
-
-    if len(typing_opts) > 1:
-        raise ValueError("Multiple typing options provided")
-
-    # Set the compiler type.
-    typing_opt = typing_opts[0] if typing_opts else "direct"
-    if typing_opt == "direct":
-        typing_compiler = DirectImportTypingCompiler()
-    elif typing_opt == "root":
-        typing_compiler = TypingImportTypingCompiler()
-    elif typing_opt == "310":
-        typing_compiler = NoTyping310TypingCompiler()
-    else:
-        raise ValueError("Invalid typing option provided")
-
     return Settings(
-        typing_compiler=typing_compiler,
         pydantic_dataclasses="pydantic_dataclasses" in plugin_options,
     )
 
@@ -203,7 +180,6 @@ def read_protobuf_type(
                         message=message_data,
                         proto_obj=field,
                         path=path + [2, index],
-                        typing_compiler=output_package.settings.typing_compiler,
                     )
                 )
             elif is_oneof(field):
@@ -213,7 +189,6 @@ def read_protobuf_type(
                         message=message_data,
                         proto_obj=field,
                         path=path + [2, index],
-                        typing_compiler=output_package.settings.typing_compiler,
                     )
                 )
             else:
@@ -223,7 +198,6 @@ def read_protobuf_type(
                         message=message_data,
                         proto_obj=field,
                         path=path + [2, index],
-                        typing_compiler=output_package.settings.typing_compiler,
                     )
                 )
 

betterproto2_compiler/settings.py

@@ -1,9 +1,6 @@
 from dataclasses import dataclass
 
-from .plugin.typing_compiler import TypingCompiler
-
 
 @dataclass
 class Settings:
     pydantic_dataclasses: bool
-    typing_compiler: TypingCompiler

betterproto2_compiler/templates/header.py.j2

@@ -21,6 +21,9 @@ __all__ = (
 import builtins
 import datetime
 import warnings
+from collections.abc import AsyncIterable, AsyncIterator, Iterable
+import typing
+from typing import TYPE_CHECKING
 
 {% if output_file.settings.pydantic_dataclasses %}
 from pydantic.dataclasses import dataclass
@@ -29,21 +32,12 @@ from pydantic import model_validator
 from dataclasses import dataclass
 {% endif %}
 
-{% set typing_imports = output_file.settings.typing_compiler.imports() %}
-{% if typing_imports %}
-{% for line in output_file.settings.typing_compiler.import_lines() %}
-{{ line }}
-{% endfor %}
-{% endif %}
-
 import betterproto2
 {% if output_file.services %}
 from betterproto2.grpc.grpclib_server import ServiceBase
 import grpclib
 {% endif %}
 
-from typing import TYPE_CHECKING
-
 {# Import the message pool of the generated code. #}
 {% if output_file.package %}
 from {{ "." * output_file.package.count(".") }}..message_pool import default_message_pool

betterproto2_compiler/templates/template.py.j2

@@ -100,20 +100,20 @@ class {{ service.py_name }}Stub(betterproto2.ServiceStub):
         {%- if not method.client_streaming -%}
             , message:
                 {%- if method.is_input_msg_empty -%}
-                    "{{ output_file.settings.typing_compiler.optional(method.py_input_message_type) }}" = None
+                    "{{ method.py_input_message_type }} | None" = None
                 {%- else -%}
                     "{{ method.py_input_message_type }}"
                 {%- endif -%}
         {%- else -%}
             {# Client streaming: need a request iterator instead #}
-            , messages: "{{ output_file.settings.typing_compiler.union(output_file.settings.typing_compiler.async_iterable(method.py_input_message_type), output_file.settings.typing_compiler.iterable(method.py_input_message_type)) }}"
+            , messages: "AsyncIterable[{{ method.py_input_message_type }}] | Iterable[{{ method.py_input_message_type }}]"
         {%- endif -%}
             ,
             *
-            , timeout: {{ output_file.settings.typing_compiler.optional("float") }} = None
-            , deadline: "{{ output_file.settings.typing_compiler.optional("Deadline") }}" = None
-            , metadata: "{{ output_file.settings.typing_compiler.optional("MetadataLike") }}" = None
-            ) -> "{% if method.server_streaming %}{{ output_file.settings.typing_compiler.async_iterator(method.py_output_message_type ) }}{% else %}{{ method.py_output_message_type }}{% endif %}":
+            , timeout: "float | None" = None
+            , deadline: "Deadline | None" = None
+            , metadata: "MetadataLike | None" = None
+            ) -> "{% if method.server_streaming %}AsyncIterator[{{ method.py_output_message_type }}]{% else %}{{ method.py_output_message_type }}{% endif %}":
         {% if method.comment %}
         """
         {{ method.comment | indent(8) }}
@@ -202,9 +202,9 @@ class {{ service.py_name }}Base(ServiceBase):
             , message: "{{ method.py_input_message_type }}"
         {%- else -%}
             {# Client streaming: need a request iterator instead #}
-            , messages: {{ output_file.settings.typing_compiler.async_iterator(method.py_input_message_type) }}
+            , messages: "AsyncIterator[{{ method.py_input_message_type }}]"
         {%- endif -%}
-            ) -> {% if method.server_streaming %}{{ output_file.settings.typing_compiler.async_iterator(method.py_output_message_type) }}{% else %}"{{ method.py_output_message_type }}"{% endif %}:
+            ) -> {% if method.server_streaming %}"AsyncIterator[{{ method.py_output_message_type }}]"{% else %}"{{ method.py_output_message_type }}"{% endif %}:
         {% if method.comment %}
         """
         {{ method.comment | indent(8) }}
@@ -235,7 +235,7 @@ class {{ service.py_name }}Base(ServiceBase):
 
     {% endfor %}
 
-    def __mapping__(self) -> {{ output_file.settings.typing_compiler.dict("str", "grpclib.const.Handler") }}:
+    def __mapping__(self) -> "dict[str, grpclib.const.Handler":
         return {
         {% for method in service.methods %}
         "{{ method.route }}": grpclib.const.Handler(

{betterproto2_compiler-0.2.2.dist-info → betterproto2_compiler-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: betterproto2_compiler
-Version: 0.2.2
+Version: 0.2.4
 Summary: Compiler for betterproto2
 License: MIT
 Keywords: protobuf,gRPC,compiler
@@ -13,11 +13,12 @@ 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.2.1,<0.3.0)
+Requires-Dist: betterproto2 (>=0.2.3,<0.3.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)
+Requires-Dist: ruff (>=0.9.3,<0.10.0)
 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-0.2.2.dist-info → betterproto2_compiler-0.2.4.dist-info}/RECORD

@@ -1,32 +1,31 @@
 betterproto2_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 betterproto2_compiler/casing.py,sha256=HSXLXAOqZzEnu-tC1SZjpW0LIjzdPqUNJEwy1BHzfgg,3056
 betterproto2_compiler/compile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-betterproto2_compiler/compile/importing.py,sha256=4jPXNBbA3jRDQf5n7GHkC1yvR1cozFoFLKRvu5GIzMk,7152
+betterproto2_compiler/compile/importing.py,sha256=2DF9zpYhjX_H3PCyUHCXhho1J2QdGAtXitlNneZZfFs,7129
 betterproto2_compiler/compile/naming.py,sha256=zf0VOmNojzyv33upOGelGxjZTEDE8JULEEED5_3inHg,562
 betterproto2_compiler/known_types/__init__.py,sha256=Exqo-3ubDuik0TZDTw5ZPqf-dVb2uPJTZxMG7X58E6U,780
-betterproto2_compiler/known_types/any.py,sha256=QnfSKTXzazZwmsxaFu8_SYNmLww1D2mFdmi29_8Nzb4,1432
+betterproto2_compiler/known_types/any.py,sha256=eRMenvvrn-1Wiss3YxhqRsjZ4XqiqPb1YQuinoA8wI4,1899
 betterproto2_compiler/known_types/duration.py,sha256=jy9GPnQTT9qhi12pQDG_ptdFAdm2gYkq3NH75zUTDOU,895
-betterproto2_compiler/known_types/timestamp.py,sha256=lw7kQPYJn76Q2wR4l3nCshj7VZ3s8h_xRcvrGIno4z0,2155
+betterproto2_compiler/known_types/timestamp.py,sha256=dUfJmdrVg1NW-zkquAc8kxMH6nqdxQ2x_MKeP4N5ksY,2153
 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=ajfzhKfLLdrg1eESD9LR18chGNDI2EerRtjLTUnWxKY,109428
+betterproto2_compiler/lib/google/protobuf/__init__.py,sha256=dGC8iW2zPQQxxNMGmS2IjY5bOhYUmNvcasB-GC2CtHQ,108191
 betterproto2_compiler/lib/google/protobuf/compiler/__init__.py,sha256=bWYhEcL4nz0_4H6FTCmN3F419FQWXkY49LGE2hJJ6jM,8906
 betterproto2_compiler/lib/message_pool.py,sha256=4-cRhhiM6bmfpUJZ8qxc8LEyqHBHpLCcotjbyZxl7JM,71
 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/main.py,sha256=gI2fSWc9U-fn6MOlkLg7iResr2YsXbdOge6SzNWxBAo,1302
-betterproto2_compiler/plugin/models.py,sha256=Kfda57yUyicTVs61HWzFZd7WT6BgntJ19VagFM56mSk,21449
+betterproto2_compiler/plugin/models.py,sha256=qm-ZolRu8_R6LHadjZZBuk0Ht61MwXKLa-Y-S88RMxY,20932
 betterproto2_compiler/plugin/module_validation.py,sha256=JnP8dSN83eJJVDP_UPJsHzq7E7Md3lah0PnKXDbFW5Q,4808
-betterproto2_compiler/plugin/parser.py,sha256=9PT8ArcGwnCviIYo1j_dsfPcdroaSVWC0OfLNzI66hU,10410
+betterproto2_compiler/plugin/parser.py,sha256=MIA5-pAIJsng59wk3KYEKBARNCsQEQeetnVZk_MhL0I,9349
 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/settings.py,sha256=d7XTRMywahR9PcOgaycPXLkHgJMSYDffuSO874yyrh0,182
-betterproto2_compiler/templates/header.py.j2,sha256=wYBR4yer77dTGM9e1RijuID-mI4GHrmk66OjdVvmBxc,1734
-betterproto2_compiler/templates/template.py.j2,sha256=J3eWLM_zBiRQcu7AaLc6LMg54yiifQUpb0l0FdRyNAk,8870
-betterproto2_compiler-0.2.2.dist-info/LICENSE.md,sha256=Pgl2pReU-2yw2miGeQ55UFlyzqAZ_EpYVyZ2nWjwRv4,1121
-betterproto2_compiler-0.2.2.dist-info/METADATA,sha256=mfl_LYJm49_hnWbg6Dr98uvgM0Vcvxe0Dx-_Qhy9PKE,1099
-betterproto2_compiler-0.2.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-betterproto2_compiler-0.2.2.dist-info/entry_points.txt,sha256=re3Qg8lLljbVobeeKH2f1FVQZ114wfZkGv3zCZTD8Ok,84
-betterproto2_compiler-0.2.2.dist-info/RECORD,,
+betterproto2_compiler/settings.py,sha256=FQwco5j9ViBXtDYoFqog7SlXhX2YcbgEnFP77znYiwc,94
+betterproto2_compiler/templates/header.py.j2,sha256=HrISX0IKmUsVpIlGIT6XlD9e3LgWWPN7jYRpws5_-CY,1609
+betterproto2_compiler/templates/template.py.j2,sha256=Kwbw302GGzSEQ007eSHmHYGF0lHw01n_c0sGbtV9pWI,8419
+betterproto2_compiler-0.2.4.dist-info/LICENSE.md,sha256=Pgl2pReU-2yw2miGeQ55UFlyzqAZ_EpYVyZ2nWjwRv4,1121
+betterproto2_compiler-0.2.4.dist-info/METADATA,sha256=bQ5WSjI-tm0jNx_WK_1fwlCd3qIP37SZF0EpyFBoI9k,1188
+betterproto2_compiler-0.2.4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+betterproto2_compiler-0.2.4.dist-info/entry_points.txt,sha256=re3Qg8lLljbVobeeKH2f1FVQZ114wfZkGv3zCZTD8Ok,84
+betterproto2_compiler-0.2.4.dist-info/RECORD,,

betterproto2_compiler/plugin/typing_compiler.py

@@ -1,163 +0,0 @@
-import abc
-import builtins
-from collections import defaultdict
-from collections.abc import Iterator
-from dataclasses import (
-    dataclass,
-    field,
-)
-
-
-class TypingCompiler(metaclass=abc.ABCMeta):
-    @abc.abstractmethod
-    def optional(self, type_: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def list(self, type_: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def dict(self, key: str, value: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def union(self, *types: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def iterable(self, type_: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def async_iterable(self, type_: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def async_iterator(self, type_: str) -> str:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    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.
-        """
-        raise NotImplementedError
-
-    def import_lines(self) -> Iterator:
-        imports = self.imports()
-        for key, value in imports.items():
-            if value is None:
-                yield f"import {key}"
-            else:
-                yield f"from {key} import ("
-                for v in sorted(value):
-                    yield f"    {v},"
-                yield ")"
-
-
-@dataclass
-class DirectImportTypingCompiler(TypingCompiler):
-    _imports: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set))
-
-    def optional(self, type_: str) -> str:
-        self._imports["typing"].add("Optional")
-        return f"Optional[{type_}]"
-
-    def list(self, type_: str) -> str:
-        self._imports["typing"].add("List")
-        return f"List[{type_}]"
-
-    def dict(self, key: str, value: str) -> str:
-        self._imports["typing"].add("Dict")
-        return f"Dict[{key}, {value}]"
-
-    def union(self, *types: str) -> str:
-        self._imports["typing"].add("Union")
-        return f"Union[{', '.join(types)}]"
-
-    def iterable(self, type_: str) -> str:
-        self._imports["typing"].add("Iterable")
-        return f"Iterable[{type_}]"
-
-    def async_iterable(self, type_: str) -> str:
-        self._imports["typing"].add("AsyncIterable")
-        return f"AsyncIterable[{type_}]"
-
-    def async_iterator(self, type_: str) -> str:
-        self._imports["typing"].add("AsyncIterator")
-        return f"AsyncIterator[{type_}]"
-
-    def imports(self) -> builtins.dict[str, set[str] | None]:
-        return {k: v if v else None for k, v in self._imports.items()}
-
-
-@dataclass
-class TypingImportTypingCompiler(TypingCompiler):
-    _imported: bool = False
-
-    def optional(self, type_: str) -> str:
-        self._imported = True
-        return f"typing.Optional[{type_}]"
-
-    def list(self, type_: str) -> str:
-        self._imported = True
-        return f"typing.List[{type_}]"
-
-    def dict(self, key: str, value: str) -> str:
-        self._imported = True
-        return f"typing.Dict[{key}, {value}]"
-
-    def union(self, *types: str) -> str:
-        self._imported = True
-        return f"typing.Union[{', '.join(types)}]"
-
-    def iterable(self, type_: str) -> str:
-        self._imported = True
-        return f"typing.Iterable[{type_}]"
-
-    def async_iterable(self, type_: str) -> str:
-        self._imported = True
-        return f"typing.AsyncIterable[{type_}]"
-
-    def async_iterator(self, type_: str) -> str:
-        self._imported = True
-        return f"typing.AsyncIterator[{type_}]"
-
-    def imports(self) -> builtins.dict[str, set[str] | None]:
-        if self._imported:
-            return {"typing": None}
-        return {}
-
-
-@dataclass
-class NoTyping310TypingCompiler(TypingCompiler):
-    _imports: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set))
-
-    def optional(self, type_: str) -> str:
-        return f"{type_} | None"
-
-    def list(self, type_: str) -> str:
-        return f"list[{type_}]"
-
-    def dict(self, key: str, value: str) -> str:
-        return f"dict[{key}, {value}]"
-
-    def union(self, *types: str) -> str:
-        return f"{' | '.join(types)}"
-
-    def iterable(self, type_: str) -> str:
-        self._imports["collections.abc"].add("Iterable")
-        return f"Iterable[{type_}]"
-
-    def async_iterable(self, type_: str) -> str:
-        self._imports["collections.abc"].add("AsyncIterable")
-        return f"AsyncIterable[{type_}]"
-
-    def async_iterator(self, type_: str) -> str:
-        self._imports["collections.abc"].add("AsyncIterator")
-        return f"AsyncIterator[{type_}]"
-
-    def imports(self) -> builtins.dict[str, set[str] | None]:
-        return {k: v if v else None for k, v in self._imports.items()}