@typespec/http-client-python 0.11.0 → 0.11.1

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/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

@@ -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,
             )

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}",

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

@@ -107,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)
@@ -154,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,
             )

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/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/{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/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)