@autorest/python 6.32.3 → 6.34.0

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

@@ -3,10 +3,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
+from typing import List, cast
 
 from . import utils
-from ..models import Client, ParameterMethodLocation
+from ..models import Client, ParameterMethodLocation, Parameter, ParameterLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from ...utils import build_policies
 
@@ -77,17 +77,40 @@ class ClientSerializer:
         retval.append('"""')
         return retval
 
-    def initialize_config(self) -> str:
+    def initialize_config(self) -> List[str]:
+        retval = []
+        additional_signatures = []
+        if self.client.need_cloud_setting:
+            additional_signatures.append("credential_scopes=credential_scopes")
+            endpoint_parameter = cast(Parameter, self.client.endpoint_parameter)
+            retval.extend(
+                [
+                    '_cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore',
+                    "_endpoints = get_arm_endpoints(_cloud)",
+                    f"if not {endpoint_parameter.client_name}:",
+                    f'    {endpoint_parameter.client_name} = _endpoints["resource_manager"]',
+                    'credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"])',
+                ]
+            )
         config_name = f"{self.client.name}Configuration"
         config_call = ", ".join(
             [
-                f"{p.client_name}={p.client_name}"
+                (
+                    f"{p.client_name}="
+                    + (
+                        f"cast(str, {p.client_name})"
+                        if self.client.need_cloud_setting and p.location == ParameterLocation.ENDPOINT_PATH
+                        else p.client_name
+                    )
+                )
                 for p in self.client.config.parameters.method
                 if p.method_location != ParameterMethodLocation.KWARG
             ]
+            + additional_signatures
             + ["**kwargs"]
         )
-        return f"self._config = {config_name}({config_call})"
+        retval.append(f"self._config = {config_name}({config_call})")
+        return retval
 
     @property
     def host_variable_name(self) -> str:
@@ -104,8 +127,11 @@ class ClientSerializer:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
         endpoint_name = "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
+        host_variable_name = (
+            f"cast(str, {self.host_variable_name})" if self.client.need_cloud_setting else self.host_variable_name
+        )
         params = {
-            endpoint_name: self.host_variable_name,
+            endpoint_name: host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:

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

@@ -16,13 +16,29 @@ from ..models.utils import NamespaceType
 from .client_serializer import ClientSerializer, ConfigSerializer
 from .base_serializer import BaseSerializer
 
+VERSION_MAP = {
+    "msrest": "0.7.1",
+    "isodate": "0.6.1",
+    "azure-mgmt-core": "1.5.0",
+    "azure-core": "1.30.0",
+    "typing-extensions": "4.6.0",
+    "corehttp": "1.0.0b6",
+}
+
+MIN_PYTHON_VERSION = "3.9"
+MAX_PYTHON_VERSION = "3.12"
+
 
 class GeneralSerializer(BaseSerializer):
     """General serializer for SDK root level files"""
 
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("packaging_templates/setup.py.jinja2")
-        params = {}
+        params = {
+            "VERSION_MAP": VERSION_MAP,
+            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
+        }
         params.update(self.code_model.options)
         return template.render(code_model=self.code_model, **params)
 
@@ -48,6 +64,9 @@ class GeneralSerializer(BaseSerializer):
             "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
             "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
             "client_name": self.code_model.clients[0].name,
+            "VERSION_MAP": VERSION_MAP,
+            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
         }
         params.update(self.code_model.options)
         params.update(kwargs)
@@ -88,44 +107,33 @@ class GeneralSerializer(BaseSerializer):
             serialize_namespace=self.serialize_namespace,
         )
 
-    def serialize_vendor_file(self) -> str:
-        template = self.env.get_template("vendor.py.jinja2")
+    def need_utils_utils_file(self) -> str:
+        template = self.env.get_template("utils.py.jinja2")
         clients = self.code_model.get_clients(self.client_namespace)
 
         # configure imports
         file_import = FileImport(self.code_model)
-        if self.code_model.need_vendored_mixin(self.client_namespace):
+        if self.code_model.need_utils_mixin:
             file_import.add_submodule_import(
                 "abc",
                 "ABC",
                 ImportType.STDLIB,
             )
-            file_import.add_submodule_import(
-                "" if self.code_model.is_azure_flavor else "runtime",
-                f"{'Async' if self.async_mode else ''}PipelineClient",
-                ImportType.SDKCORE,
-                TypingSection.TYPING,
-            )
             file_import.add_msrest_import(
-                serialize_namespace=self.serialize_namespace,
+                serialize_namespace=f"{self.serialize_namespace}._utils",
                 msrest_import_type=MsrestImportType.SerializerDeserializer,
                 typing_section=TypingSection.TYPING,
             )
