@autorest/python 6.27.4 → 6.28.1

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)

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

@@ -7,7 +7,7 @@ from enum import Enum
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 import sys
-from .utils import add_to_pylint_disable
+from .utils import add_to_pylint_disable, NamespaceType
 from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
@@ -82,6 +82,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
         self.usage: int = self.yaml_data.get("usage", UsageFlags.Input.value | UsageFlags.Output.value)
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
 
     @property
     def is_usage_output(self) -> bool:
@@ -254,8 +255,7 @@ class JSONModelType(ModelType):
     def type_annotation(self, **kwargs: Any) -> str:
         return "ET.Element" if self.is_xml else "JSON"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "object"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -281,13 +281,18 @@ class GeneratedModelType(ModelType):
     def type_annotation(self, **kwargs: Any) -> str:
         is_operation_file = kwargs.pop("is_operation_file", False)
         skip_quote = kwargs.get("skip_quote", False)
-        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.models_filename}." if self.internal else ""
         retval = module_name + file_name + self.name
         return retval if is_operation_file or skip_quote else f'"{retval}"'
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.namespace}.models.{self.type_annotation(need_module_name=False, skip_quote=True)}"
+        type_annotation = self.type_annotation(need_model_alias=False, skip_quote=True, **kwargs)
+        return f"~{self.code_model.namespace}.models.{type_annotation}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return self.name
@@ -298,32 +303,43 @@ class GeneratedModelType(ModelType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
-        relative_path = kwargs.pop("relative_path", None)
-        if relative_path:
-            # add import for models in operations or _types file
+        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)
+        # add import for models in operations or _types file
+        if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
             file_import.add_submodule_import(
                 relative_path,
                 "models",
                 ImportType.LOCAL,
-                alias="_models",
-                typing_section=(TypingSection.TYPING if kwargs.get("model_typing") else TypingSection.REGULAR),
+                alias=alias,
             )
             if self.is_form_data:
                 file_import.add_submodule_import(
-                    relative_path,
+                    self.code_model.get_relative_import_path(serialize_namespace),
                     "_model_base",
                     ImportType.LOCAL,
-                    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,
+            )
         return file_import
 
 
 class MsrestModelType(GeneratedModelType):
     base = "msrest"
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type_annotation(skip_quote=True) if self.internal else self.name
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type_annotation(skip_quote=True, **kwargs) if self.internal else self.name
 
     @property
     def instance_check_template(self) -> str:
@@ -338,12 +354,11 @@ class MsrestModelType(GeneratedModelType):
 class DPGModelType(GeneratedModelType):
     base = "dpg"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return (
-            self.type_annotation(skip_quote=True)
+            self.type_annotation(skip_quote=True, **kwargs)
             if self.internal
-            else self.type_annotation(need_module_name=False, skip_quote=True)
+            else self.type_annotation(need_model_alias=False, skip_quote=True, **kwargs)
         )
 
     @property

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

@@ -13,6 +13,7 @@ from typing import (
     Generic,
     TypeVar,
     cast,
+    Sequence,
 )
 
 from .request_builder_parameter import RequestBuilderParameter
@@ -34,7 +35,9 @@ from .parameter import (
 )
 from .parameter_list import ParameterList
 from .model_type import ModelType
+from .primitive_types import BinaryIteratorType, BinaryType
 from .base import BaseType
+from .combined_type import CombinedType
 from .request_builder import OverloadedRequestBuilder, RequestBuilder
 from ...utils import xml_serializable, json_serializable, NAME_LENGTH_LIMIT
 
@@ -54,7 +57,7 @@ def is_internal(target: Optional[BaseType]) -> bool:
 
 
 class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instance-attributes
-    Generic[ResponseType], BaseBuilder[ParameterList, List["Operation"]]
+    Generic[ResponseType], BaseBuilder[ParameterList, Sequence["Operation"]]
 ):
     def __init__(
         self,
@@ -67,7 +70,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         responses: List[ResponseType],
         exceptions: List[Response],
         *,
-        overloads: Optional[List["Operation"]] = None,
+        overloads: Optional[Sequence["Operation"]] = None,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -77,7 +80,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             parameters=parameters,
             overloads=overloads,
         )
-        self.overloads: List["Operation"] = overloads or []
+        self.overloads: Sequence["Operation"] = overloads or []
         self.responses = responses
         self.request_builder = request_builder
         self.deprecated = False
