@autorest/python 6.32.3 → 6.34.0

package/autorest/m2r.py

@@ -3,8 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-"""An autorest MD to RST plugin.
-"""
+"""An autorest MD to RST plugin."""
 import logging
 from typing import Any, Dict, Set, Union
 

package/autorest/m4reformatter/__init__.py

@@ -4,8 +4,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-"""The modelerfour reformatter autorest plugin.
-"""
+"""The modelerfour reformatter autorest plugin."""
 import re
 import copy
 import logging

package/autorest/multiapi/models/imports.py

@@ -123,9 +123,14 @@ class FileImport:
             ],
             convert_list_to_tuple(name_import),
         )
-        self._imports.setdefault(typing_section, {}).setdefault(import_type, {}).setdefault(from_section, set()).add(
-            name_input
+        target_values = (
+            self._imports.setdefault(typing_section, {}).setdefault(import_type, {}).setdefault(from_section, set())
         )
+        if isinstance(target_values, list):
+            if name_input not in target_values:
+                target_values.append(name_input)
+        else:
+            target_values.add(name_input)
 
     def add_submodule_import(
         self,

package/autorest/multiapi/serializers/__init__.py

@@ -133,7 +133,11 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 lstrip_blocks=True,
             )
             self.write_file(
-                Path("_serialization.py"),
+                Path("_utils/__init__.py"),
+                self.env.get_template("multiapi_utils_init.py.jinja2").render(),
+            )
+            self.write_file(
+                Path("_utils/serialization.py"),
                 codegen_env.get_template("serialization.py.jinja2").render(
                     code_model=code_model,
                 ),

package/autorest/multiapi/templates/multiapi_operations_mixin.py.jinja2

@@ -8,7 +8,7 @@
 # Changes may cause incorrect behavior and will be lost if the code is
 # regenerated.
 # --------------------------------------------------------------------------
-from {{ ".." if async_mode else "." }}_serialization import Serializer, Deserializer
+from {{ ".." if async_mode else "." }}_utils.serialization import Serializer, Deserializer
 {% if imports %}
 {{ imports }}
 {% endif %}

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -18,6 +18,7 @@ def __init__(
 {% set async_prefix = "Async" if async_mode else "" %}
 {% set a_prefix = "a" if async_mode else "" %}
 {% set await = "await " if async_mode else "" %}
+{% set credential_scopes = "credential_scopes=credential_scopes, " if code_model.config.credential_scopes is not none and code_model.azure_arm else "" %}
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
@@ -77,6 +78,7 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
     )
 
     {{ method_signature()|indent }}
+        {% if not code_model.azure_arm %}
         {% if not code_model.client.host_value %}
         {% for parameterized_host_template, api_versions in code_model.client.parameterized_host_template_to_api_version|dictsort %}
         {% set if_statement = "if" if loop.first else "elif" %}
@@ -86,9 +88,17 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
         else:
             raise ValueError("API version {} is not available".format(api_version))
         {% endif %}
+        {% endif %}
         if api_version:
             kwargs.setdefault('api_version', api_version)
-        self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
+        {% if credential_scopes %}
+        _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore
+        _endpoints = get_arm_endpoints(_cloud)
+        if not base_url:
+            base_url = _endpoints["resource_manager"]
+        credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"])
+        {% endif %}
+        self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}{{ credential_scopes }}**kwargs)
         _policies = kwargs.pop("policies", None)
         if _policies is None:
             _policies = [
@@ -96,7 +106,8 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
                 {{ p }},
                 {% endfor %}
             ]
