🐛 Fix imports.

Author: rafalkrupinski

src/lapidary/render/model/python/__init__.py

@@ -95,13 +95,13 @@ def modules(self) -> Sequence[AbstractModule]:
     def _modules(self) -> Iterable[AbstractModule]:
         known_modules = set()
         for mod in itertools.chain(self.schemas, self._response_envelopes):
-            assert mod.path not in known_modules
+            assert mod.path not in known_modules, mod.path
             known_modules.add(mod.path)
             yield mod
 
         for package in self.packages():
-            assert package not in known_modules
-            yield EmptyModule(path=package, body=None)
+            if package not in known_modules:
+                yield EmptyModule(path=package, body=None)
 
     def add_response_envelope_module(self, mod: ResponseEnvelopeModule):
         self._response_envelopes.append(mod)

src/lapidary/render/model/python/model.py

@@ -35,10 +35,6 @@ class Field:
     deprecated: bool = False
     """Currently not used"""
 
-    @property
-    def dependencies(self) -> Iterable[TypeHint]:
-        return [self.annotation.type]
-
 
 @dc.dataclass
 class Auth:
@@ -119,11 +115,10 @@ class OperationFunction:
     responses: ResponseMap
     security: SecurityRequirements | None
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         yield self.request_body_type
         for param in self.params:
-            yield from param.dependencies
+            yield from param.dependencies()
         yield self.response_body_type
 
     @property
@@ -164,7 +159,6 @@ class Parameter:
     style: ParamStyle | None
     explode: bool | None
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         yield self.type
 
@@ -184,11 +178,10 @@ class SchemaClass:
     fields: list[Field] = dc.field(default_factory=list)
     model_type: ModelType = ModelType.model
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         yield self.base_type
         for prop in self.fields:
-            yield from prop.dependencies
+            yield prop.annotation.type
 
 
 @dc.dataclass
@@ -200,7 +193,6 @@ class ClientInit:
     response_map: ResponseMap = dc.field(default_factory=dict)
     security: SecurityRequirements | None = None
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         for mime_map in self.response_map.values():
             yield from mime_map.values()
@@ -211,11 +203,10 @@ class ClientClass:
     init_method: ClientInit
     methods: list[OperationFunction] = dc.field(default_factory=list)
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
-        yield from self.init_method.dependencies
+        yield from self.init_method.dependencies()
         for fn in self.methods:
-            yield from fn.dependencies
+            yield from fn.dependencies()
 
 
 @dc.dataclass(frozen=True)
@@ -225,7 +216,6 @@ class ResponseHeader:
     type: TypeHint
     annotation: Literal['Cookie', 'Header', 'Link']
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         yield self.type
 
@@ -236,8 +226,7 @@ class ResponseEnvelopeModel:
     headers: Iterable[ResponseHeader]
     body_type: TypeHint
 
-    @property
     def dependencies(self) -> Iterable[TypeHint]:
         yield self.body_type
         for header in self.headers:
-            yield from header.dependencies
+            yield from header.dependencies()

src/lapidary/render/model/python/module.py

@@ -4,12 +4,13 @@
 
 from .model import ClientClass, ResponseEnvelopeModel, SchemaClass
 from .module_path import ModulePath
-from .type_hint import GenericTypeHint, TypeHint
+from .type_hint import NONE, TypeHint, flatten
 
 template_imports = [
     'builtins',
     'typing',
     'typing_extensions',
+    'lapidary.runtime',
 ]
 
 
@@ -19,13 +20,23 @@ class AbstractModule[Body](abc.ABC):
     module_type: str
     body: Body = dc.field()
 
-    @property
     @abc.abstractmethod
-    def imports(self) -> Iterable[str]:
+    def dependencies(self) -> Iterable[TypeHint]:
         pass
 
     @property
-    def rel_path(self) -> str:
+    def imports(self) -> Iterable[str]:
+        dependencies = flatten(self.dependencies())
+        return sorted(
+            {
+                dep.module
+                for dep in dependencies
+                if dep.module not in template_imports and dep != NONE and dep.module != str(self.path)
+            }
+        )
+
+    @property
+    def file_path(self) -> str:
         return self.path.to_path()
 
 
@@ -34,20 +45,16 @@ class AuthModule(AbstractModule[Mapping[str, TypeHint]]):
     module_type = 'auth'
 
     @property
-    def imports(self) -> Iterable[str]:
-        yield from ()
+    def dependencies(self) -> Iterable[TypeHint]:
+        return self.body.values()
 
 
 @dc.dataclass(frozen=True, kw_only=True)
 class ClientModule(AbstractModule[ClientClass]):
     module_type: str = dc.field(default='client')
 
-    @property
-    def imports(self) -> Iterable[str]:
-        dependencies = GenericTypeHint.union_of(*self.body.dependencies).args  # flatten unions
-        imports = sorted({imp for dep in dependencies if dep for imp in dep.imports() if imp not in template_imports})
-
-        return imports
+    def dependencies(self) -> Iterable[TypeHint]:
+        return self.body.dependencies()
 
 
 @dc.dataclass(frozen=True, kw_only=True)