@@ -144,10 +147,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
-    def cls_type_annotation(self, *, async_mode: bool) -> str:
+    def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
         if self.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
             return "ClsType[None]"
-        return f"ClsType[{self.response_type_annotation(async_mode=async_mode)}]"
+        return f"ClsType[{self.response_type_annotation(async_mode=async_mode, **kwargs)}]"
 
     def _response_docstring_helper(self, attr_name: str, **kwargs: Any) -> str:
         responses_with_body = [r for r in self.responses if r.type]
@@ -207,21 +210,26 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             e for e in self.exceptions if "default" not in e.status_codes and e.type and isinstance(e.type, ModelType)
         ]
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
-        response_types = [r.type_annotation(async_mode=async_mode, operation=self) for r in self.responses if r.type]
+        response_types = [r.type_annotation(async_mode=async_mode, **kwargs) for r in self.responses if r.type]
         if len(set(response_types)) > 1:
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.added_on:
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             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,
             )
         return file_import
 
+    @property
+    def need_import_iobase(self) -> bool:
+        return self.parameters.has_body and isinstance(self.parameters.body_parameter.type, CombinedType)
+
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
             return FileImport(self.code_model)
@@ -230,15 +238,23 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.merge(
                 param.imports_for_multiapi(
                     async_mode,
-                    operation=self,
+                    need_import_iobase=self.need_import_iobase,
                     **kwargs,
                 )
             )
         for response in self.responses:
-            file_import.merge(response.imports_for_multiapi(async_mode=async_mode, operation=self, **kwargs))
+            file_import.merge(
+                response.imports_for_multiapi(
+                    async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs
+                )
+            )
         if self.code_model.options["models_mode"]:
             for exception in self.exceptions:
-                file_import.merge(exception.imports_for_multiapi(async_mode=async_mode, operation=self, **kwargs))
+                file_import.merge(
+                    exception.imports_for_multiapi(
+                        async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs
+                    )
+                )
         return file_import
 
     @staticmethod
@@ -265,6 +281,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         self,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
         async_mode: bool,
+        serialize_namespace: str,
     ) -> FileImport:
         """Helper method to get a request builder import."""
         file_import = FileImport(self.code_model)
@@ -287,35 +304,49 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 )
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             file_import.add_submodule_import(
-                f"...{self.code_model.operations_folder_name}.{self.filename}",
+                self.code_model.get_relative_import_path(
+                    serialize_namespace,
+                    self.code_model.get_imported_namespace_for_operation(self.client_namespace),
+                    module_name=self.filename,
+                ),
                 request_builder.name,
                 import_type=ImportType.LOCAL,
             )
         return file_import
 