-        self._client: {{ async_prefix }}{{ code_model.client.pipeline_client }} = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ code_model.host_variable_name }}, policies=_policies, **kwargs)
+        {% set host_variable_name = "cast(str, " + code_model.host_variable_name + ")" if credential_scopes else code_model.host_variable_name %}
+        self._client: {{ async_prefix }}{{ code_model.client.pipeline_client }} = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ host_variable_name }}, policies=_policies, **kwargs)
         super({{ code_model.client.name }}, self).__init__(
             api_version=api_version,
             profile=profile

package/autorest/multiapi/templates/multiapi_utils_init.py.jinja2

@@ -0,0 +1,10 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------

package/autorest/preprocess.py

@@ -3,8 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-"""The preprocessing autorest plugin.
-"""
+"""The preprocessing autorest plugin."""
 from typing import Dict, Any
 from pygen.preprocess import PreProcessPlugin
 from . import YamlUpdatePluginAutorest

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

@@ -15,7 +15,7 @@ from .request_builder import (
     OverloadedRequestBuilder,
     get_request_builder,
 )
-from .parameter import Parameter, ParameterMethodLocation
+from .parameter import Parameter, ParameterMethodLocation, ParameterLocation
 from .lro_operation import LROOperation
 from .lro_paging_operation import LROPagingOperation
 from ...utils import extract_original_name, NAME_LENGTH_LIMIT
@@ -54,7 +54,7 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
         return self.yaml_data["name"]
 
 
-class Client(_ClientConfigBase[ClientGlobalParameterList]):
+class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=too-many-public-methods
     """Model representing our service client"""
 
     def __init__(
@@ -79,6 +79,27 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         self.request_id_header_name = self.yaml_data.get("requestIdHeaderName", None)
         self.has_etag: bool = yaml_data.get("hasEtag", False)
 
+        # update the host parameter value. In later logic, SDK will overwrite it
+        # with value from cloud_setting if users don't provide it.
+        if self.need_cloud_setting:
+            for p in self.parameters.parameters:
+                if p.location == ParameterLocation.ENDPOINT_PATH:
+                    p.client_default_value = None
+                    p.optional = True
+                    break
+
+    @property
+    def need_cloud_setting(self) -> bool:
+        return bool(
+            self.code_model.options.get("azure_arm", False)
+            and self.credential_scopes is not None
+            and self.endpoint_parameter is not None
+        )
+
+    @property
+    def endpoint_parameter(self) -> Optional[Parameter]:
+        return next((p for p in self.parameters.parameters if p.location == ParameterLocation.ENDPOINT_PATH), None)
+
     def _build_request_builders(
         self,
     ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
@@ -233,6 +254,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             "Self",
             ImportType.STDLIB,
         )
+        if self.need_cloud_setting:
+            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+            file_import.add_submodule_import("azure.core.settings", "settings", ImportType.SDKCORE)
+            file_import.add_submodule_import("azure.mgmt.core.tools", "get_arm_endpoints", ImportType.SDKCORE)
         return file_import
 
     @property
@@ -332,6 +357,18 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         )
         return file_import
 
+    @property
+    def credential_scopes(self) -> Optional[List[str]]:
+        """Credential scopes for this client"""
+
+        if self.credential:
+            if hasattr(getattr(self.credential.type, "policy", None), "credential_scopes"):
+                return self.credential.type.policy.credential_scopes  # type: ignore
+            for t in getattr(self.credential.type, "types", []):
+                if hasattr(getattr(t, "policy", None), "credential_scopes"):
+                    return t.policy.credential_scopes
+        return None
+
     @classmethod
     def from_yaml(
         cls,

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

@@ -242,16 +242,26 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         """
         return client_namespace == self.namespace
 
-    def need_vendored_code(self, async_mode: bool, client_namespace: str) -> bool:
-        """Whether we need to vendor code in the _vendor.py in specific namespace"""
+    def need_utils_folder(self, async_mode: bool, client_namespace: str) -> bool:
         return (
-            self.need_vendored_form_data(async_mode, client_namespace)
-            or self.need_vendored_etag(client_namespace)
-            or self.need_vendored_abstract(client_namespace)
-            or self.need_vendored_mixin(client_namespace)
+            self.need_utils_utils(async_mode, client_namespace)
+            or self.need_utils_serialization
+            or self.options["models_mode"] == "dpg"
         )
 
-    def need_vendored_form_data(self, async_mode: bool, client_namespace: str) -> bool:
+    @property
+    def need_utils_serialization(self) -> bool:
+        return not self.options["client_side_validation"]
+
+    def need_utils_utils(self, async_mode: bool, client_namespace: str) -> bool:
+        return (
+            self.need_utils_form_data(async_mode, client_namespace)
+            or self.need_utils_etag(client_namespace)
+            or self.need_utils_abstract(client_namespace)
+            or self.need_utils_mixin
+        )
+
+    def need_utils_form_data(self, async_mode: bool, client_namespace: str) -> bool:
         return (
             (not async_mode)
             and self.is_top_namespace(client_namespace)
@@ -259,14 +269,15 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             and self.options["models_mode"] == "dpg"
         )
 
-    def need_vendored_etag(self, client_namespace: str) -> bool:
+    def need_utils_etag(self, client_namespace: str) -> bool:
         return self.is_top_namespace(client_namespace) and self.has_etag
 
-    def need_vendored_abstract(self, client_namespace: str) -> bool:
+    def need_utils_abstract(self, client_namespace: str) -> bool:
         return self.is_top_namespace(client_namespace) and self.has_abstract_operations
 
-    def need_vendored_mixin(self, client_namespace: str) -> bool:
-        return self.has_mixin(client_namespace)
+    @property
+    def need_utils_mixin(self) -> bool:
+        return any(c_n for c_n in self.client_namespace_types if self.has_mixin(c_n))
 
     def has_mixin(self, client_namespace: str) -> bool:
         return any(c for c in self.get_clients(client_namespace) if c.has_mixin)

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

@@ -52,7 +52,7 @@ class EnumValue(BaseType):
         """The python type used for RST syntax input and type annotation."""
 
         type_annotation = self.value_type.type_annotation(**kwargs)
-        enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+        enum_type_annotation = f"{self.enum_type.client_namespace}.models.{self.name}"
         return f"{type_annotation} or ~{enum_type_annotation}"
 
     def get_json_template_representation(
@@ -198,7 +198,7 @@ class EnumType(BaseType):
         """The python type used for RST syntax input and type annotation."""
         if self.code_model.options["models_mode"]:
             type_annotation = self.value_type.type_annotation(**kwargs)
-            enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+            enum_type_annotation = f"{self.client_namespace}.models.{self.name}"
             return f"{type_annotation} or ~{enum_type_annotation}"
         return self.value_type.type_annotation(**kwargs)
 

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

@@ -30,9 +30,11 @@ class TypingSection(str, Enum):
 
 
 class MsrestImportType(Enum):
-    Module = auto()  # import _serialization.py or msrest.serialization as Module
-    Serializer = auto()  # from _serialization.py or msrest.serialization import Serializer
-    SerializerDeserializer = auto()  # from _serialization.py or msrest.serialization import Serializer and Deserializer
+    Module = auto()  # import _utils/serialization.py or msrest.serialization as Module
+    Serializer = auto()  # from _utils/serialization.py or msrest.serialization import Serializer
+    SerializerDeserializer = (
+        auto()
+    )  # from _utils/serialization.py or msrest.serialization import Serializer and Deserializer
 
 
 class ImportModel:
@@ -261,21 +263,23 @@ 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
+            # _utils/serialization.py is always in root namespace
+            imported_namespace = f"{self.code_model.namespace}._utils"
             if self.code_model.options["multiapi"]:
-                # 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)
+                # for multiapi, the namespace is azure.mgmt.xxx.v20XX_XX_XX
+                # while _utils/serialization.py is in azure.mgmt.xxx
+                imported_namespace = f"{get_parent_namespace(imported_namespace)}._utils"
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(
                     self.code_model.get_relative_import_path(serialize_namespace, imported_namespace),
-                    "_serialization",
+                    "serialization",
                     ImportType.LOCAL,
                     typing_section,
+                    alias="_serialization",
                 )
             else:
                 relative_path = self.code_model.get_relative_import_path(
-                    serialize_namespace, imported_namespace, module_name="_serialization"
+                    serialize_namespace, f"{self.code_model.namespace}._utils.serialization"
                 )
                 self.add_submodule_import(relative_path, "Serializer", ImportType.LOCAL, typing_section)
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:

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

@@ -134,7 +134,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
             # but final call returns a model
             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"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
                 "_deserialize",
                 ImportType.LOCAL,
             )

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

@@ -292,7 +292,7 @@ class GeneratedModelType(ModelType):
 
     def docstring_type(self, **kwargs: Any) -> str:
         type_annotation = self.type_annotation(need_model_alias=False, skip_quote=True, **kwargs)
-        return f"~{self.code_model.namespace}.models.{type_annotation}"
+        return f"~{self.client_namespace}.models.{type_annotation}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return self.name
@@ -318,9 +318,10 @@ class GeneratedModelType(ModelType):
             )
             if self.is_form_data:
                 file_import.add_submodule_import(
-                    self.code_model.get_relative_import_path(serialize_namespace),
-                    "_model_base",
+                    self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
+                    "Model",
                     ImportType.LOCAL,
+                    alias="_Model",
                 )
         elif serialize_namespace_type == NamespaceType.TYPES_FILE or (
             serialize_namespace_type == NamespaceType.MODEL and called_by_property

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

@@ -391,7 +391,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 ImportType.SDKCORE,
             )
             if not async_mode:
-                relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor")
+                relative_path = self.code_model.get_relative_import_path(
+                    serialize_namespace, module_name="_utils.utils"
+                )
                 file_import.add_submodule_import(
                     relative_path,
                     "prep_if_match",
@@ -436,12 +438,17 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
+            relative_path = self.code_model.get_relative_import_path(
+                serialize_namespace, module_name="_utils.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(
-                        self.code_model.get_relative_import_path(serialize_namespace), "_model_base", ImportType.LOCAL
+                        relative_path,
+                        "Model",
+                        ImportType.LOCAL,
+                        alias="_Model",
                     )
                 elif xml_serializable(self.parameters.body_parameter.default_content_type):
                     file_import.add_submodule_import(

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

@@ -63,11 +63,11 @@ class OperationGroup(BaseModel):
             operation_group.has_non_abstract_operations for operation_group in self.operation_groups
         )
 
-    @property
-    def base_class(self) -> str:
+    def base_class(self, async_mode: bool) -> str:
+        pipeline_client = f"{'Async' if async_mode else ''}PipelineClient"
         base_classes: List[str] = []
         if self.is_mixin:
-            base_classes.append(f"{self.client.name}MixinABC")
+            base_classes.append(f"ClientMixinABC[{pipeline_client}, {self.client.name}Configuration]")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
@@ -100,8 +100,12 @@ class OperationGroup(BaseModel):
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        utils_path = self.code_model.get_relative_import_path(
+            serialize_namespace,
+            f"{self.code_model.namespace}._utils.utils",
+        )
+
         for operation in self.operations:
             file_import.merge(operation.imports(async_mode, **kwargs))
         if not self.code_model.options["combine_operation_files"]:
@@ -141,32 +145,28 @@ class OperationGroup(BaseModel):
                 ImportType.LOCAL,
                 alias="_models",
             )
+        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_submodule_import(
+            "" if self.code_model.is_azure_flavor else "runtime",
+            f"{'Async' if async_mode else ''}PipelineClient",
+            ImportType.SDKCORE,
+        )
         if self.is_mixin:
             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",
+                # XxxMixinABC is always defined in _utils of client namespace
+                utils_path,
+                "ClientMixinABC",
                 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,
@@ -179,12 +179,8 @@ class OperationGroup(BaseModel):
             )
         if self.has_abstract_operations:
             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 is always defined in _utils of top namespace
+                utils_path,
                 "raise_if_not_implemented",
                 ImportType.LOCAL,
             )

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

@@ -157,7 +157,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 ImportType.SDKCORE,
             )
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
+            relative_path = self.code_model.get_relative_import_path(
+                serialize_namespace, module_name="_utils.model_base"
+            )
             file_import.merge(self.item_type.imports(**kwargs))
             if self.default_error_deserialization or self.need_deserialize:
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)

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

@@ -275,7 +275,7 @@ class BodyParameter(_ParameterBase):
         if self.is_form_data:
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.utils"),
                 "prepare_multipart_form_data",
                 ImportType.LOCAL,
             )
@@ -357,6 +357,9 @@ class Parameter(_ParameterBase):
         )
         if self.code_model.options["only_path_and_body_params_positional"] and query_or_header:
             return ParameterMethodLocation.KEYWORD_ONLY
+        # for optional path parameter, we need to use keyword only
+        if self.location == ParameterLocation.PATH and self.optional:
+            return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod

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

@@ -618,13 +618,13 @@ class MultiPartFileType(PrimitiveType):
         return self.name
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.namespace}._vendor.{self.name}"
+        return f"~{self.code_model.namespace}._utils.utils.{self.name}"
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         file_import.add_submodule_import(
-            self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+            self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.utils"),
             self.name,
             ImportType.LOCAL,
         )

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

@@ -149,7 +149,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.code_model.options["models_mode"] == "dpg":
             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"),
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_utils.model_base"),
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )

package/generator/build/lib/pygen/codegen/serializers/__init__.py

@@ -153,7 +153,7 @@ class JinjaSerializer(ReaderAndWriter):
                     general_serializer.serialize_pkgutil_init_file(),
                 )
 
-            # _model_base.py/_serialization.py/_vendor.py/py.typed/_types.py/_validation.py
+            # _utils/py.typed/_types.py/_validation.py
             # is always put in top level namespace
             if self.code_model.is_top_namespace(client_namespace):
                 self._serialize_and_write_top_level_folder(env=env, namespace=client_namespace)
@@ -404,25 +404,41 @@ class JinjaSerializer(ReaderAndWriter):
                     general_serializer.serialize_config_file(clients),
                 )
 
-                # sometimes we need define additional Mixin class for client in _vendor.py
-                self._serialize_and_write_vendor_file(env, namespace)
+                # sometimes we need define additional Mixin class for client in _utils.py
+                self._serialize_and_write_utils_folder(env, namespace)
 
-    def _serialize_and_write_vendor_file(self, env: Environment, namespace: str) -> None:
+    def _serialize_and_write_utils_folder(self, env: Environment, namespace: str) -> None:
         exec_path = self.exec_path(namespace)
-        # write _vendor.py
-        for async_mode, async_path in self.serialize_loop:
-            if self.code_model.need_vendored_code(async_mode=async_mode, client_namespace=namespace):
-                self.write_file(
-                    exec_path / Path(f"{async_path}_vendor.py"),
-                    GeneralSerializer(
-                        code_model=self.code_model, env=env, async_mode=async_mode, client_namespace=namespace
-                    ).serialize_vendor_file(),
-                )
+        general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
+        utils_folder_path = exec_path / Path("_utils")
+        if self.code_model.need_utils_folder(async_mode=False, client_namespace=namespace):
+            self.write_file(
+                utils_folder_path / Path("__init__.py"),
+                self.code_model.license_header,
+            )
+        if self.code_model.need_utils_utils(async_mode=False, client_namespace=namespace):
+            self.write_file(
+                utils_folder_path / Path("utils.py"),
+                general_serializer.need_utils_utils_file(),
+            )
+        # write _utils/serialization.py
+        if self.code_model.need_utils_serialization:
+            self.write_file(
+                utils_folder_path / Path("serialization.py"),
+                general_serializer.serialize_serialization_file(),
+            )
+
+        # write _model_base.py
+        if self.code_model.options["models_mode"] == "dpg":
+            self.write_file(
+                utils_folder_path / Path("model_base.py"),
+                general_serializer.serialize_model_base_file(),
+            )
 
     def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
         exec_path = self.exec_path(namespace)
-        # write _vendor.py
-        self._serialize_and_write_vendor_file(env, namespace)
+        # write _utils folder
+        self._serialize_and_write_utils_folder(env, namespace)
 
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
 
@@ -432,20 +448,6 @@ class JinjaSerializer(ReaderAndWriter):
         # write the empty py.typed file
         self.write_file(exec_path / Path("py.typed"), "# Marker file for PEP 561.")
 
-        # write _serialization.py
-        if not self.code_model.options["client_side_validation"] and not self.code_model.options["multiapi"]:
-            self.write_file(
-                exec_path / Path("_serialization.py"),
-                general_serializer.serialize_serialization_file(),
-            )
-
-        # write _model_base.py
-        if self.code_model.options["models_mode"] == "dpg":
-            self.write_file(
-                exec_path / Path("_model_base.py"),
-                general_serializer.serialize_model_base_file(),
-            )
-
         # write _validation.py
         if any(og for client in self.code_model.clients for og in client.operation_groups if og.need_validation):
             self.write_file(

package/generator/build/lib/pygen/codegen/serializers/builder_serializer.py

@@ -672,7 +672,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 [
                     "_body = (",
                     f"    {body_param.client_name}.as_dict()",
-                    f"    if isinstance({body_param.client_name}, _model_base.Model) else",
+                    f"    if isinstance({body_param.client_name}, _Model) else",
                     f"    {body_param.client_name}",
                     ")",
                     f"_file_fields: List[str] = {file_fields}",