@autorest/python 6.38.2 → 6.39.0

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, cast
+from typing import cast
 
 from . import utils
 from ..models import Client, ParameterMethodLocation, Parameter, ParameterLocation
@@ -38,7 +38,7 @@ class ClientSerializer:
             response_type_annotation="None",
         )
 
-    def pop_kwargs_from_signature(self) -> List[str]:
+    def pop_kwargs_from_signature(self) -> list[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
             self.client.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
@@ -50,15 +50,15 @@ class ClientSerializer:
         class_name = self.client.name
         base_class = ""
         if self.client.has_mixin:
-            prefix = "" if self.client.code_model.options["multiapi"] else "_"
+            prefix = "_"
             base_class = f"{prefix}{class_name}OperationsMixin"
         pylint_disable = self.client.pylint_disable()
         if base_class:
             return f"class {class_name}({base_class}):{pylint_disable}"
         return f"class {class_name}:{pylint_disable}"
 
-    def property_descriptions(self, async_mode: bool) -> List[str]:
-        retval: List[str] = []
+    def property_descriptions(self, async_mode: bool) -> list[str]:
+        retval: list[str] = []
         operations_folder = ".aio.operations." if async_mode else ".operations."
         for og in [og for og in self.client.operation_groups if not og.is_mixin]:
             retval.append(f":ivar {og.property_name}: {og.class_name} operations")
@@ -78,7 +78,7 @@ class ClientSerializer:
         retval.append('"""')
         return retval
 
-    def initialize_config(self) -> List[str]:
+    def initialize_config(self) -> list[str]:
         retval = []
         additional_signatures = []
         if self.client.need_cloud_setting:
@@ -86,7 +86,7 @@ class ClientSerializer:
             endpoint_parameter = cast(Parameter, self.client.endpoint_parameter)
             retval.extend(
                 [
-                    '_cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore',
+                    "_cloud = cloud_setting 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"]',
@@ -124,7 +124,7 @@ class ClientSerializer:
     def should_init_super(self) -> bool:
         return any(og for og in self.client.operation_groups if og.is_mixin and og.has_abstract_operations)
 
-    def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
+    def initialize_pipeline_client(self, async_mode: bool) -> list[str]:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
         endpoint_name = "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
@@ -154,7 +154,7 @@ class ClientSerializer:
         )
         return result
 
-    def serializers_and_operation_groups_properties(self) -> List[str]:
+    def serializers_and_operation_groups_properties(self) -> list[str]:
         retval = []
 
         def _get_client_models_value(models_dict_name: str) -> str:
@@ -169,12 +169,12 @@ class ClientSerializer:
             )
             model_dict_name = f"_models.{self.client.code_model.models_filename}" if add_private_models else "_models"
             retval.append(
-                f"client_models{': Dict[str, Any]' if not self.client.code_model.model_types else ''}"
+                f"client_models{': dict[str, Any]' if not self.client.code_model.model_types else ''}"
                 f" = {_get_client_models_value(model_dict_name)}"
             )
             if add_private_models and self.client.code_model.model_types:
                 update_dict = "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
-                retval.append(f"client_models.update({update_dict})")
+                retval.append(f"client_models |= {update_dict}")
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
@@ -182,10 +182,7 @@ class ClientSerializer:
             retval.append("self._serialize.client_side_validation = False")
         operation_groups = [og for og in self.client.operation_groups if not og.is_mixin]
         for og in operation_groups:
-            if og.code_model.options["multiapi"]:
-                api_version = f", '{og.api_versions[0]}'" if og.api_versions else ", None"
-            else:
-                api_version = ""
+            api_version = ""
             retval.extend(
                 [
                     f"self.{og.property_name} = {og.class_name}(",
@@ -213,13 +210,13 @@ class ClientSerializer:
             response_type_annotation=("Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse"),
         )
 
-    def _example_make_call(self, async_mode: bool) -> List[str]:
+    def _example_make_call(self, async_mode: bool) -> list[str]:
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
         retval = [f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"]
         retval.append(f"<{http_response}: 200 OK>")
         return retval
 
-    def _request_builder_example(self, async_mode: bool) -> List[str]:
+    def _request_builder_example(self, async_mode: bool) -> list[str]:
         retval = [
             "We have helper methods to create requests specific to this service in "
             + f"`{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}`."
@@ -242,14 +239,14 @@ class ClientSerializer:
         retval.extend(self._example_make_call(async_mode))
         return retval
 
-    def _rest_request_example(self, async_mode: bool) -> List[str]:
+    def _rest_request_example(self, async_mode: bool) -> list[str]:
         retval = [f">>> from {self.client.code_model.core_library}.rest import HttpRequest"]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
         return retval
 
-    def send_request_description(self, async_mode: bool) -> List[str]:
+    def send_request_description(self, async_mode: bool) -> list[str]:
         rest_library = f"{self.client.code_model.core_library}.rest"
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
@@ -269,7 +266,7 @@ class ClientSerializer:
         retval.append('"""')
         return retval
 
-    def serialize_path(self) -> List[str]:
+    def serialize_path(self) -> list[str]:
         return self.parameter_serializer.serialize_path(self.client.parameters.path, "self._serialize")
 
 
@@ -294,7 +291,7 @@ class ConfigSerializer:
             response_type_annotation="None",
         )
 
-    def pop_kwargs_from_signature(self) -> List[str]:
+    def pop_kwargs_from_signature(self) -> list[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
             self.client.config.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
@@ -302,22 +299,22 @@ class ConfigSerializer:
             pop_params_kwarg=PopKwargType.NO,
         )
 
-    def set_constants(self) -> List[str]:
+    def set_constants(self) -> list[str]:
         return [
             f"self.{p.client_name} = {p.client_default_value_declaration}"
             for p in self.client.config.parameters.constant
             if p not in self.client.config.parameters.method
         ]
 
-    def check_required_parameters(self) -> List[str]:
+    def check_required_parameters(self) -> list[str]:
         return [
             f"if {p.client_name} is None:\n" f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
             for p in self.client.config.parameters.method
             if not (p.optional or p.constant)
         ]
 
-    def property_descriptions(self, async_mode: bool) -> List[str]:
-        retval: List[str] = []
+    def property_descriptions(self, async_mode: bool) -> list[str]:
+        retval: list[str] = []
         for p in self.client.config.parameters.method:
             retval.append(f":{p.description_keyword} {p.client_name}: {p.description}")
             retval.append(f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}")

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional, List
+from typing import Optional
 from jinja2 import Environment
 from .base_serializer import BaseSerializer
 from ..models import FileImport, CodeModel, EnumType
@@ -17,7 +17,7 @@ class EnumSerializer(BaseSerializer):
         env: Environment,
         async_mode: bool = False,
         *,
-        enums: List[EnumType],
+        enums: list[EnumType],
         client_namespace: Optional[str] = None
     ):
         super().__init__(code_model, env, async_mode=async_mode, client_namespace=client_namespace)

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

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import json
-from typing import Any, List, TYPE_CHECKING
+from typing import Any
 import re
 import tomli as tomllib
 from packaging.version import parse as parse_version
@@ -19,9 +19,6 @@ from ..models.utils import NamespaceType
 from .client_serializer import ClientSerializer, ConfigSerializer
 from .base_serializer import BaseSerializer
 
-if TYPE_CHECKING:
-    from pathlib import Path
-
 VERSION_MAP = {
     "msrest": "0.7.1",
     "isodate": "0.6.1",
@@ -45,7 +42,7 @@ class GeneralSerializer(BaseSerializer):
             "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
             "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
         }
-        params.update({"options": self.code_model.options})
+        params |= {"options": self.code_model.options}
         return template.render(code_model=self.code_model, **params)
 
     def _extract_min_dependency(self, s):
@@ -60,12 +57,11 @@ class GeneralSerializer(BaseSerializer):
         m = re.search(r"[>=]=?([\d.]+(?:[a-z]+\d+)?)", s)
         return parse_version(m.group(1)) if m else parse_version("0")
 
-    def _keep_pyproject_fields(self, file_path: "Path") -> dict:
+    def _keep_pyproject_fields(self, file_content: str) -> dict:
         # Load the pyproject.toml file if it exists and extract fields to keep.
         result: dict = {"KEEP_FIELDS": {}}
         try:
-            with open(file_path, "rb") as f:
-                loaded_pyproject_toml = tomllib.load(f)
+            loaded_pyproject_toml = tomllib.loads(file_content)
         except Exception:  # pylint: disable=broad-except
             # If parsing the pyproject.toml fails, we assume the it does not exist or is incorrectly formatted.
             return result
@@ -108,12 +104,12 @@ class GeneralSerializer(BaseSerializer):
 
         return result
 
-    def serialize_package_file(self, template_name: str, file_path: "Path", **kwargs: Any) -> str:
+    def serialize_package_file(self, template_name: str, file_content: str, **kwargs: Any) -> str:
         template = self.env.get_template(template_name)
 
         # Add fields to keep from an existing pyproject.toml
         if template_name == "pyproject.toml.jinja2":
-            params = self._keep_pyproject_fields(file_path)
+            params = self._keep_pyproject_fields(file_content)
         else:
             params = {}
 
@@ -130,28 +126,26 @@ class GeneralSerializer(BaseSerializer):
             dev_status = "4 - Beta"
         else:
             dev_status = "5 - Production/Stable"
-        params.update(
-            {
-                "code_model": self.code_model,
-                "dev_status": dev_status,
-                "token_credential": token_credential,
-                "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 if self.code_model.clients else "",
-                "VERSION_MAP": VERSION_MAP,
-                "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
-                "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
-            }
-        )
-        params.update({"options": self.code_model.options})
-        params.update(kwargs)
+        params |= {
+            "code_model": self.code_model,
+            "dev_status": dev_status,
+            "token_credential": token_credential,
+            "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 if self.code_model.clients else "",
+            "VERSION_MAP": VERSION_MAP,
+            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
+        }
+        params |= {"options": self.code_model.options}
+        params |= kwargs
         return template.render(file_import=FileImport(self.code_model), **params)
 
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
         return template.render()
 
-    def serialize_init_file(self, clients: List[Client]) -> str:
+    def serialize_init_file(self, clients: list[Client]) -> str:
         template = self.env.get_template("init.py.jinja2")
         return template.render(
             code_model=self.code_model,
@@ -160,7 +154,7 @@ class GeneralSerializer(BaseSerializer):
             serialize_namespace=self.serialize_namespace,
         )
 
-    def serialize_service_client_file(self, clients: List[Client]) -> str:
+    def serialize_service_client_file(self, clients: list[Client]) -> str:
         template = self.env.get_template("client_container.py.jinja2")
 
         imports = FileImport(self.code_model)
@@ -210,13 +204,10 @@ class GeneralSerializer(BaseSerializer):
             )
         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)
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
             file_import.add_submodule_import(
                 ".._utils.model_base",
                 "SdkJSONEncoder",
@@ -239,7 +230,7 @@ class GeneralSerializer(BaseSerializer):
             client_namespace=self.client_namespace,
         )
 