-            for client in clients:
-                if client.has_mixin:
-                    file_import.add_submodule_import(
-                        "._configuration",
-                        f"{client.name}Configuration",
-                        ImportType.LOCAL,
-                    )
-        if self.code_model.need_vendored_etag(self.client_namespace):
+            file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Generic", ImportType.STDLIB)
+        if self.code_model.need_utils_etag(self.client_namespace):
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
                 "",
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
-        if self.code_model.need_vendored_form_data(self.async_mode, self.client_namespace):
+        if self.code_model.need_utils_form_data(self.async_mode, self.client_namespace):
             file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
@@ -135,12 +143,12 @@ class GeneralSerializer(BaseSerializer):
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "._model_base",
+                ".._utils.model_base",
                 "SdkJSONEncoder",
                 ImportType.LOCAL,
             )
             file_import.add_submodule_import(
-                "._model_base",
+                ".._utils.model_base",
                 "Model",
                 ImportType.LOCAL,
             )
@@ -206,19 +214,33 @@ class GeneralSerializer(BaseSerializer):
                 if not enum.internal
             }
         )
-        cross_langauge_def_dict.update(
-            {
-                (
-                    f"{self.code_model.namespace}.{client.name}."
-                    + ("" if operation_group.is_mixin else f"{operation_group.property_name}.")
-                    + f"{operation.name}"
-                ): operation.cross_language_definition_id
-                for client in self.code_model.clients
-                for operation_group in client.operation_groups
-                for operation in operation_group.operations
-                if not operation.name.startswith("_")
-            }
-        )
+        for client in self.code_model.clients:
+            for operation_group in client.operation_groups:
+                for operation in operation_group.operations:
+                    if operation.name.startswith("_"):
+                        continue
+                    cross_langauge_def_dict.update(
+                        {
+                            f"{self.code_model.namespace}."
+                            + (
+                                f"{client.name}."
+                                if operation_group.is_mixin
+                                else f"operations.{operation_group.class_name}."
+                            )
+                            + f"{operation.name}": operation.cross_language_definition_id
+                        }
+                    )
+                    cross_langauge_def_dict.update(
+                        {
+                            f"{self.code_model.namespace}.aio."
+                            + (
+                                f"{client.name}."
+                                if operation_group.is_mixin
+                                else f"operations.{operation_group.class_name}."
+                            )
+                            + f"{operation.name}": operation.cross_language_definition_id
+                        }
+                    )
         return json.dumps(
             {
                 "CrossLanguagePackageId": self.code_model.cross_language_package_id,

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

@@ -230,10 +230,11 @@ class DpgModelSerializer(_ModelSerializer):
         file_import = FileImport(self.code_model)
         if any(not m.parents for m in self.models):
             file_import.add_submodule_import(
-                self.code_model.get_relative_import_path(self.serialize_namespace),
-                "_model_base",
+                self.code_model.get_relative_import_path(self.serialize_namespace, module_name="_utils.model_base"),
+                "Model",
                 ImportType.LOCAL,
                 TypingSection.REGULAR,
+                alias="_Model",
             )
         for model in self.models:
             if model.base == "json":
@@ -272,7 +273,7 @@ class DpgModelSerializer(_ModelSerializer):
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
-        basename = "_model_base.Model"
+        basename = "_Model"
         if model.parents:
             basename = ", ".join([m.name for m in model.parents])
         if model.discriminator_value:

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

@@ -109,6 +109,7 @@ class ParameterSerializer:
             return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
         return serialize_line
 
+    # pylint: disable=line-too-long
     def serialize_path(
         self,
         parameters: Union[
@@ -124,7 +125,11 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    self.serialize_parameter(path_parameter, serializer_name),
+                    (
+                        f'"" if {path_parameter.full_client_name} is None else "/" + {self.serialize_parameter(path_parameter, serializer_name)}'
+                        if path_parameter.optional and isinstance(path_parameter, RequestBuilderParameter)
+                        else self.serialize_parameter(path_parameter, serializer_name)
+                    ),
                 )
                 for path_parameter in parameters
             ]

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

@@ -62,7 +62,7 @@ class SampleSerializer(BaseSerializer):
                 ImportType.SDKCORE,
             )
         for param in self.operation.parameters.positional + self.operation.parameters.keyword_only:
-            if not param.client_default_value and not param.optional and param.wire_name in self.sample_params:
+            if param.client_default_value is None and not param.optional and param.wire_name in self.sample_params:
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
@@ -80,7 +80,7 @@ class SampleSerializer(BaseSerializer):
             for p in (
                 self.code_model.clients[0].parameters.positional + self.code_model.clients[0].parameters.keyword_only
             )
-            if not (p.optional or p.client_default_value)
+            if not p.optional and p.client_default_value is None
         ]
         client_params = {
             p.client_name: special_param.get(

package/generator/build/lib/pygen/codegen/templates/client.py.jinja2

@@ -9,7 +9,7 @@
         {% if client.has_parameterized_host %}
         {{ serializer.host_variable_name }} = {{ keywords.escape_str(client.url) }}
         {% endif %}
-        {{ serializer.initialize_config() }}
+        {{ op_tools.serialize(serializer.initialize_config()) | indent(8) }}
         {{ op_tools.serialize(serializer.initialize_pipeline_client(async_mode)) | indent(8) }}
 
         {{ op_tools.serialize(serializer.serializers_and_operation_groups_properties()) | indent(8) }}

package/generator/build/lib/pygen/codegen/templates/config.py.jinja2

@@ -21,14 +21,8 @@ class {{ client.name }}Configuration:  {{ client.config.pylint_disable() }}
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if client.credential %}
-    {% set cred_scopes = client.credential.type if client.credential.type.policy is defined and client.credential.type.policy.credential_scopes is defined %}
-    {% if not cred_scopes %}
-        {% set cred_scopes = client.credential.type.types | selectattr("policy.credential_scopes") | first if client.credential.type.types is defined %}
-    {% endif %}
-    {% if cred_scopes %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ cred_scopes.policy.credential_scopes }})
-    {% endif %}
+{% if client.credential_scopes is not none %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ client.credential_scopes }})
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
         self.polling_interval = kwargs.get("polling_interval", 30)

