@typespec/http-client-python 0.5.1 → 0.6.0

package/generator/build/lib/pygen/codegen/models/operation_group.py

@@ -10,7 +10,7 @@ from .utils import OrderedSet
 from .base import BaseModel
 from .operation import get_operation
 from .imports import FileImport, ImportType, TypingSection
-from .utils import add_to_pylint_disable
+from .utils import add_to_pylint_disable, NamespaceType
 from .lro_operation import LROOperation
 from .lro_paging_operation import LROPagingOperation
 from ...utils import NAME_LENGTH_LIMIT
@@ -46,6 +46,10 @@ class OperationGroup(BaseModel):
                 for op_group in self.yaml_data.get("operationGroups", [])
             ]
             self.link_lro_initial_operations()
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
+        self.has_parent_operation_group: bool = False
+        for og in self.operation_groups:
+            og.has_parent_operation_group = True
 
     @property
     def has_abstract_operations(self) -> bool:
@@ -66,11 +70,11 @@ class OperationGroup(BaseModel):
             base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
+    def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
         relative_path = ".." if async_mode else "."
         for operation in self.operations:
-            file_import.merge(operation.imports_for_multiapi(async_mode, relative_path=relative_path))
+            file_import.merge(operation.imports_for_multiapi(async_mode, **kwargs))
         if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
             "models_mode"
         ] == "msrest":
@@ -94,30 +98,71 @@ class OperationGroup(BaseModel):
         """Whether any of its operations need validation"""
         return any(o for o in self.operations if o.need_validation)
 
-    def imports(self, async_mode: bool) -> FileImport:
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
 
-        relative_path = ("..." if async_mode else "..") + ("." if self.client.is_subclient else "")
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         for operation in self.operations:
-            file_import.merge(operation.imports(async_mode, relative_path=relative_path))
+            file_import.merge(operation.imports(async_mode, **kwargs))
         if not self.code_model.options["combine_operation_files"]:
             for og in self.operation_groups:
                 file_import.add_submodule_import(
-                    ".",
+                    self.code_model.get_relative_import_path(
+                        serialize_namespace,
+                        self.code_model.get_imported_namespace_for_operation(self.client_namespace, async_mode),
+                    ),
                     og.class_name,
                     ImportType.LOCAL,
                 )
+        else:
+            for og in self.operation_groups:
+                namespace = self.code_model.get_serialize_namespace(
+                    og.client_namespace, async_mode, NamespaceType.OPERATION
+                )
+                if namespace != serialize_namespace:
+                    file_import.add_submodule_import(
+                        self.code_model.get_relative_import_path(
+                            serialize_namespace,
+                            self.code_model.get_imported_namespace_for_operation(og.client_namespace, async_mode),
+                        )
+                        + f".{og.filename}",
+                        og.class_name,
+                        ImportType.LOCAL,
+                    )
         # for multiapi
         if (
             (self.code_model.public_model_types)
             and self.code_model.options["models_mode"] == "msrest"
             and not self.is_mixin
         ):
-            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(serialize_namespace),
+                "models",
+                ImportType.LOCAL,
+                alias="_models",
+            )
         if self.is_mixin:
-            file_import.add_submodule_import(".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL)
+            file_import.add_submodule_import(
+                # XxxMixinABC is always defined in _vendor of client namespace
+                self.code_model.get_relative_import_path(
+                    serialize_namespace,
+                    self.code_model.get_imported_namespace_for_client(self.client.client_namespace, async_mode),
+                    module_name="_vendor",
+                ),
+                f"{self.client.name}MixinABC",
+                ImportType.LOCAL,
+            )
         if self.has_abstract_operations:
-            file_import.add_submodule_import(".._vendor", "raise_if_not_implemented", ImportType.LOCAL)
+            file_import.add_submodule_import(
+                # raise_if_not_implemented is always defined in _vendor of top namespace
+                self.code_model.get_relative_import_path(
+                    serialize_namespace,
+                    self.code_model.get_imported_namespace_for_client(self.code_model.namespace, async_mode),
+                    module_name="_vendor",
+                ),
+                "raise_if_not_implemented",
+                ImportType.LOCAL,
+            )
         if all(o.abstract for o in self.operations):
             return file_import
         file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
@@ -128,7 +173,7 @@ class OperationGroup(BaseModel):
 
     @property
     def filename(self) -> str:
-        return self.operations[0].filename
+        return self.operations[0].filename if self.operations else "_operations"
 
     @property
     def is_mixin(self) -> bool:

package/generator/build/lib/pygen/codegen/models/paging_operation.py

@@ -103,8 +103,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def operation_type(self) -> str:
         return "paging"
 
-    def cls_type_annotation(self, *, async_mode: bool) -> str:
-        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
+    def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
+        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode, **kwargs)}]"
 
     def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(async_mode, **kwargs)