-    def serialize_config_file(self, clients: List[Client]) -> str:
+    def serialize_config_file(self, clients: list[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
         imports = FileImport(self.code_model)
         for client in self.code_model.clients:
@@ -282,40 +273,35 @@ class GeneralSerializer(BaseSerializer):
             f"{model.client_namespace}.models.{model.name}": model.cross_language_definition_id
             for model in self.code_model.public_model_types
         }
-        cross_langauge_def_dict.update(
-            {
-                f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
-                for enum in self.code_model.enums
-                if not enum.internal
-            }
-        )
+        cross_langauge_def_dict |= {
+            f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
+            for enum in self.code_model.enums
+            if not enum.internal
+        }
+
         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
-                        }
-                    )
+                    cross_langauge_def_dict |= {
+                        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 |= {
+                        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/import_serializer.py

@@ -4,7 +4,6 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import deepcopy
-from typing import List
 from ..models.imports import (
     ImportType,
     FileImport,
@@ -14,7 +13,7 @@ from ..models.imports import (
 )
 
 
-def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
+def _serialize_package(imports: list[ImportModel], delimiter: str) -> str:
     buffer = []
     if any(i for i in imports if i.submodule_name is None):
         buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
@@ -47,7 +46,7 @@ def _serialize_versioned_package(i: ImportModel, delimiter: str) -> str:
     return delimiter.join(buffer)
 
 
-def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
+def _serialize_import_type(imports: list[ImportModel], delimiter: str) -> str:
     """Serialize a given import type."""
     import_list = []
     for module_name in sorted(set(i.module_name for i in imports)):
@@ -60,7 +59,7 @@ def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
     return delimiter.join(import_list)
 
 
-def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]:
+def _get_import_clauses(imports: list[ImportModel], delimiter: str) -> list[str]:
     import_clause = []
     for import_type in ImportType:
         imports_with_import_type = [i for i in imports if i.import_type == import_type]
@@ -91,15 +90,15 @@ class FileImportSerializer:
             self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def get_typing_definitions(self) -> str:
-        def declare_definition(type_name: str, type_definition: TypeDefinition) -> List[str]:
-            ret: List[str] = []
+        def declare_definition(type_name: str, type_definition: TypeDefinition) -> list[str]:
+            ret: list[str] = []
             definition_value = type_definition.async_definition if self.async_mode else type_definition.sync_definition
             ret.append("{} = {}".format(type_name, definition_value))
             return ret
 
         if not self.file_import.type_definitions:
             return ""
-        declarations: List[str] = [""]
+        declarations: list[str] = [""]
         for type_name, value in self.file_import.type_definitions.items():
             declarations.extend(declare_definition(type_name, value))
         return "\n".join(declarations)

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

@@ -3,14 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
 from jinja2 import Environment
 from ..models import CodeModel, ModelType, EnumType
 
 
 class ModelInitSerializer:
     def __init__(
-        self, code_model: CodeModel, env: Environment, *, models: List[ModelType], enums: List[EnumType]
+        self, code_model: CodeModel, env: Environment, *, models: list[ModelType], enums: list[EnumType]
     ) -> None:
         self.code_model = code_model
         self.env = env

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Optional
+from typing import Optional
 from abc import ABC, abstractmethod
 
 from ..models import ModelType, Property, ConstantType, EnumValue
@@ -13,8 +13,8 @@ from .base_serializer import BaseSerializer
 from ..models.utils import NamespaceType
 
 
-def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> List[str]:
-    retval: List[str] = []
+def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> list[str]:
+    retval: list[str] = []
     sphinx_prefix = f":{description_keyword} {prop.client_name}:"
     description = prop.description(is_operation_file=False).replace("\\", "\\\\")
     retval.append(f"{sphinx_prefix} {description}" if description else sphinx_prefix)
@@ -24,7 +24,7 @@ def _documentation_string(prop: Property, description_keyword: str, docstring_ty
 
 class _ModelSerializer(BaseSerializer, ABC):
     def __init__(
-        self, code_model, env, async_mode=False, *, models: List[ModelType], client_namespace: Optional[str] = None
+        self, code_model, env, async_mode=False, *, models: list[ModelType], client_namespace: Optional[str] = None
     ):
         super().__init__(code_model, env, async_mode, client_namespace=client_namespace)
         self.models = models
@@ -51,15 +51,15 @@ class _ModelSerializer(BaseSerializer, ABC):
         return s.replace(".", "\\\\.")
 
     @staticmethod
-    def input_documentation_string(prop: Property) -> List[str]:
+    def input_documentation_string(prop: Property) -> list[str]:
         # building the param line of the property doc
         return _documentation_string(prop, "keyword", "paramtype")
 
     @staticmethod
-    def variable_documentation_string(prop: Property) -> List[str]:
+    def variable_documentation_string(prop: Property) -> list[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    def super_call(self, model: ModelType) -> List[str]:
+    def super_call(self, model: ModelType) -> list[str]:
         return [f"super().__init__({self.properties_to_pass_to_super(model)})"]
 
     @staticmethod
@@ -91,7 +91,7 @@ class _ModelSerializer(BaseSerializer, ABC):
     def _init_line_parameters(model: ModelType):
         return [p for p in model.properties if not p.readonly and not p.is_discriminator and not p.constant]
 
-    def init_line(self, model: ModelType) -> List[str]:
+    def init_line(self, model: ModelType) -> list[str]:
         init_properties_declaration = []
         init_line_parameters = self._init_line_parameters(model)
         init_line_parameters.sort(key=lambda x: x.optional)
@@ -113,12 +113,12 @@ class _ModelSerializer(BaseSerializer, ABC):
         return ", ".join(properties_to_pass_to_super)
 
     @abstractmethod
-    def initialize_properties(self, model: ModelType) -> List[str]: ...
+    def initialize_properties(self, model: ModelType) -> list[str]: ...
 
     def need_init(self, model: ModelType) -> bool:
         return bool(self.init_line(model) or model.discriminator)
 
-    def pylint_disable_items(self, model: ModelType) -> List[str]:
+    def pylint_disable_items(self, model: ModelType) -> list[str]:
         if model.flattened_property or self.initialize_properties(model):
             return [""]
         if any(p for p in model.properties if p.is_discriminator and model.discriminator_value):
@@ -172,7 +172,7 @@ class MsrestModelSerializer(_ModelSerializer):
         return f"class {model.name}({basename}):{model.pylint_disable()}"
 
     @staticmethod
-    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+    def get_properties_to_initialize(model: ModelType) -> list[Property]:
         if model.parents:
             properties_to_initialize = list(
                 {
@@ -186,7 +186,7 @@ class MsrestModelSerializer(_ModelSerializer):
             properties_to_initialize = model.properties
         return properties_to_initialize
 
-    def initialize_properties(self, model: ModelType) -> List[str]:
+    def initialize_properties(self, model: ModelType) -> list[str]:
         init_args = []
         for prop in self.get_properties_to_initialize(model):
             if prop.is_discriminator:
@@ -215,7 +215,7 @@ class MsrestModelSerializer(_ModelSerializer):
 
 
 class DpgModelSerializer(_ModelSerializer):
-    def super_call(self, model: ModelType) -> List[str]:
+    def super_call(self, model: ModelType) -> list[str]:
         super_call = f"super().__init__({self.properties_to_pass_to_super(model)})"
         if model.flattened_property:
             return [
@@ -264,8 +264,6 @@ class DpgModelSerializer(_ModelSerializer):
                         parent.name,
                         ImportType.LOCAL,
                     )
-            if model.is_polymorphic:
-                file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             if self.need_init(model):
                 file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
@@ -281,7 +279,7 @@ class DpgModelSerializer(_ModelSerializer):
         return f"class {model.name}({basename}):{model.pylint_disable()}"
 
     @staticmethod
-    def get_properties_to_declare(model: ModelType) -> List[Property]:
+    def get_properties_to_declare(model: ModelType) -> list[Property]:
         if model.parents:
             parent_properties = [p for bm in model.parents for p in bm.properties]
             properties_to_declare = [
@@ -328,7 +326,7 @@ class DpgModelSerializer(_ModelSerializer):
         generated_code = f'{prop.client_name}: {type_annotation} = {field}({", ".join(args)})'
         return f"{generated_code}{type_ignore}"
 
-    def initialize_properties(self, model: ModelType) -> List[str]:
+    def initialize_properties(self, model: ModelType) -> list[str]:
         init_args = []
         for prop in self.get_properties_to_declare(model):
             if prop.constant and not prop.is_base_discriminator:

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional, List, Union
+from typing import Optional, Union
 import functools
 from jinja2 import Environment
 
@@ -27,7 +27,7 @@ class OperationGroupsSerializer(BaseSerializer):
     def __init__(
         self,
         code_model: CodeModel,
-        operation_groups: List[OperationGroup],
+        operation_groups: list[OperationGroup],
         env: Environment,
         async_mode: bool,
         *,
@@ -39,7 +39,7 @@ class OperationGroupsSerializer(BaseSerializer):
 
     def _get_request_builders(
         self, operation_group: OperationGroup
-    ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
+    ) -> list[Union[OverloadedRequestBuilder, RequestBuilder]]:
         return [
             r
             for r in operation_group.client.request_builders

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

@@ -3,14 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
 from jinja2 import Environment
 
 from ..models import CodeModel, OperationGroup
 
 
-def get_pylint_disable(code_model: CodeModel, og: OperationGroup) -> str:
-    if og.is_mixin and not code_model.options["multiapi"]:
+def get_pylint_disable(og: OperationGroup) -> str:
+    if og.is_mixin:
         return " # pylint: disable=unused-import"
     return ""
 
@@ -19,7 +18,7 @@ class OperationsInitSerializer:
     def __init__(
         self,
         code_model: CodeModel,
-        operation_groups: List[OperationGroup],
+        operation_groups: list[OperationGroup],
         env: Environment,
         async_mode: bool,
     ) -> None:
@@ -28,12 +27,12 @@ class OperationsInitSerializer:
         self.env = env
         self.async_mode = async_mode
 
-    def operation_group_imports(self) -> List[str]:
+    def operation_group_imports(self) -> list[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
             return "_operations" if self.code_model.options["combine-operation-files"] else operation_group.filename
 
         return [
-            f"from .{_get_filename(og)} import {og.class_name} # type: ignore{get_pylint_disable(self.code_model, og)}"
+            f"from .{_get_filename(og)} import {og.class_name} # type: ignore{get_pylint_disable(og)}"
             for og in self.operation_groups
         ]