+    @property
+    def need_deserialize(self) -> bool:
+        return any(r.type and not isinstance(r.type, BinaryIteratorType) for r in self.responses)
+
     def imports(  # pylint: disable=too-many-branches, disable=too-many-statements
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
         if self.abstract:
             return FileImport(self.code_model)
+
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         file_import = self._imports_shared(async_mode, **kwargs)
 
         for param in self.parameters.method:
             file_import.merge(
                 param.imports(
                     async_mode,
-                    operation=self,
+                    need_import_iobase=self.need_import_iobase,
                     **kwargs,
                 )
             )
         for response in self.responses:
-            file_import.merge(response.imports(async_mode=async_mode, operation=self, **kwargs))
+            file_import.merge(
+                response.imports(async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs)
+            )
         if self.code_model.options["models_mode"]:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
         if self.parameters.has_body and self.parameters.body_parameter.flattened:
-            file_import.merge(self.parameters.body_parameter.type.imports(operation=self, **kwargs))
+            file_import.merge(
+                self.parameters.body_parameter.type.imports(need_import_iobase=self.need_import_iobase, **kwargs)
+            )
         if not async_mode:
             for param in self.parameters.headers:
                 if param.wire_name.lower() == "repeatability-request-id":
@@ -353,7 +384,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
-        relative_path = "..." if async_mode else ".."
         if self.has_etag:
             file_import.add_submodule_import(
                 "exceptions",
@@ -361,8 +391,17 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 ImportType.SDKCORE,
             )
             if not async_mode:
-                file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_match", ImportType.LOCAL)
-                file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_none_match", ImportType.LOCAL)
+                relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor")
+                file_import.add_submodule_import(
+                    relative_path,
+                    "prep_if_match",
+                    ImportType.LOCAL,
+                )
+                file_import.add_submodule_import(
+                    relative_path,
+                    "prep_if_none_match",
+                    ImportType.LOCAL,
+                )
         if async_mode:
             file_import.add_submodule_import(
                 "rest",
@@ -376,7 +415,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 ImportType.SDKCORE,
             )
         if self.code_model.options["builders_visibility"] == "embedded" and not async_mode:
-            file_import.merge(self.request_builder.imports())
+            file_import.merge(self.request_builder.imports(**kwargs))
         file_import.add_submodule_import(
             f"{'' if self.code_model.is_azure_flavor else 'runtime.'}pipeline",
             "PipelineResponse",
@@ -393,34 +432,36 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 "distributed_trace",
                 ImportType.SDKCORE,
             )
-        file_import.merge(self.get_request_builder_import(self.request_builder, async_mode))
+        file_import.merge(self.get_request_builder_import(self.request_builder, async_mode, serialize_namespace))
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
-            if self.parameters.has_body:
+            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
+            body_param = self.parameters.body_parameter if self.parameters.has_body else None
+            if body_param and not isinstance(body_param.type, BinaryType):
                 if self.has_form_data_body:
-                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
+                    file_import.add_submodule_import(
+                        self.code_model.get_relative_import_path(serialize_namespace), "_model_base", ImportType.LOCAL
+                    )
                 elif xml_serializable(self.parameters.body_parameter.default_content_type):
                     file_import.add_submodule_import(
-                        f"{relative_path}_model_base",
+                        relative_path,
                         "_get_element",
                         ImportType.LOCAL,
                     )
                 elif json_serializable(self.parameters.body_parameter.default_content_type):
                     file_import.add_submodule_import(
-                        f"{relative_path}_model_base",
+                        relative_path,
                         "SdkJSONEncoder",
                         ImportType.LOCAL,
                     )
                     file_import.add_import("json", ImportType.STDLIB)
             if any(xml_serializable(str(r.default_content_type)) for r in self.responses):
-                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize_xml", ImportType.LOCAL)
-            elif 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_xml", ImportType.LOCAL)
+            elif self.need_deserialize:
+                file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
             if self.default_error_deserialization or self.non_default_errors:
-                file_import.add_submodule_import(
-                    f"{relative_path}_model_base", "_failsafe_deserialize", ImportType.LOCAL
-                )
+                file_import.add_submodule_import(relative_path, "_failsafe_deserialize", ImportType.LOCAL)
         return file_import
 
     def get_response_from_status(self, status_code: Optional[Union[str, int]]) -> ResponseType:
@@ -465,7 +506,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         responses = [cast(ResponseType, get_response(r, code_model)) for r in yaml_data["responses"]]
         exceptions = [Response.from_yaml(e, code_model) for e in yaml_data["exceptions"]]
         parameter_list = ParameterList.from_yaml(yaml_data, code_model)
-        overloads = [cls.from_yaml(overload, code_model, client) for overload in yaml_data.get("overloads", [])]
+        overloads = [
+            cast(Operation, cls.from_yaml(overload, code_model, client)) for overload in yaml_data.get("overloads", [])
+        ]
 
         return cls(
             yaml_data=yaml_data,

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

@@ -9,8 +9,8 @@ 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 .imports import FileImport, ImportType, TypingSection, MsrestImportType
+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,96 @@ 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,
+            )
+        else:
+            file_import.add_submodule_import(
+                "" if self.code_model.is_azure_flavor else "runtime",
+                f"{'Async' if async_mode else ''}PipelineClient",
+                ImportType.SDKCORE,
+            )
+            file_import.add_submodule_import(
+                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="_configuration",
+                ),
+                f"{self.client.name}Configuration",
+                ImportType.LOCAL,
+            )
+            file_import.add_msrest_import(
+                serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
+                msrest_import_type=MsrestImportType.Serializer,
+                typing_section=TypingSection.REGULAR,
+            )
+            file_import.add_msrest_import(
+                serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
+                msrest_import_type=MsrestImportType.SerializerDeserializer,
+                typing_section=TypingSection.REGULAR,
+            )
         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 +198,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/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)
+            if self.default_error_deserialization or self.need_deserialize:
+                file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
         return file_import
 
 

package/generator/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,
             )