@autorest/python 6.27.4 → 6.28.1

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