@autorest/python 6.38.1 → 6.39.0

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

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from pathlib import Path
-from typing import List, Dict, Any, Set, Union, Literal, Optional, cast
+from typing import Any, Union, Literal, Optional, cast
 
 from .base import BaseType
 from .enum_type import EnumType
@@ -22,7 +22,7 @@ def _is_legacy(options) -> bool:
     return not (options.get("version-tolerant") or options.get("low-level-client"))
 
 
-def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
+def get_all_operation_groups_recursively(clients: list[Client]) -> list[OperationGroup]:
     operation_groups = []
     queue = []
     for client in clients:
@@ -37,10 +37,10 @@ def get_all_operation_groups_recursively(clients: List[Client]) -> List[Operatio
 class ClientNamespaceType:
     def __init__(
         self,
-        clients: Optional[List[Client]] = None,
-        models: Optional[List[ModelType]] = None,
-        enums: Optional[List[EnumType]] = None,
-        operation_groups: Optional[List[OperationGroup]] = None,
+        clients: Optional[list[Client]] = None,
+        models: Optional[list[ModelType]] = None,
+        enums: Optional[list[EnumType]] = None,
+        operation_groups: Optional[list[OperationGroup]] = None,
     ):
         self.clients = clients or []
         self.models = models or []
@@ -73,34 +73,34 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         options: OptionsDict,
     ) -> None:
         self.yaml_data = yaml_data
         self.options = options
         self.namespace = self.yaml_data["namespace"]
-        self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
-        self._model_types: List[ModelType] = []
+        self.types_map: dict[int, BaseType] = {}  # map yaml id to schema
+        self._model_types: list[ModelType] = []
         from . import build_type
 
         for type_yaml in yaml_data.get("types", []):
             build_type(yaml_data=type_yaml, code_model=self)