package/generator/build/lib/pygen/codegen/templates/model_dpg.py.jinja2

@@ -19,7 +19,7 @@
     """
 
     {% if model.is_polymorphic %}
-    __mapping__: Dict[str, _model_base.Model] = {}
+    __mapping__: Dict[str, _Model] = {}
     {% endif %}
     {% for p in serializer.get_properties_to_declare(model)%}
     {{ serializer.declare_property(p) }}

package/generator/build/lib/pygen/codegen/templates/operation_group.py.jinja2

@@ -1,4 +1,4 @@
-{% set base_class = ("(" + operation_group.base_class + ")") if operation_group.base_class else "" %}
+{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
 {% macro check_abstract_methods() %}
 {% if operation_group.has_abstract_operations %}
         raise_if_not_implemented(self.__class__, [
@@ -8,9 +8,9 @@
         ])
 {% endif %}
 {% endmacro %}
-{% if operation_group.base_class %}
+{% if operation_group.base_class(async_mode) %}
 class {{ operation_group.class_name }}( {{ operation_group.pylint_disable() }}
-    {{ operation_group.base_class }}
+    {{ operation_group.base_class(async_mode) }}
 ):
 {% else %}
 class {{ operation_group.class_name }}: {{ operation_group.pylint_disable() }}

package/generator/build/lib/pygen/codegen/templates/packaging_templates/setup.py.jinja2

@@ -1,4 +1,6 @@
 # coding=utf-8
+{% set min_version = MIN_PYTHON_VERSION.split('.')[1] | int %}
+{% set max_version = MAX_PYTHON_VERSION.split('.')[1] | int %}
 {% if code_model.license_header %}
 {{ code_model.license_header }}
 {% endif %}
@@ -67,10 +69,9 @@ setup(
         "Programming Language :: Python",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
+        {% for version in range(min_version, max_version + 1)  %}
+        "Programming Language :: Python :: 3.{{ version }}",
+        {% endfor %}
         "License :: OSI Approved :: MIT License",
     ],
     zip_safe=False,
@@ -95,21 +96,21 @@ setup(
     {% endif %}
     install_requires=[
         {% if code_model.is_legacy %}
-        "msrest>=0.7.1",
+        "msrest>={{ VERSION_MAP["msrest"] }}",
         {% else %}
-        "isodate>=0.6.1",
+        "isodate>={{ VERSION_MAP["isodate"] }}",
         {% endif %}
         {% if azure_arm %}
-        "azure-mgmt-core>=1.3.2",
+        "azure-mgmt-core>={{ VERSION_MAP["azure-mgmt-core"] }}",
         {% elif code_model.is_azure_flavor %}
-        "azure-core>=1.30.0",
+        "azure-core>={{ VERSION_MAP["azure-core"] }}",
         {% else %}
-        "corehttp[requests]",
+        "corehttp[requests]>={{ VERSION_MAP["corehttp"] }}",
         {% endif %}
-        "typing-extensions>=4.6.0",
+        "typing-extensions>={{ VERSION_MAP['typing-extensions'] }}",
     ],
     {% if package_mode %}
-    python_requires=">=3.9",
+    python_requires=">={{  MIN_PYTHON_VERSION }}",
     {% else %}
     long_description="""\
     {{ code_model.description }}

