@typespec/http-client-python 0.5.1 → 0.6.0

package/generator/pygen/codegen/models/code_model.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Dict, Any, Set, Union, Literal
+from typing import List, Dict, Any, Set, Union, Literal, Optional, cast
 
 from .base import BaseType
 from .enum_type import EnumType
@@ -11,12 +11,40 @@ from .model_type import ModelType, UsageFlags
 from .combined_type import CombinedType
 from .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
+from .operation_group import OperationGroup
+from .utils import NamespaceType
 
 
 def _is_legacy(options) -> bool:
     return not (options.get("version_tolerant") or options.get("low_level_client"))
 
 
+def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
+    operation_groups = []
+    queue = []
+    for client in clients:
+        queue.extend(client.operation_groups)
+    while queue:
+        operation_groups.append(queue.pop(0))
+        if operation_groups[-1].operation_groups:
+            queue.extend(operation_groups[-1].operation_groups)
+    return operation_groups
+
+
+class ClientNamespaceType:
+    def __init__(
+        self,
+        clients: Optional[List[Client]] = None,
+        models: Optional[List[ModelType]] = None,
+        enums: Optional[List[EnumType]] = None,
+        operation_groups: Optional[List[OperationGroup]] = None,
+    ):
+        self.clients = clients or []
+        self.models = models or []
+        self.enums = enums or []
+        self.operation_groups = operation_groups or []
+
+
 class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-instance-attributes
     """Top level code model
 
@@ -44,8 +72,6 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self,
         yaml_data: Dict[str, Any],
         options: Dict[str, Any],
-        *,
-        is_subnamespace: bool = False,
     ) -> None:
         self.yaml_data = yaml_data
         self.options = options
@@ -59,18 +85,113 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.clients: List[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
-        self.subnamespace_to_clients: Dict[str, List[Client]] = {
-            subnamespace: [Client.from_yaml(client_yaml, self, is_subclient=True) for client_yaml in client_yamls]
-            for subnamespace, client_yamls in yaml_data.get("subnamespaceToClients", {}).items()
-        }
         if self.options["models_mode"] and self.model_types:
             self.sort_model_types()
-        self.is_subnamespace = is_subnamespace
         self.named_unions: List[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
         self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
         self.for_test: bool = False
+        # key is typespec namespace, value is models/clients/opeartion_groups/enums cache in the namespace
+        self._client_namespace_types: Dict[str, ClientNamespaceType] = {}
+        self.has_subnamespace = False
+        self._operations_folder_name: Dict[str, str] = {}
+        self._relative_import_path: Dict[str, str] = {}
+
+    @staticmethod
+    def get_imported_namespace_for_client(imported_namespace: str, async_mode: bool = False) -> str:
+        return imported_namespace + (".aio" if async_mode else "")
+
+    @staticmethod
+    def get_imported_namespace_for_model(imported_namespace: str) -> str:
+        return imported_namespace + ".models"
+
+    def get_imported_namespace_for_operation(self, imported_namespace: str, async_mode: bool = False) -> str:
+        module_namespace = f".{self.operations_folder_name(imported_namespace)}"
+        return self.get_imported_namespace_for_client(imported_namespace, async_mode) + module_namespace
+
+    # | serialize_namespace  | imported_namespace   | relative_import_path |
+    # |----------------------|----------------------|----------------------|
+    # |azure.test.operations | azure.test.operations| .                    |
+    # |azure.test.operations | azure.test           | ..                   |
+    # |azure.test.operations | azure.test.subtest   | ..subtest            |
+    # |azure.test.operations | azure                | ...                  |
+    # |azure.test.aio.operations | azure.test       | ...                  |
+    # |azure.test.subtest.aio.operations|azure.test | ....                 |
+    # |azure.test            |azure.test.subtest    | .subtest             |
+    def get_relative_import_path(
+        self,
+        serialize_namespace: str,
+        imported_namespace: Optional[str] = None,
+        module_name: Optional[str] = None,
+    ) -> str:
+        if imported_namespace is None:
+            imported_namespace = self.namespace
+
+        key = f"{serialize_namespace}-{imported_namespace}"
+        if key not in self._relative_import_path:
+            idx = 0
+            serialize_namespace_split = serialize_namespace.split(".")
+            imported_namespace_split = cast(str, imported_namespace).split(".")
+            while idx < min(len(serialize_namespace_split), len(imported_namespace_split)):
+                if serialize_namespace_split[idx] != imported_namespace_split[idx]:
+                    break
+                idx += 1
+            self._relative_import_path[key] = "." * (len(serialize_namespace_split[idx:]) + 1) + ".".join(
+                imported_namespace_split[idx:]
+            )
+        result = self._relative_import_path[key]
+        if module_name is None:
+            return result
+        return f"{result}{module_name}" if result.endswith(".") else f"{result}.{module_name}"
+
+    @property
+    def need_unique_model_alias(self) -> bool:
+        return self.has_subnamespace and self.options["enable_typespec_namespace"]
+
+    def get_unique_models_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
+        if not self.need_unique_model_alias:
+            return "_models"
+        relative_path = self.get_relative_import_path(
+            serialize_namespace, self.get_imported_namespace_for_model(imported_namespace)
+        )
+        dot_num = max(relative_path.count(".") - 1, 0)
+        parts = [""] + ([p for p in relative_path.split(".") if p] or ["models"])
+        return "_".join(parts) + (str(dot_num) if dot_num > 0 else "")
+
+    @property
+    def client_namespace_types(self) -> Dict[str, ClientNamespaceType]:
+        if not self._client_namespace_types:
+            # calculate client namespace types for each kind of client namespace
+            for client in self.clients:
+                if client.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[client.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[client.client_namespace].clients.append(client)
+            for model in self.model_types:
+                if model.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[model.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[model.client_namespace].models.append(model)
+            for enum in self.enums:
+                if enum.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[enum.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[enum.client_namespace].enums.append(enum)
+            for operation_group in get_all_operation_groups_recursively(self.clients):
+                if operation_group.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[operation_group.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[operation_group.client_namespace].operation_groups.append(operation_group)
+
+            # here we can check and record whether there are multi kinds of client namespace
+            if len(self._client_namespace_types.keys()) > 1:
+                self.has_subnamespace = True
+
+            # insert namespace to make sure it is continuous(e.g. ("", "azure", "azure.mgmt", "azure.mgmt.service"))
+            longest_namespace = sorted(self._client_namespace_types.keys())[-1]
+            namespace_parts = longest_namespace.split(".")
+            for idx in range(len(namespace_parts) + 1):
+                namespace = ".".join(namespace_parts[:idx])
+                if namespace not in self._client_namespace_types:
+                    self._client_namespace_types[namespace] = ClientNamespaceType()
+        return self._client_namespace_types
 
     @property
     def has_form_data(self) -> bool:
@@ -80,17 +201,17 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def has_etag(self) -> bool:
         return any(client.has_etag for client in self.clients)
 
+    @staticmethod
+    def clients_has_operations(clients: List[Client]) -> bool:
+        return any(c for c in clients if c.has_operations)
+
     @property
     def has_operations(self) -> bool:
-        if any(c for c in self.clients if c.has_operations):
-            return True
-        return any(c for clients in self.subnamespace_to_clients.values() for c in clients if c.has_operations)
+        return self.clients_has_operations(self.clients)
 
     @property
     def has_non_abstract_operations(self) -> bool:
-        return any(c for c in self.clients if c.has_non_abstract_operations) or any(
-            c for cs in self.subnamespace_to_clients.values() for c in cs if c.has_non_abstract_operations
-        )
+        return any(c for c in self.clients if c.has_non_abstract_operations)
 
     def lookup_request_builder(self, request_builder_id: int) -> Union[RequestBuilder, OverloadedRequestBuilder]:
         """Find the request builder based off of id"""
@@ -114,31 +235,73 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def client_filename(self) -> str:
         return self.clients[0].filename
 
-    def need_vendored_code(self, async_mode: bool) -> bool:
-        """Whether we need to vendor code in the _vendor.py file for this SDK"""
-        if self.has_abstract_operations:
-            return True
-        if async_mode:
-            return self.need_mixin_abc
-        return self.need_mixin_abc or self.has_etag or self.has_form_data
+    def get_clients(self, client_namespace: str) -> List[Client]:
+        """Get all clients in specific namespace"""
+        return self.client_namespace_types.get(client_namespace, ClientNamespaceType()).clients
 
-    @property
-    def need_mixin_abc(self) -> bool:
-        return any(c for c in self.clients if c.has_mixin)
+    def is_top_namespace(self, client_namespace: str) -> bool:
+        """Whether the namespace is the top namespace. For example, a package named 'azure-mgmt-service',
+        'azure.mgmt.service' is the top namespace.
+        """
+        return client_namespace == self.namespace
+
+    def need_vendored_code(self, async_mode: bool, client_namespace: str) -> bool:
+        """Whether we need to vendor code in the _vendor.py in specific namespace"""
+        return (
+            self.need_vendored_form_data(async_mode, client_namespace)
+            or self.need_vendored_etag(client_namespace)
+            or self.need_vendored_abstract(client_namespace)
+            or self.need_vendored_mixin(client_namespace)
+        )
+
+    def need_vendored_form_data(self, async_mode: bool, client_namespace: str) -> bool:
+        return (
+            (not async_mode)
+            and self.is_top_namespace(client_namespace)
+            and self.has_form_data
+            and self.options["models_mode"] == "dpg"
+        )
+
+    def need_vendored_etag(self, client_namespace: str) -> bool:
+        return self.is_top_namespace(client_namespace) and self.has_etag
+
+    def need_vendored_abstract(self, client_namespace: str) -> bool:
+        return self.is_top_namespace(client_namespace) and self.has_abstract_operations
+
+    def need_vendored_mixin(self, client_namespace: str) -> bool:
+        return self.has_mixin(client_namespace)
+
+    def has_mixin(self, client_namespace: str) -> bool:
+        return any(c for c in self.get_clients(client_namespace) if c.has_mixin)
 
     @property
     def has_abstract_operations(self) -> bool:
         return any(c for c in self.clients if c.has_abstract_operations)
 
-    @property
-    def operations_folder_name(self) -> str:
+    def operations_folder_name(self, client_namespace: str) -> str:
         """Get the name of the operations folder that holds operations."""
-        name = "operations"
-        if self.options["version_tolerant"] and not any(
-            og for client in self.clients for og in client.operation_groups if not og.is_mixin
-        ):
-            name = f"_{name}"
-        return name
+        if client_namespace not in self._operations_folder_name:
+            name = "operations"
+            operation_groups = self.client_namespace_types.get(client_namespace, ClientNamespaceType()).operation_groups
+            if self.options["version_tolerant"] and all(og.is_mixin for og in operation_groups):
+                name = f"_{name}"
+            self._operations_folder_name[client_namespace] = name
+        return self._operations_folder_name[client_namespace]
+
+    def get_serialize_namespace(
+        self,
+        client_namespace: str,
+        async_mode: bool = False,
+        client_namespace_type: NamespaceType = NamespaceType.CLIENT,
+    ) -> str:
+        """calculate the namespace for serialization from client namespace"""
+        if client_namespace_type == NamespaceType.CLIENT:
+            return client_namespace + (".aio" if async_mode else "")
+        if client_namespace_type == NamespaceType.MODEL:
+            return client_namespace + ".models"
+
+        operations_folder_name = self.operations_folder_name(client_namespace)
+        return client_namespace + (".aio." if async_mode else ".") + operations_folder_name
 
     @property
     def description(self) -> str:
@@ -170,9 +333,13 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def model_types(self, val: List[ModelType]) -> None:
         self._model_types = val
 
+    @staticmethod
+    def get_public_model_types(models: List[ModelType]) -> List[ModelType]:
+        return [m for m in models if not m.internal and not m.base == "json"]
+
     @property
     def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if not m.internal and not m.base == "json"]
+        return self.get_public_model_types(self.model_types)
 
     @property
     def enums(self) -> List[EnumType]:

package/generator/pygen/codegen/models/combined_type.py

@@ -8,6 +8,7 @@ import re
 from .imports import FileImport, ImportType, TypingSection
 from .base import BaseType
 from .model_type import ModelType
+from .utils import NamespaceType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -30,9 +31,9 @@ class CombinedType(BaseType):
         self.types = types  # the types that this type is combining
         self.name = yaml_data.get("name")
         self._is_union_of_literals = all(i.type == "constant" for i in self.types)
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """The tag recognized by 'msrest' as a serialization/deserialization.
 
         'str', 'int', 'float', 'bool' or