@@ -57,18 +64,16 @@ class EmptyModule(AbstractModule[None]):
     module_type: str = dc.field(default='empty')
     body: None = None
 
-    @property
-    def imports(self) -> Iterable[str]:
-        yield from ()
+    def dependencies(self) -> Iterable[TypeHint]:
+        return ()
 
 
 @dc.dataclass(frozen=True, kw_only=True)
 class ResponseEnvelopeModule(AbstractModule[ResponseEnvelopeModel]):
     module_type: str = dc.field(default='response')
 
-    @property
-    def imports(self) -> Iterable[str]:
-        yield from self.body.dependencies
+    def dependencies(self) -> Iterable[TypeHint]:
+        return self.body.dependencies()
 
 
 @dc.dataclass(frozen=True, kw_only=True)
@@ -80,14 +85,6 @@ class SchemaModule(AbstractModule[Iterable[SchemaClass]]):
 
     module_type: str = 'schema'
 
-    @property
-    def imports(self) -> Iterable[str]:
-        dependencies = GenericTypeHint.union_of(
-            *[dep for cls in self.body for dep in cls.dependencies]
-        ).args  # flatten unions
-        imports = sorted({imp for dep in dependencies if dep for imp in dep.imports() if imp not in template_imports})
-        path_str = str(self.path)
-        if path_str in imports:
-            imports.remove(path_str)
-
-        return imports
+    def dependencies(self) -> Iterable[TypeHint]:
+        for schema in self.body:
+            yield from schema.dependencies()

src/lapidary/render/model/python/type_hint.py

@@ -1,5 +1,5 @@
 import dataclasses as dc
-from collections.abc import Collection, Iterable
+from collections.abc import Collection, Iterable, MutableSet
 from typing import cast
 
 
@@ -39,8 +39,8 @@ def is_union(self) -> bool:
     def is_none(self) -> bool:
         return False
 
-    def _types(self) -> 'Iterable[TypeHint]':
-        return [self]
+    def dependencies(self) -> 'Iterable[TypeHint]':
+        return ()
 
     def __eq__(self, other) -> bool:
         return isinstance(other, TypeHint) and self.module == other.module and self.name == other.name
@@ -57,12 +57,9 @@ def __repr__(self):
         return self.full_name()
 
     @staticmethod
-    def from_str(name: str) -> 'BuiltinTypeHint':
+    def from_str(name: str) -> TypeHint:
         return BuiltinTypeHint(name=name)
 
-    def imports(self) -> list[str]:
-        return []
-
     def full_name(self):
         return self.name
 
@@ -84,11 +81,8 @@ def union_of(*types: TypeHint) -> 'GenericTypeHint':
     def is_union(self) -> bool:
         return self.module == 'typing' and self.name == 'Union'
 
-    def imports(self) -> list[str]:
-        return [imp for typ in self._types() for imp in TypeHint.imports(typ) if imp != 'builtins']
-
-    def _types(self) -> Iterable[TypeHint]:
-        return [self, *[typ for arg in self.args for typ in arg._types()]]
+    def dependencies(self) -> Iterable[TypeHint]:
+        yield from self.args
 
     def __repr__(self) -> str:
         return self.full_name()
@@ -118,7 +112,7 @@ def __hash__(self) -> int:
 
 class NoneTypeHint(TypeHint):
     def __init__(self):
-        super().__init__(module=None, name=None)
+        super().__init__(module='types', name='NoneType')
 
     def full_name(self):
         return 'None'
@@ -146,3 +140,15 @@ def type_hint_or_union(types: Collection[TypeHint]) -> TypeHint:
         return next(iter(types))
     else:
         return GenericTypeHint.union_of(*types)
+
+
+def flatten(types: Iterable[TypeHint]) -> Iterable[TypeHint]:
+    all_types = set()
+    _flatten(types, all_types)
+    return GenericTypeHint.union_of(*all_types).args
+
+
+def _flatten(types: Iterable[TypeHint], target: MutableSet[TypeHint]) -> None:
+    for typ in types:
+        target.add(typ)
+        _flatten(typ.dependencies(), target)

src/lapidary/render/templates/render/includes/module/response.py.jinja

@@ -1,9 +1,12 @@
 {% import 'includes/type_hint.py.jinja' as th -%}
 
 from __future__ import annotations
-import typing_extensions as typing
 
+import typing_extensions as typing
 from lapidary.runtime import *
+{%- for imp in item.imports %}
+import {{ imp }}
+{%- endfor %}
 
 
 class {{item.body.name}}(ResponseEnvelope):

src/lapidary/render/templates/render/includes/module/schema.py.jinja

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import typing
-
 import lapidary.runtime
 import pydantic
-import typing_extensions
+import typing_extensions as typing
 
 {%- for imp in item.imports %}
 import {{ imp }}