package/generator/build/lib/pygen/codegen/templates/{vendor.py.jinja2 → utils.py.jinja2}

@@ -5,20 +5,19 @@
 
 {{ imports }}
 
-{% if code_model.need_vendored_mixin(client_namespace) %}
-    {% for client in clients | selectattr("has_mixin") %}
-{% set pylint_disable = "# pylint: disable=name-too-long" if (client.name | length) + ("MixinABC" | length) > 40 else "" %}
-class {{ client.name }}MixinABC(  {{ pylint_disable }}
-    ABC
-):
+{% if code_model.need_utils_mixin %}
+
+TClient = TypeVar("TClient")
+TConfig = TypeVar("TConfig")
+
+class ClientMixinABC(ABC, Generic[TClient, TConfig]):
     """DO NOT use this class. It is for internal typing use only."""
-    _client: "{{ keywords.async_class }}PipelineClient"
-    _config: {{ client.name }}Configuration
+    _client: TClient
+    _config: TConfig
     _serialize: "Serializer"
     _deserialize: "Deserializer"
-    {% endfor %}
 {% endif %}
-{% if code_model.need_vendored_abstract(client_namespace) %}
+{% if code_model.need_utils_abstract(client_namespace) %}
 
 def raise_if_not_implemented(cls, abstract_methods):
     not_implemented = [f for f in abstract_methods if not callable(getattr(cls, f, None))]
@@ -29,7 +28,7 @@ def raise_if_not_implemented(cls, abstract_methods):
         )
 {% endif %}
 
-{% if code_model.need_vendored_etag(client_namespace) %}
+{% if code_model.need_utils_etag(client_namespace) %}
 def quote_etag(etag: Optional[str]) -> Optional[str]:
     if not etag or etag == "*":
         return etag
@@ -59,7 +58,7 @@ def prep_if_none_match(etag: Optional[str], match_condition: Optional[MatchCondi
         return "*"
     return None
 {% endif %}
-{% if code_model.need_vendored_form_data(async_mode, client_namespace)  %}
+{% if code_model.need_utils_form_data(async_mode, client_namespace)  %}
 # file-like tuple could be `(filename, IO (or bytes))` or `(filename, IO (or bytes), content_type)`
 FileContent = Union[str, bytes, IO[str], IO[bytes]]
 

package/generator/component-detection-pip-report.json

@@ -4,11 +4,11 @@
   "install": [
     {
       "download_info": {
-        "url": "https://files.pythonhosted.org/packages/54/21/f43f0a1fa8b06b32812e0975981f4677d28e0f3271601dc88ac5a5b83220/setuptools-78.1.0-py3-none-any.whl",
+        "url": "https://files.pythonhosted.org/packages/cc/ea/d53f2f8897c46a36df085964d07761ea4c2d1f2cf92019693b6742b7aabb/setuptools-79.0.0-py3-none-any.whl",
         "archive_info": {
-          "hash": "sha256=3e386e96793c8702ae83d17b853fb93d3e09ef82ec62722e61da5cd22376dcd8",
+          "hash": "sha256=b9ab3a104bedb292323f53797b00864e10e434a3ab3906813a7169e4745b912a",
           "hashes": {
-            "sha256": "3e386e96793c8702ae83d17b853fb93d3e09ef82ec62722e61da5cd22376dcd8"
+            "sha256": "b9ab3a104bedb292323f53797b00864e10e434a3ab3906813a7169e4745b912a"
           }
         }
       },
@@ -18,7 +18,7 @@
       "metadata": {
         "metadata_version": "2.4",
         "name": "setuptools",
-        "version": "78.1.0",
+        "version": "79.0.0",
         "dynamic": [
           "license-file"
         ],
@@ -39,7 +39,6 @@
         "classifier": [
           "Development Status :: 5 - Production/Stable",
           "Intended Audience :: Developers",
-          "License :: OSI Approved :: MIT License",
           "Programming Language :: Python :: 3",
           "Programming Language :: Python :: 3 :: Only",
           "Topic :: Software Development :: Libraries :: Python Modules",

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