@@ -45,7 +46,7 @@ class CombinedType(BaseType):
         """
         if not all(t for t in self.types if t.type == "constant"):
             raise ValueError("Shouldn't get serialization type of a combinedtype")
-        return self.types[0].serialization_type
+        return self.types[0].serialization_type(**kwargs)
 
     @property
     def client_default_value(self) -> Any:
@@ -112,9 +113,11 @@ class CombinedType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        if self.name and not kwargs.get("is_types_file"):
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
+        if self.name and serialize_namespace_type != NamespaceType.TYPES_FILE:
             file_import.add_submodule_import(
-                kwargs.pop("relative_path"),
+                self.code_model.get_relative_import_path(serialize_namespace),
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/generator/pygen/codegen/models/constant_type.py

@@ -56,14 +56,13 @@ class ConstantType(BaseType):
             f"Default value is {self.get_declaration()}.",
         )
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """Returns the serialization value for msrest.
 
         :return: The serialization value for msrest
         :rtype: str
         """
-        return self.value_type.serialization_type
+        return self.value_type.serialization_type(**kwargs)
 
     def docstring_text(self, **kwargs: Any) -> str:
         return "constant"

package/generator/pygen/codegen/models/credential_types.py

@@ -131,8 +131,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):
     def docstring_text(self, **kwargs: Any) -> str:
         return "credential"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.docstring_type()
 
     @classmethod

package/generator/pygen/codegen/models/dictionary_type.py

@@ -34,14 +34,13 @@ class DictionaryType(BaseType):
     def encode(self) -> Optional[str]:
         return self.element_type.encode if hasattr(self.element_type, "encode") else None  # type: ignore
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """Returns the serialization value for msrest.
 
         :return: The serialization value for msrest
         :rtype: str
         """
-        return f"{{{self.element_type.serialization_type}}}"
+        return f"{{{self.element_type.serialization_type(**kwargs)}}}"
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation

package/generator/pygen/codegen/models/enum_type.py

@@ -7,6 +7,8 @@ from typing import Any, Dict, List, TYPE_CHECKING, Optional, cast
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
+from .utils import NamespaceType
+
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -63,9 +65,8 @@ class EnumValue(BaseType):
             client_default_value_declaration=client_default_value_declaration,
         )
 
-    @property
-    def serialization_type(self) -> str:
-        return self.value_type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.value_type.serialization_type(**kwargs)
 
     @property
     def instance_check_template(self) -> str:
@@ -75,7 +76,17 @@ class EnumValue(BaseType):
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
-        file_import.add_submodule_import("._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR)
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        file_import.add_submodule_import(
+            self.code_model.get_relative_import_path(
+                serialize_namespace,
+                self.code_model.get_imported_namespace_for_model(self.enum_type.client_namespace),
+                module_name=self.code_model.enums_filename,
+            ),
+            self.enum_type.name,
+            ImportType.LOCAL,
+            TypingSection.REGULAR,
+        )
 
         return file_import
 
@@ -124,18 +135,18 @@ class EnumType(BaseType):
         self.value_type = value_type
         self.internal: bool = self.yaml_data.get("internal", False)
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
 
     def __lt__(self, other):
         return self.name.lower() < other.name.lower()
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """Returns the serialization value for msrest.
 
         :return: The serialization value for msrest
         :rtype: str
         """
-        return self.value_type.serialization_type
+        return self.value_type.serialization_type(**kwargs)
 
     def description(self, *, is_operation_file: bool) -> str:
         possible_values = [self.get_declaration(v.value) for v in self.values]
@@ -160,7 +171,12 @@ class EnumType(BaseType):
         :rtype: str
         """
         if self.code_model.options["models_mode"]:
-            module_name = "_models." if kwargs.get("need_module_name", True) else ""
+
+            module_name = ""
+            if kwargs.get("need_model_alias", True):
+                serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                model_alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
+                module_name = f"{model_alias}."
             file_name = f"{self.code_model.enums_filename}." if self.internal else ""
             model_name = module_name + file_name + self.name
             # we don't need quoted annotation in operation files, and need it in model folder files.
@@ -212,27 +228,34 @@ class EnumType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        operation = kwargs.pop("operation", False)
         file_import = FileImport(self.code_model)
+        file_import.merge(self.value_type.imports(**kwargs))
         if self.code_model.options["models_mode"]:
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
-            if not operation:
+
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+            relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+            alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
+            serialize_namespace_type = kwargs.get("serialize_namespace_type")
+            called_by_property = kwargs.get("called_by_property", False)
+            if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
                 file_import.add_submodule_import(
-                    "..",
+                    relative_path,
                     "models",
                     ImportType.LOCAL,
-                    TypingSection.TYPING,
-                    alias="_models",
+                    alias=alias,
+                    typing_section=TypingSection.REGULAR,
                 )
-        file_import.merge(self.value_type.imports(operation=operation, **kwargs))
-        relative_path = kwargs.pop("relative_path", None)
-        if self.code_model.options["models_mode"] and relative_path:
-            # add import for enums in operations file
-            file_import.add_submodule_import(
-                relative_path,
-                "models",
-                ImportType.LOCAL,
-                alias="_models",
-                typing_section=(TypingSection.TYPING if kwargs.get("model_typing") else TypingSection.REGULAR),
-            )
+            elif serialize_namespace_type == NamespaceType.TYPES_FILE or (
+                serialize_namespace_type == NamespaceType.MODEL and called_by_property
+            ):
+                file_import.add_submodule_import(
+                    relative_path,
+                    "models",
+                    ImportType.LOCAL,
+                    alias=alias,
+                    typing_section=TypingSection.TYPING,
+                )
+
+        file_import.merge(self.value_type.imports(**kwargs))
         return file_import