-        self.clients: List[Client] = [
+        self.clients: list[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
         if self.options["models-mode"] and self.model_types:
             self.sort_model_types()
-        self.named_unions: List[CombinedType] = [
+        self.named_unions: list[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
         self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
         self.for_test: bool = False
         # key is typespec namespace, value is models/clients/opeartion_groups/enums cache in the namespace
-        self._client_namespace_types: Dict[str, ClientNamespaceType] = {}
+        self._client_namespace_types: dict[str, ClientNamespaceType] = {}
         self.has_subnamespace = False
-        self._operations_folder_name: Dict[str, str] = {}
-        self._relative_import_path: Dict[str, str] = {}
-        self.metadata: Dict[str, Any] = yaml_data.get("metadata", {})
+        self._operations_folder_name: dict[str, str] = {}
+        self._relative_import_path: dict[str, str] = {}
+        self.metadata: dict[str, Any] = yaml_data.get("metadata", {})
 
     @staticmethod
     def get_imported_namespace_for_client(imported_namespace: str, async_mode: bool = False) -> str:
@@ -160,7 +160,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         return "_".join(parts) + (str(dot_num) if dot_num > 0 else "")
 
     @property
-    def client_namespace_types(self) -> Dict[str, ClientNamespaceType]:
+    def client_namespace_types(self) -> dict[str, ClientNamespaceType]:
         if not self._client_namespace_types:
             # calculate client namespace types for each kind of client namespace
             for client in self.clients:
@@ -202,7 +202,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         return any(client.has_etag for client in self.clients)
 
     @staticmethod
-    def clients_has_operations(clients: List[Client]) -> bool:
+    def clients_has_operations(clients: list[Client]) -> bool:
         return any(c for c in clients if c.has_operations)
 
     @property
@@ -235,7 +235,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def client_filename(self) -> str:
         return self.clients[0].filename
 
-    def get_clients(self, client_namespace: str) -> List[Client]:
+    def get_clients(self, client_namespace: str) -> list[Client]:
         """Get all clients in specific namespace"""
         return self.client_namespace_types.get(client_namespace, ClientNamespaceType()).clients
 
@@ -332,7 +332,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             raise KeyError(f"Couldn't find schema with id {schema_id}") from exc
 
     @property
-    def model_types(self) -> List[ModelType]:
+    def model_types(self) -> list[ModelType]:
         """All of the model types in this class"""
         if not self._model_types:
             self._model_types = [
@@ -341,19 +341,19 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         return self._model_types
 
     @model_types.setter
-    def model_types(self, val: List[ModelType]) -> None:
+    def model_types(self, val: list[ModelType]) -> None:
         self._model_types = val
 
     @staticmethod
-    def get_public_model_types(models: List[ModelType]) -> List[ModelType]:
+    def get_public_model_types(models: list[ModelType]) -> list[ModelType]:
         return [m for m in models if not m.internal and not m.base == "json"]
 
     @property
-    def public_model_types(self) -> List[ModelType]:
+    def public_model_types(self) -> list[ModelType]:
         return self.get_public_model_types(self.model_types)
 
     @property
-    def enums(self) -> List[EnumType]:
+    def enums(self) -> list[EnumType]:
         """All of the enums"""
         return [t for t in self.types_map.values() if isinstance(t, EnumType)]
 
@@ -364,8 +364,8 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def _sort_model_types_helper(
         self,
         current: ModelType,
-        seen_schema_names: Set[str],
-        seen_schema_yaml_ids: Set[int],
+        seen_schema_names: set[str],
+        seen_schema_yaml_ids: set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
@@ -389,9 +389,9 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         :return: None
         :rtype: None
         """
-        seen_schema_names: Set[str] = set()
-        seen_schema_yaml_ids: Set[int] = set()
-        sorted_object_schemas: List[ModelType] = []
+        seen_schema_names: set[str] = set()
+        seen_schema_yaml_ids: set[int] = set()
+        sorted_object_schemas: list[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
             sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
         self.model_types = sorted_object_schemas
@@ -415,7 +415,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         return _is_legacy(self.options)
 
     @staticmethod
-    def has_non_json_models(models: List[ModelType]) -> bool:
+    def has_non_json_models(models: list[ModelType]) -> bool:
         return any(m for m in models if m.base != "json")
 
     @property

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Type, Tuple, Union
+from typing import Any, Optional, TYPE_CHECKING, Type, Union
 import re
 from .imports import FileImport, ImportType, TypingSection
 from .base import BaseType
@@ -23,9 +23,9 @@ class CombinedType(BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
-        types: List[BaseType],
+        types: list[BaseType],
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.types = types  # the types that this type is combining
@@ -104,7 +104,7 @@ class CombinedType(BaseType):
             client_default_value_declaration=client_default_value_declaration,
         )
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         raise ValueError("You shouldn't get polymorphic subtypes of multiple types")
 
     @property
@@ -131,7 +131,7 @@ class CombinedType(BaseType):
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BaseType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "BaseType":
         from . import build_type
 
         return cls(
@@ -143,8 +143,8 @@ class CombinedType(BaseType):
     def target_model_subtype(
         self,
         target_types: Union[
-            Tuple[Type[ModelType]],
-            Tuple[Type[ModelType], Type[ModelType]],
+            tuple[Type[ModelType]],
+            tuple[Type[ModelType], Type[ModelType]],
         ],
     ) -> Optional[ModelType]:
         for sub_t in self.types:

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

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Optional, TYPE_CHECKING, Union
+from typing import Any, Optional, TYPE_CHECKING, Union
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
@@ -28,7 +28,7 @@ class ConstantType(BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         value_type: BaseType,
         value: Optional[Union[str, int, float]],
@@ -82,7 +82,7 @@ class ConstantType(BaseType):
         return isinstance(self.value_type, (IntegerType, BinaryType, StringType, BooleanType))
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ConstantType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "ConstantType":
         """Constructs a ConstantType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -109,16 +109,9 @@ class ConstantType(BaseType):
             client_default_value_declaration=self.get_declaration(),
         )
 
-    def _imports_shared(self, **kwargs: Any):
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
         file_import.merge(self.value_type.imports(**kwargs))
-        return file_import
-
-    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
-        return self._imports_shared(**kwargs)
-
-    def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(**kwargs)
         if self._is_literal:
             file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
         return file_import

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

@@ -7,9 +7,7 @@ from abc import abstractmethod
 from typing import (
     Optional,
     Any,
-    Dict,
     TYPE_CHECKING,
-    List,
     Generic,
     TypeVar,
     Union,
@@ -29,7 +27,7 @@ class _CredentialPolicyBaseType:
     Inherited by our BearerTokenCredentialPolicy and KeyCredentialPolicy types.
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         self.yaml_data = yaml_data
         self.code_model = code_model
 
@@ -45,10 +43,10 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
-        credential_scopes: List[str],
-        flows: Optional[Dict[str, Any]] = None,
+        credential_scopes: list[str],
+        flows: Optional[dict[str, Any]] = None,
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.credential_scopes = credential_scopes
@@ -60,7 +58,7 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
         return f"policies.{policy_name}(self.credential, *self.credential_scopes, {auth_flows}**kwargs)"
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BearerTokenCredentialPolicyType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "BearerTokenCredentialPolicyType":
         return cls(yaml_data, code_model, yaml_data["credentialScopes"], yaml_data.get("flows"))
 
 
@@ -75,7 +73,7 @@ class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
 class KeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         key: str,
         scheme: Optional[str] = None,
@@ -95,7 +93,7 @@ class KeyCredentialPolicyType(_CredentialPolicyBaseType):
         return f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "KeyCredentialPolicyType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "KeyCredentialPolicyType":
         return cls(yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None))
 
 
@@ -114,7 +112,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         policy: CredentialPolicyType,
     ) -> None:
@@ -138,7 +136,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):
         return self.docstring_type()
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "CredentialType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "CredentialType":
         from . import build_type
 
         return cls(

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

@@ -3,9 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, TYPE_CHECKING, List
+from typing import Any, Optional, TYPE_CHECKING
 from .base import BaseType
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -23,7 +23,7 @@ class DictionaryType(BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         element_type: BaseType,
     ) -> None:
@@ -48,7 +48,7 @@ class DictionaryType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        return f"Dict[str, {self.element_type.type_annotation(**kwargs)}]"
+        return f"dict[str, {self.element_type.type_annotation(**kwargs)}]"
 
     def description(self, *, is_operation_file: bool) -> str:
         return "" if is_operation_file else self.yaml_data.get("description", "")
@@ -79,7 +79,7 @@ class DictionaryType(BaseType):
             )
         }
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         from .model_type import ModelType
 
         if isinstance(self.element_type, ModelType):
@@ -90,7 +90,7 @@ class DictionaryType(BaseType):
                 polymorphic_subtypes.append(self.element_type)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "DictionaryType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "DictionaryType":
         """Constructs a DictionaryType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -99,7 +99,7 @@ class DictionaryType(BaseType):
         :return: A created DictionaryType
         :rtype: ~autorest.models.DictionaryType
         """
-        element_schema: Dict[str, Any] = yaml_data["elementType"]
+        element_schema: dict[str, Any] = yaml_data["elementType"]
 
         from . import build_type  # pylint: disable=import-outside-toplevel
 
@@ -113,7 +113,6 @@ class DictionaryType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports(**kwargs))
         return file_import
 

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TYPE_CHECKING, Optional, cast
+from typing import Any, TYPE_CHECKING, Optional, cast
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
@@ -24,7 +24,7 @@ class EnumValue(BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         enum_type: "EnumType",
         value_type: BaseType,
@@ -94,7 +94,7 @@ class EnumValue(BaseType):
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumValue":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "EnumValue":
         """Constructs an EnumValue from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this object
@@ -127,9 +127,9 @@ class EnumType(BaseType):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
-        values: List["EnumValue"],
+        values: list["EnumValue"],
         value_type: BaseType,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
@@ -219,12 +219,12 @@ class EnumType(BaseType):
     def instance_check_template(self) -> str:
         return self.value_type.instance_check_template
 
-    def fill_instance_from_yaml(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def fill_instance_from_yaml(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         for value in yaml_data["values"]:
             self.values.append(EnumValue.from_yaml(value, code_model))
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "EnumType":
         raise ValueError(
             "You shouldn't call from_yaml for EnumType to avoid recursion. "
             "Please initial a blank EnumType, then call .fill_instance_from_yaml on the created type."

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

@@ -4,8 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum, auto
-from typing import Dict, List, Optional, Tuple, Union, Set, TYPE_CHECKING
-from .._utils import get_parent_namespace
+from typing import Optional, Union, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -46,7 +45,7 @@ class ImportModel:
         *,
         submodule_name: Optional[str] = None,
         alias: Optional[str] = None,
-        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
+        version_modules: Optional[tuple[tuple[tuple[int, int], str, Optional[str]]]] = None,
     ):
         self.typing_section = typing_section
         self.import_type = import_type
@@ -90,10 +89,10 @@ class TypeDefinition:
 
 class FileImport:
     def __init__(self, code_model: "CodeModel") -> None:
-        self.imports: List[ImportModel] = []
+        self.imports: list[ImportModel] = []
         self.code_model = code_model
         # has sync and async type definitions
-        self.type_definitions: Dict[str, TypeDefinition] = {}
+        self.type_definitions: dict[str, TypeDefinition] = {}
         self.core_library = self.code_model.core_library
 
     def _append_import(self, import_model: ImportModel) -> None:
@@ -114,7 +113,7 @@ class FileImport:
         ):
             self.imports.append(import_model)
 
-    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+    def get_imports_from_section(self, typing_section: TypingSection) -> list[ImportModel]:
         return [i for i in self.imports if i.typing_section == typing_section]
 
     def add_submodule_import(
@@ -124,7 +123,7 @@ class FileImport:
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
-        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
+        version_modules: Optional[tuple[tuple[tuple[int, int], str, Optional[str]]]] = None,
     ) -> None:
         """Add an import to this import block."""
         self._append_import(
@@ -167,7 +166,7 @@ class FileImport:
         """Merge the given file import format."""
         for i in file_import.imports:
             self._append_import(i)
-        self.type_definitions.update(file_import.type_definitions)
+        self.type_definitions |= file_import.type_definitions
 
     def add_mutable_mapping_import(self) -> None:
         self.add_submodule_import("collections.abc", "MutableMapping", ImportType.STDLIB)
@@ -180,21 +179,21 @@ class FileImport:
 
     def to_dict(
         self,
-    ) -> Dict[
+    ) -> dict[
         TypingSection,
-        Dict[
+        dict[
             ImportType,
-            Dict[
+            dict[
                 str,
-                Set[
+                set[
                     Optional[
                         Union[
                             str,
-                            Tuple[str, str],
-                            Tuple[
+                            tuple[str, str],
+                            tuple[
                                 str,
                                 Optional[str],
-                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                tuple[tuple[tuple[int, int], str, Optional[str]]],
                             ],
                         ]
                     ]
@@ -202,21 +201,21 @@ class FileImport:
             ],
         ],
     ]:
-        retval: Dict[
+        retval: dict[
             TypingSection,
-            Dict[
+            dict[
                 ImportType,
-                Dict[
+                dict[
                     str,
-                    Set[
+                    set[
                         Optional[
                             Union[
                                 str,
-                                Tuple[str, str],
-                                Tuple[
+                                tuple[str, str],
+                                tuple[
                                     str,
                                     Optional[str],
-                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                    tuple[tuple[tuple[int, int], str, Optional[str]]],
                                 ],
                             ]
                         ]
@@ -228,11 +227,11 @@ class FileImport:
             name_import: Optional[
                 Union[
                     str,
-                    Tuple[str, str],
-                    Tuple[
+                    tuple[str, str],
+                    tuple[
                         str,
                         Optional[str],
-                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                        tuple[tuple[tuple[int, int], str, Optional[str]]],
                     ],
                 ]
             ] = None
@@ -265,10 +264,6 @@ class FileImport:
         else:
             # _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 _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),

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

@@ -3,9 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, Union, TYPE_CHECKING, List
+from typing import Any, Optional, Union, TYPE_CHECKING
 from .base import BaseType
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 class ListType(BaseType):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         element_type: BaseType,
     ) -> None:
@@ -40,7 +40,14 @@ class ListType(BaseType):
         ):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)
-        return f"List[{self.element_type.type_annotation(**kwargs)}]"
+        has_operation_named_list = any(
+            o.name.lower() == "list"
+            for c in self.code_model.clients
+            for og in c.operation_groups
+            for o in og.operations
+        )
+        list_type = "List" if has_operation_named_list and kwargs.get("is_operation_file") else "list"
+        return f"{list_type}[{self.element_type.type_annotation(**kwargs)}]"
 
     def description(self, *, is_operation_file: bool) -> str:
         return "" if is_operation_file else self.yaml_data.get("description", "")
@@ -80,8 +87,8 @@ class ListType(BaseType):
         return f"list of {self.element_type.docstring_text(**kwargs)}"
 
     @property
-    def validation(self) -> Optional[Dict[str, Union[bool, int, str]]]:
-        validation: Dict[str, Union[bool, int, str]] = {}
+    def validation(self) -> Optional[dict[str, Union[bool, int, str]]]:
+        validation: dict[str, Union[bool, int, str]] = {}
         if self.max_items:
             validation["max_items"] = self.max_items
             validation["min_items"] = self.min_items or 0
@@ -102,7 +109,7 @@ class ListType(BaseType):
             )
         ]
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         from .model_type import ModelType
 
         if isinstance(self.element_type, ModelType):
@@ -117,7 +124,7 @@ class ListType(BaseType):
         return "isinstance({}, list)"
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ListType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "ListType":
         from . import build_type
 
         return cls(
@@ -128,12 +135,6 @@ class ListType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        if not (
-            self.code_model.options["version-tolerant"]
-            and self.element_type.is_xml
-            and not self.code_model.options["models-mode"]
-        ):
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports(**kwargs))
         return file_import