@autorest/python 6.9.4 → 6.9.5

package/autorest/codegen/models/primitive_types.py

@@ -107,7 +107,7 @@ class BinaryType(PrimitiveType):
         from .combined_type import CombinedType
         from .operation import OperationBase
 
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
         operation = kwargs.get("operation")
         if (
@@ -145,7 +145,7 @@ class BinaryIteratorType(PrimitiveType):
         return self.get_declaration("Iterator[bytes]")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         iterator = "AsyncIterator" if kwargs.get("async_mode") else "Iterator"
         file_import.add_submodule_import("typing", iterator, ImportType.STDLIB)
         return file_import
@@ -171,7 +171,7 @@ class AnyType(PrimitiveType):
         return self.get_declaration({})
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -204,7 +204,7 @@ class AnyObjectType(PrimitiveType):
         return "isinstance({}, MutableMapping)"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.define_mutable_mapping_type()
         return file_import
 
@@ -386,7 +386,7 @@ class DatetimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -429,7 +429,7 @@ class TimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -476,7 +476,7 @@ class UnixTimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -519,7 +519,7 @@ class DateType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -562,7 +562,7 @@ class DurationType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -606,20 +606,24 @@ class ByteArraySchema(PrimitiveType):
         return "isinstance({}, bytes)"
 
 
-class AzureCoreType(PrimitiveType):
+class SdkCoreType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = yaml_data.get("name", "")
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return "~azure.core." + self.type_annotation(**kwargs)
+        return f"~{self.init_file_import().import_core}" + self.type_annotation(
+            **kwargs
+        )
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_submodule_import("azure.core", self.name, ImportType.AZURECORE)
+        file_import = self.init_file_import()
+        file_import.add_submodule_import(
+            file_import.import_core, self.name, ImportType.SDKCORE
+        )
         return file_import
 
     @property

package/autorest/codegen/models/property.py

@@ -147,7 +147,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return retval or None
 
     def imports(self, **kwargs) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
         file_import.merge(

package/autorest/codegen/models/request_builder.py

@@ -72,16 +72,16 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def response_docstring_text(self, **kwargs) -> str:
         return (
-            "Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            f"Returns an :class:`~{self.response_docstring_type()}` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
 
     def response_docstring_type(self, **kwargs) -> str:
-        return "~azure.core.rest.HttpRequest"
+        return f"~{self.init_file_import().import_core_rest}.HttpRequest"
 
     def imports(self) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         relative_path = ".."
         if (
             not self.code_model.options["builders_visibility"] == "embedded"
@@ -98,14 +98,16 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             )
 
         file_import.add_submodule_import(
-            "azure.core.rest",
+            file_import.import_core_rest,
             "HttpRequest",
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
 
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
-                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                file_import.import_core_utils,
+                "case_insensitive_dict",
+                ImportType.SDKCORE,
             )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL

package/autorest/codegen/models/response.py

@@ -8,7 +8,7 @@ from typing import Dict, Optional, List, Any, TYPE_CHECKING, Union
 from .base import BaseModel
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .primitive_types import BinaryType, BinaryIteratorType
+from .primitive_types import BinaryType, BinaryIteratorType, ByteArraySchema
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .model_type import ModelType
@@ -58,6 +58,7 @@ class Response(BaseModel):
         self.headers = headers or []
         self.type = type
         self.nullable = yaml_data.get("nullable")
+        self.default_content_type = yaml_data.get("defaultContentType")
 
     @property
     def result_property(self) -> str:
@@ -80,7 +81,12 @@ class Response(BaseModel):
     @property
     def is_stream_response(self) -> bool:
         """Is the response expected to be streamable, like a download."""
-        return isinstance(self.type, BinaryIteratorType)
+        retval = isinstance(self.type, BinaryIteratorType) or (
+            isinstance(self.type, ByteArraySchema)
+            and bool(self.default_content_type)
+            and self.default_content_type != "application/json"
+        )
+        return retval
 
     @property
     def serialization_type(self) -> str:
@@ -108,7 +114,7 @@ class Response(BaseModel):
         return self.type.docstring_type(**kwargs) if self.type else "None"
 
     def _imports_shared(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         if self.type:
             file_import.merge(self.type.imports(**kwargs))
         if self.nullable:
@@ -158,6 +164,14 @@ class PagingResponse(Response):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.item_type = self.code_model.lookup_type(id(self.yaml_data["itemType"]))
+        self.pager_sync: str = (
+            self.yaml_data.get("pagerSync")
+            or f"{self.init_file_import().import_core_paging}.ItemPaged"
+        )
+        self.pager_async: str = (
+            self.yaml_data.get("pagerAsync")
+            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+        )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
         return self.item_type.get_polymorphic_subtypes(polymorphic_subtypes)
@@ -166,9 +180,7 @@ class PagingResponse(Response):
         return self.item_type.get_json_template_representation()
 
     def get_pager_path(self, async_mode: bool) -> str:
-        return (
-            self.yaml_data["pagerAsync"] if async_mode else self.yaml_data["pagerSync"]
-        )
+        return self.pager_async if async_mode else self.pager_sync
 
     def get_pager(self, async_mode: bool) -> str:
         return self.get_pager_path(async_mode).split(".")[-1]
@@ -192,7 +204,7 @@ class PagingResponse(Response):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.SDKCORE)
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -200,7 +212,9 @@ class PagingResponse(Response):
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
-                "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
+                file_import.import_core_paging_async,
+                "AsyncList",
+                ImportType.SDKCORE,
             )
 
         return file_import
@@ -269,9 +283,7 @@ class LROResponse(Response):
         async_mode = kwargs["async_mode"]
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_submodule_import(
-            poller_import_path, poller, ImportType.AZURECORE
-        )
+        file_import.add_submodule_import(poller_import_path, poller, ImportType.SDKCORE)
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -285,7 +297,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_polling_method_import_path,
             default_polling_method,
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
         default_no_polling_method_import_path = ".".join(
             self.get_no_polling_method_path(async_mode).split(".")[:-1]
@@ -294,7 +306,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_no_polling_method_import_path,
             default_no_polling_method,
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
 
         base_polling_method_import_path = ".".join(
@@ -302,7 +314,7 @@ class LROResponse(Response):
         )
         base_polling_method = self.get_base_polling_method(async_mode)
         file_import.add_submodule_import(
-            base_polling_method_import_path, base_polling_method, ImportType.AZURECORE
+            base_polling_method_import_path, base_polling_method, ImportType.SDKCORE
         )
         return file_import
 

package/autorest/codegen/serializers/__init__.py

@@ -240,6 +240,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         serializer = GeneralSerializer(self.code_model, env, async_mode=False)
         params = self.code_model.options["package_configuration"] or {}
         for template_name in package_files:
+            if (
+                self.code_model.options["unbranded"]
+                and template_name == "dev_requirements.txt.jinja2"
+            ):
+                continue
             file = template_name.replace(".jinja2", "")
             output_name = root_of_sdk / file
             if not self.read_file(output_name) or file in _REGENERATE_FILES:

package/autorest/codegen/serializers/base_serializer.py

@@ -0,0 +1,21 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from jinja2 import Environment
+from ..models import (
+    FileImport,
+    CodeModel,
+)
+
+
+class BaseSerializer:
+    """Base serializer for SDK root level files"""
+
+    def __init__(self, code_model: CodeModel, env: Environment):
+        self.code_model = code_model
+        self.env = env
+
+    def init_file_import(self) -> FileImport:
+        return FileImport(self.code_model)

package/autorest/codegen/serializers/builder_serializer.py

@@ -426,6 +426,12 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             builder.parameters.path, self.serializer_name
         )
 
+    @property
+    def pipeline_name(self) -> str:
+        if not self.code_model.options["unbranded"]:
+            return "_pipeline"
+        return "pipeline"
+
 
 ############################## REQUEST BUILDERS ##############################
 
@@ -483,12 +489,13 @@ class RequestBuilderSerializer(
         return False
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
+        import_core_rest = builder.init_file_import().import_core_rest
         response_str = (
-            ":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            f":return: Returns an :class:`~{import_core_rest}.HttpRequest` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
-        rtype_str = ":rtype: ~azure.core.rest.HttpRequest"
+        rtype_str = f":rtype: ~{import_core_rest}.HttpRequest"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -637,13 +644,13 @@ class _OperationSerializer(
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         stream_value = (
-            'kwargs.pop("stream", False)'
+            f'kwargs.pop("stream", {builder.has_stream_response})'
             if builder.expose_stream_keyword
             else builder.has_stream_response
         )
         return [
             f"_stream = {stream_value}",
-            f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
+            f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    _request,",
             "    stream=_stream,",
@@ -723,7 +730,7 @@ class _OperationSerializer(
         return [
             response_str,
             rtype_str,
-            ":raises ~azure.core.exceptions.HttpResponseError:",
+            f":raises ~{builder.init_file_import().import_core_exceptions}.HttpResponseError:",
         ]
 
     def _serialize_body_parameter(self, builder: OperationType) -> List[str]:
@@ -1049,14 +1056,17 @@ class _OperationSerializer(
         if response.headers:
             retval.append("")
         deserialize_code: List[str] = []
-        if response.is_stream_response:
-            deserialize_code.append(
-                "deserialized = {}".format(
+        if builder.has_stream_response:
+            if isinstance(response.type, ByteArraySchema):
+                retval.append(f"{'await ' if self.async_mode else ''}response.read()")
+                deserialized = "response.content"
+            else:
+                deserialized = (
                     "response.iter_bytes()"
                     if self.code_model.options["version_tolerant"]
-                    else "response.stream_download(self._client._pipeline)"
+                    else f"response.stream_download(self._client.{self.pipeline_name})"
                 )
-            )
+            deserialize_code.append(f"deserialized = {deserialized}")
         elif response.type:
             pylint_disable = ""
             if isinstance(response.type, ModelType) and response.type.internal:
@@ -1069,14 +1079,18 @@ class _OperationSerializer(
                 deserialize_code.append("    pipeline_response")
                 deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
-                deserialize_code.append("deserialized = _deserialize(")
-                deserialize_code.append(
-                    f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
-                )
-                deserialize_code.append(
-                    f"    response.json(){response.result_property}"
-                )
-                deserialize_code.append(")")
+                if builder.has_stream_response:
+                    deserialize_code.append("deserialized = response.content")
+                else:
+                    deserialize_code.append("deserialized = _deserialize(")
+                    deserialize_code.append(
+                        f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
+                    )
+                    deserialize_code.append(
+                        f"    response.json(){response.result_property}"
+                    )
+                    deserialize_code.append(")")
+
             else:
                 deserialized_value = (
                     "ET.fromstring(response.text())"
@@ -1088,7 +1102,7 @@ class _OperationSerializer(
                 deserialize_code.append("else:")
                 deserialize_code.append("    deserialized = None")
         if len(deserialize_code) > 0:
-            if builder.expose_stream_keyword:
+            if builder.expose_stream_keyword and not builder.has_stream_response:
                 retval.append("if _stream:")
                 retval.append("    deserialized = response.iter_bytes()")
                 retval.append("else:")

package/autorest/codegen/serializers/client_serializer.py

@@ -111,19 +111,28 @@ class ClientSerializer:
     def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
+        endpoint_name = (
+            "endpoint" if self.client.code_model.options["unbranded"] else "base_url"
+        )
         params = {
-            "base_url": self.host_variable_name,
+            endpoint_name: self.host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:
             result.append(
                 f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"'
             )
+        policies = build_policies(
+            self.client.code_model.options["azure_arm"],
+            async_mode,
+            self.client.code_model.options["unbranded"],
+            self.client.code_model.options["tracing"],
+        )
         result.extend(
             [
                 "_policies = kwargs.pop('policies', None)",
                 "if _policies is None:",
-                f'    _policies = [{",".join(build_policies(self.client.code_model.options["azure_arm"], async_mode, self.client.code_model.options["unbranded"]))}]',  # pylint: disable=line-too-long
+                f'    _policies = [{",".join(policies)}]',
                 f"self._client: {pipeline_client_name} = {pipeline_client_name}("
                 f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)",
             ]
@@ -243,7 +252,9 @@ class ClientSerializer:
         return retval
 
     def _rest_request_example(self, async_mode: bool) -> List[str]:
-        retval = [">>> from azure.core.rest import HttpRequest"]
+        retval = [
+            f">>> from {self.client.init_file_import().import_core_rest} import HttpRequest"
+        ]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
@@ -262,7 +273,9 @@ class ClientSerializer:
         )
         retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(":type request: ~azure.core.rest.HttpRequest")
+        retval.append(
+            f":type request: ~{self.client.init_file_import().import_core_rest}.HttpRequest"
+        )
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )
@@ -270,7 +283,9 @@ class ClientSerializer:
             ":return: The response of your network call. Does not do error handling on your response."
         )
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval.append(f":rtype: ~azure.core.rest.{http_response}")
+        retval.append(
+            f":rtype: ~{self.client.init_file_import().import_core_rest}.{http_response}"
+        )
         retval.append('"""')
         return retval
 

package/autorest/codegen/serializers/enum_serializer.py

@@ -4,16 +4,13 @@
 # license information.
 # --------------------------------------------------------------------------
 
-from jinja2 import Environment
-from ..models import CodeModel
+from .base_serializer import BaseSerializer
 
 
-class EnumSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
-        self.env = env
-
+class EnumSerializer(BaseSerializer):
     def serialize(self) -> str:
         # Generate the enum file
         template = self.env.get_template("enum_container.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(
+            code_model=self.code_model, file_import=self.init_file_import()
+        )

package/autorest/codegen/serializers/general_serializer.py

@@ -8,29 +8,20 @@ from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType
 from ..models import (
-    FileImport,
     ImportType,
     CodeModel,
     TokenCredentialType,
     Client,
 )
 from .client_serializer import ClientSerializer, ConfigSerializer
+from .base_serializer import BaseSerializer
 
-_PACKAGE_MODE_FILES = [
-    "CHANGELOG.md.jinja2",
-    "dev_requirements.txt.jinja2",
-    "LICENSE.jinja2",
-    "MANIFEST.in.jinja2",
-    "README.md.jinja2",
-]
 
-
-class GeneralSerializer:
+class GeneralSerializer(BaseSerializer):
     """General serializer for SDK root level files"""
 
     def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool):
-        self.code_model = code_model
-        self.env = env
+        super().__init__(code_model, env)
         self.async_mode = async_mode
 
     def serialize_setup_file(self) -> str:
@@ -68,7 +59,7 @@ class GeneralSerializer:
         }
         params.update(self.code_model.options)
         params.update(kwargs)
-        return template.render(**params)
+        return template.render(file_import=self.init_file_import(), **params)
 
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
@@ -85,7 +76,7 @@ class GeneralSerializer:
     def serialize_service_client_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("client_container.py.jinja2")
 
-        imports = FileImport(self.code_model)
+        imports = self.init_file_import()
         for client in clients:
             imports.merge(client.imports(self.async_mode))
 
@@ -101,12 +92,12 @@ class GeneralSerializer:
         template = self.env.get_template("vendor.py.jinja2")
 
         # configure imports
-        file_import = FileImport(self.code_model)
+        file_import = self.init_file_import()
         if self.code_model.need_request_converter:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
                 "HttpRequest",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
 
         if self.code_model.need_mixin_abc:
@@ -116,9 +107,9 @@ class GeneralSerializer:
                 ImportType.STDLIB,
             )
             file_import.add_submodule_import(
-                "azure.core",
+                file_import.import_core_pipeline_client,
                 f"{'Async' if self.async_mode else ''}PipelineClient",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
                 TypingSection.TYPING,
             )
             file_import.add_msrest_import(
@@ -135,9 +126,9 @@ class GeneralSerializer:
         if self.code_model.has_etag:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "azure.core",
+                file_import.import_core,
                 "MatchConditions",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
 
         return template.render(
@@ -151,7 +142,7 @@ class GeneralSerializer:
 
     def serialize_config_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
-        imports = FileImport(self.code_model)
+        imports = self.init_file_import()
         for client in self.code_model.clients:
             imports.merge(client.config.imports(self.async_mode))
         return template.render(
@@ -168,11 +159,16 @@ class GeneralSerializer:
 
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(
+            import_core_exceptions=self.init_file_import().import_core_exceptions,
+            import_core_serialization=self.init_file_import().import_core_serialization,
+        )
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(
+            code_model=self.code_model, file_import=self.init_file_import()
+        )
 
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")