package/generator/pygen/codegen/models/imports.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum, auto
 from typing import Dict, List, Optional, Tuple, Union, Set, TYPE_CHECKING
+from .._utils import get_parent_namespace
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -259,7 +260,7 @@ class FileImport:
     def add_msrest_import(
         self,
         *,
-        relative_path: str,
+        serialize_namespace: str,
         msrest_import_type: MsrestImportType,
         typing_section: TypingSection,
     ):
@@ -271,21 +272,22 @@ class FileImport:
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:
                     self.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, typing_section)
         else:
+            # _serialization.py is always in root namespace
+            imported_namespace = self.code_model.namespace
             if self.code_model.options["multiapi"]:
-                relative_path += "."
+                # for multiapi, the namespace is azure.mgmt.xxx.v20XX_XX_XX while _serialization.py is in azure.mgmt.xxx
+                imported_namespace = get_parent_namespace(imported_namespace)
             if msrest_import_type == MsrestImportType.Module:
-                self.add_submodule_import(relative_path, "_serialization", ImportType.LOCAL, typing_section)
-            else:
                 self.add_submodule_import(
-                    f"{relative_path}_serialization",
-                    "Serializer",
+                    self.code_model.get_relative_import_path(serialize_namespace, imported_namespace),
+                    "_serialization",
                     ImportType.LOCAL,
                     typing_section,
                 )