@@ -117,7 +117,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             and self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
-            file_import.merge(self.next_request_builder.imports())
+            file_import.merge(self.next_request_builder.imports(**kwargs))
         return file_import
 
     @property
@@ -129,6 +129,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
@@ -136,7 +137,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 ImportType.SDKCORE,
             )
         if self.next_request_builder:
-            file_import.merge(self.get_request_builder_import(self.next_request_builder, async_mode))
+            file_import.merge(
+                self.get_request_builder_import(self.next_request_builder, async_mode, serialize_namespace)
+            )
         elif any(p.is_api_version for p in self.client.parameters):
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
@@ -145,10 +148,10 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 ImportType.SDKCORE,
             )
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = "..." if async_mode else ".."
+            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
             file_import.merge(self.item_type.imports(**kwargs))
             if self.default_error_deserialization or any(r.type for r in self.responses):
-                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
+                file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
         return file_import
 
 

package/generator/build/lib/pygen/codegen/models/parameter.py

@@ -155,23 +155,23 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
     def docstring_type(self, **kwargs: Any) -> str:
         return self.type.docstring_type(**kwargs)
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type.serialization_type(**kwargs)
 
-    def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
         file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         if self.added_on and self.implementation != "Client":
             file_import.add_submodule_import(
-                f"{'.' if async_mode else ''}.._validation",
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_validation"),
                 "api_version_validation",
                 ImportType.LOCAL,
             )
         if isinstance(self.type, CombinedType) and self.type.name:
             file_import.add_submodule_import(
-                "..." if async_mode else "..",
+                self.code_model.get_relative_import_path(serialize_namespace),
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,
@@ -212,8 +212,8 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
     @abc.abstractmethod
     def in_method_signature(self) -> bool: ...
 
-    def method_signature(self, async_mode: bool) -> str:
-        type_annotation = self.type_annotation(async_mode=async_mode)
+    def method_signature(self, async_mode: bool, **kwargs: Any) -> str:
+        type_annotation = self.type_annotation(async_mode=async_mode, **kwargs)
         if self.client_default_value is not None or self.optional:
             return f"{self.client_name}: {type_annotation} = {self.client_default_value_declaration},"
         if self.default_to_unset_sentinel:
@@ -272,9 +272,9 @@ class BodyParameter(_ParameterBase):
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = super().imports(async_mode, **kwargs)
         if self.is_form_data:
-            relative_path = "..." if async_mode else ".."
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                f"{relative_path}_vendor",
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
                 "prepare_multipart_form_data",
                 ImportType.LOCAL,
             )

package/generator/build/lib/pygen/codegen/models/parameter_list.py