+            else:
+                relative_path = self.code_model.get_relative_import_path(
+                    serialize_namespace, imported_namespace, module_name="_serialization"
+                )
+                self.add_submodule_import(relative_path, "Serializer", ImportType.LOCAL, typing_section)
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:
-                    self.add_submodule_import(
-                        f"{relative_path}_serialization",
-                        "Deserializer",
-                        ImportType.LOCAL,
-                        typing_section,
-                    )
+                    self.add_submodule_import(relative_path, "Deserializer", ImportType.LOCAL, typing_section)

package/generator/pygen/codegen/models/list_type.py

@@ -29,9 +29,8 @@ class ListType(BaseType):
     def encode(self) -> Optional[str]:
         return self.element_type.encode if hasattr(self.element_type, "encode") else None  # type: ignore
 
-    @property
-    def serialization_type(self) -> str:
-        return f"[{self.element_type.serialization_type}]"
+    def serialization_type(self, **kwargs: Any) -> str:
+        return f"[{self.element_type.serialization_type(**kwargs)}]"
 
     def type_annotation(self, **kwargs: Any) -> str:
         if (

package/generator/pygen/codegen/models/lro_operation.py

@@ -92,9 +92,9 @@ class LROOperationBase(OperationBase[LROResponseType]):
             return lro_response.type_annotation(**kwargs)
         return "None"
 
-    def cls_type_annotation(self, *, async_mode: bool) -> str:
+    def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
         """We don't want the poller to show up in ClsType, so we call super() on response type annotation"""
-        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
+        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode, **kwargs)}]"
 
     def get_poller_with_response_type(self, async_mode: bool) -> str:
         return self.response_type_annotation(async_mode=async_mode)
@@ -132,8 +132,12 @@ class LROOperationBase(OperationBase[LROResponseType]):
         ):
             # used in the case if initial operation returns none
             # but final call returns a model
-            relative_path = "..." if async_mode else ".."
-            file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", 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="_model_base"),
+                "_deserialize",
+                ImportType.LOCAL,
+            )
         file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
         return file_import

package/generator/pygen/codegen/models/lro_paging_operation.py

@@ -20,8 +20,8 @@ class LROPagingOperation(LROOperationBase[LROPagingResponse], PagingOperationBas
     def operation_type(self) -> str:
         return "lropaging"
 
-    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(self, async_mode: bool, **kwargs: Any) -> FileImport:
         lro_imports = LROOperationBase.imports(self, async_mode, **kwargs)