@@ -200,22 +200,22 @@ class _ParameterListBase(
         """Sorted method params. First positional, then keyword only, then kwarg"""
         return self.positional + self.keyword_only + self.kwarg
 
-    def method_signature(self, async_mode: bool) -> List[str]:
+    def method_signature(self, async_mode: bool, **kwargs: Any) -> List[str]:
         """Method signature for this parameter list."""
         return method_signature_helper(
-            positional=self.method_signature_positional(async_mode),
-            keyword_only=self.method_signature_keyword_only(async_mode),
+            positional=self.method_signature_positional(async_mode, **kwargs),
+            keyword_only=self.method_signature_keyword_only(async_mode, **kwargs),
             kwarg_params=self.method_signature_kwargs,
         )
 
-    def method_signature_positional(self, async_mode: bool) -> List[str]:
+    def method_signature_positional(self, async_mode: bool, **kwargs: Any) -> List[str]:
         """Signature for positional parameters"""
-        return [parameter.method_signature(async_mode) for parameter in self.positional]
+        return [parameter.method_signature(async_mode, **kwargs) for parameter in self.positional]
 
-    def method_signature_keyword_only(self, async_mode: bool) -> List[str]:
+    def method_signature_keyword_only(self, async_mode: bool, **kwargs: Any) -> List[str]:
         """Signature for keyword only parameters"""
         result = [
-            parameter.method_signature(async_mode)
+            parameter.method_signature(async_mode, **kwargs)
             for parameter in self.keyword_only
             if not parameter.hide_in_operation_signature
         ]

package/generator/build/lib/pygen/codegen/models/primitive_types.py

@@ -49,8 +49,7 @@ class PrimitiveType(BaseType):
 
 
 class BooleanType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "bool"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -66,8 +65,7 @@ class BinaryType(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.type
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -84,17 +82,9 @@ class BinaryType(PrimitiveType):
         return self.get_declaration(b"bytes")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        from .combined_type import CombinedType
-        from .operation import OperationBase
-
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
-        operation = kwargs.get("operation")
-        if (
-            isinstance(operation, OperationBase)
-            and operation.parameters.has_body
-            and isinstance(operation.parameters.body_parameter.type, CombinedType)
-        ):
+        if kwargs.get("need_import_iobase", False):
             file_import.add_submodule_import("io", "IOBase", ImportType.STDLIB)
         return file_import
 
@@ -107,8 +97,7 @@ class BinaryIteratorType(PrimitiveType):
     def _iterator_name(self, **kwargs: Any) -> str:
         return "AsyncIterator" if kwargs.pop("async_mode") else "Iterator"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "IO"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -135,8 +124,7 @@ class BinaryIteratorType(PrimitiveType):
 
 
 class AnyType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "object"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -160,8 +148,7 @@ class AnyType(PrimitiveType):
 
 
 class AnyObjectType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "object"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -239,8 +226,7 @@ class IntegerType(NumberType):
         if yaml_data.get("encode") == "string":
             self.encode = "str"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "int"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -259,8 +245,7 @@ class IntegerType(NumberType):
 
 
 class FloatType(NumberType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "float"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -279,8 +264,7 @@ class FloatType(NumberType):
 
 
 class DecimalType(NumberType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "decimal"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -342,8 +326,7 @@ class StringType(PrimitiveType):
     def get_declaration(self, value) -> str:
         return f"'{value}'" if value == '"' else f'"{value}"'
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "str"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -363,8 +346,7 @@ class DatetimeType(PrimitiveType):
             else "rfc7231"
         )
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         formats_to_attribute_type = {
             "rfc3339": "iso-8601",
             "rfc7231": "rfc-1123",
@@ -410,8 +392,7 @@ class DatetimeType(PrimitiveType):
 
 
 class TimeType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "time"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -457,8 +438,7 @@ class UnixTimeType(PrimitiveType):
     def encode(self) -> str:
         return "unix-timestamp"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "unix-time"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -500,8 +480,7 @@ class UnixTimeType(PrimitiveType):
 
 
 class DateType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "date"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -543,8 +522,7 @@ class DateType(PrimitiveType):
 
 
 class DurationType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "duration"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -590,8 +568,7 @@ class ByteArraySchema(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = yaml_data.get("encode", "base64")
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         if self.encode == "base64url":
             return "base64"
         return "bytearray"
@@ -628,8 +605,7 @@ class SdkCoreType(PrimitiveType):
     def instance_check_template(self) -> str:
         return f"isinstance({{}}, {self.name})"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.name
 
 
@@ -646,8 +622,12 @@ class MultiPartFileType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
-        relative_path = "..." if kwargs.get("async_mode") else ".."
-        file_import.add_submodule_import(f"{relative_path}_vendor", self.name, ImportType.LOCAL)
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        file_import.add_submodule_import(
+            self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+            self.name,
+            ImportType.LOCAL,
+        )
         return file_import
 
     @property

package/generator/build/lib/pygen/codegen/models/property.py

@@ -76,9 +76,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def is_input(self):
         return not (self.constant or self.readonly or self.is_discriminator)
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type.serialization_type(**kwargs)
 
     @property
     def msrest_deserialization_key(self) -> str:
@@ -99,10 +98,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def xml_metadata(self) -> Optional[Dict[str, Union[str, bool]]]:
         return self.yaml_data.get("xmlMetadata")
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False, **kwargs: Any) -> str:
         if self.is_base_discriminator:
             return "str"
-        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file, **kwargs)
         if self.optional and self.client_default_value is None:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
@@ -144,12 +143,13 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         file_import = FileImport(self.code_model)
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
-        file_import.merge(self.type.imports(**kwargs, relative_path="..", model_typing=True))
+        file_import.merge(self.type.imports(**kwargs))
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                ".._model_base",
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base"),
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )

package/generator/build/lib/pygen/codegen/models/request_builder.py

@@ -7,11 +7,12 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     TypeVar,
     TYPE_CHECKING,
     Union,
     Optional,
+    Sequence,
+    cast,
 )
 from abc import abstractmethod
 
@@ -34,7 +35,7 @@ ParameterListType = TypeVar(
 )
 
 
-class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]]):
+class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder"]]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -43,7 +44,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
         name: str,
         parameters: ParameterListType,
         *,
-        overloads: Optional[List["RequestBuilder"]] = None,
+        overloads: Optional[Sequence["RequestBuilder"]] = None,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -53,7 +54,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
             parameters=parameters,
             overloads=overloads,
         )
-        self.overloads: List["RequestBuilder"] = overloads or []
+        self.overloads: Sequence["RequestBuilder"] = overloads or []
         self.url: str = yaml_data["url"]
         self.method: str = yaml_data["method"]
         self.want_tracing = False
@@ -84,15 +85,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
     def response_docstring_type(self, **kwargs) -> str:
         return f"~{self.code_model.core_library}.rest.HttpRequest"
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
-        relative_path = ".."
-        if not self.code_model.options["builders_visibility"] == "embedded" and self.group_name:
-            relative_path = "..." if self.group_name else ".."
         if self.abstract:
             return file_import
         for parameter in self.parameters.method:
-            file_import.merge(parameter.imports(async_mode=False, relative_path=relative_path, operation=self))
+            file_import.merge(parameter.imports(async_mode=False, **kwargs))
 
         file_import.add_submodule_import(
             "rest",
@@ -108,11 +106,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
             )
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL)
         file_import.add_msrest_import(
-            relative_path=(
-                "..."
-                if (not self.code_model.options["builders_visibility"] == "embedded" and self.group_name)
-                else ".."
-            ),
+            serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
             msrest_import_type=MsrestImportType.Serializer,
             typing_section=TypingSection.REGULAR,
         )
@@ -154,7 +148,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
         # So add operation group name is effective method
 
         overloads = [
-            RequestBuilder.from_yaml(rb_yaml_data, code_model, client)
+            cast(RequestBuilder, RequestBuilder.from_yaml(rb_yaml_data, code_model, client))
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
         parameter_list = cls.parameter_list_type()(yaml_data, code_model)

package/generator/build/lib/pygen/codegen/models/response.py

@@ -29,9 +29,8 @@ class ResponseHeader(BaseModel):
         self.wire_name: str = yaml_data["wireName"]
         self.type = type
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type.serialization_type(**kwargs)
 
     @classmethod
     def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ResponseHeader":
@@ -88,10 +87,9 @@ class Response(BaseModel):
         )
         return retval
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         if self.type:
-            return self.type.serialization_type
+            return self.type.serialization_type(**kwargs)
         return "None"
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -120,9 +118,9 @@ class Response(BaseModel):
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, CombinedType) and self.type.name:
-            async_mode = kwargs.get("async_mode", False)
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                "..." if async_mode else "..",
+                self.code_model.get_relative_import_path(serialize_namespace),
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/generator/build/lib/pygen/codegen/models/utils.py

@@ -5,6 +5,8 @@
 # --------------------------------------------------------------------------
 from typing import TypeVar, Dict
 
+from enum import Enum
+
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
@@ -19,3 +21,12 @@ def add_to_pylint_disable(curr_str: str, entry: str) -> str:
     if curr_str:
         return f"{curr_str},{entry}"
     return f"  # pylint: disable={entry}"
+
+
+class NamespaceType(str, Enum):
+    """Special signal for impports"""
+
+    MODEL = "model"
+    OPERATION = "operation"
+    CLIENT = "client"
+    TYPES_FILE = "types_file"