@autorest/python 6.38.2 → 6.39.0

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

package/generator/pygen/codegen/models/lro_operation.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, Optional, List, TYPE_CHECKING, TypeVar, Union
+from typing import Any, Optional, TYPE_CHECKING, TypeVar, Union
 from .imports import FileImport
 from .operation import OperationBase, Operation
 from .response import LROPagingResponse, LROResponse, Response
@@ -22,16 +22,16 @@ LROResponseType = TypeVar("LROResponseType", bound=Union[LROResponse, LROPagingR
 class LROOperationBase(OperationBase[LROResponseType]):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
-        responses: List[LROResponseType],
-        exceptions: List[Response],
+        responses: list[LROResponseType],
+        exceptions: list[Response],
         *,
-        overloads: Optional[List[Operation]] = None,
+        overloads: Optional[list[Operation]] = None,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -46,7 +46,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
         )
         if not self.name.lstrip("_").startswith("begin"):
             self.name = ("_begin" if self.internal else "begin_") + self.name
-        self.lro_options: Dict[str, Any] = self.yaml_data.get("lroOptions", {})
+        self.lro_options: dict[str, Any] = self.yaml_data.get("lroOptions", {})
         self._initial_operation: Optional["OperationType"] = None
 
     @property

package/generator/pygen/codegen/models/lro_paging_operation.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, List, Union
+from typing import Any, Union
 from .imports import FileImport
 from .lro_operation import LROOperationBase
 from .paging_operation import PagingOperationBase
@@ -12,7 +12,7 @@ from .response import LROPagingResponse, Response
 
 class LROPagingOperation(LROOperationBase[LROPagingResponse], PagingOperationBase[LROPagingResponse]):
     @property
-    def success_status_codes(self) -> List[Union[int, str, List[int]]]:
+    def success_status_codes(self) -> list[Union[int, str, list[int]]]:
         """The list of all successfull status code."""
         return [200]
 

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

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum
 from collections import OrderedDict
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
+from typing import Any, Optional, TYPE_CHECKING, cast
 import sys
 from .utils import add_to_pylint_disable, NamespaceType
 from .base import BaseType
@@ -36,7 +36,7 @@ class UsageFlags(Enum):
     Xml = 512
 
 
-def _get_properties(type: "ModelType", properties: List[Property]) -> List[Property]:
+def _get_properties(type: "ModelType", properties: list[Property]) -> list[Property]:
     for parent in type.parents:
         # here we're adding the properties from our parents
 
@@ -61,12 +61,12 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         *,
-        properties: Optional[List[Property]] = None,
-        parents: Optional[List["ModelType"]] = None,
-        discriminated_subtypes: Optional[Dict[str, "ModelType"]] = None,
+        properties: Optional[list[Property]] = None,
+        parents: Optional[list["ModelType"]] = None,
+        discriminated_subtypes: Optional[dict[str, "ModelType"]] = None,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name: str = self.yaml_data["name"]
@@ -96,7 +96,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
             return None
 
     @property
-    def flattened_items(self) -> List[str]:
+    def flattened_items(self) -> list[str]:
         return [
             item.client_name
             for prop in self.properties
@@ -141,7 +141,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         return super().xml_serialization_ctxt
 
     @property
-    def discriminated_subtypes_name_mapping(self) -> Dict[str, str]:
+    def discriminated_subtypes_name_mapping(self) -> dict[str, str]:
         return {k: v.name for k, v in self.discriminated_subtypes.items()}
 
     def get_json_template_representation(
@@ -181,7 +181,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
             )
         )
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         is_polymorphic_subtype = self.discriminator_value and not self.discriminated_subtypes
         if self._got_polymorphic_subtypes:
             return
@@ -195,13 +195,13 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         self._got_polymorphic_subtypes = False
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ModelType":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "ModelType":
         raise ValueError(
             "You shouldn't call from_yaml for ModelType to avoid recursion. "
             "Please initial a blank ModelType, then call .fill_instance_from_yaml on the created type."
         )
 
-    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:
         from . import build_type
 
         self.parents = [cast(ModelType, build_type(bm, code_model)) for bm in yaml_data.get("parents", [])]

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

@@ -4,8 +4,6 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import (
-    Dict,
-    List,
     Any,
     Optional,
     Union,
@@ -61,14 +59,14 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
 ):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
         parameters: ParameterList,
-        responses: List[ResponseType],
-        exceptions: List[Response],
+        responses: list[ResponseType],
+        exceptions: list[Response],
         *,
         overloads: Optional[Sequence["Operation"]] = None,
     ) -> None:
@@ -204,61 +202,18 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         return None if self.code_model.options["models-mode"] == "dpg" else "'object'"
 
     @property
-    def non_default_errors(self) -> List[Response]:
+    def non_default_errors(self) -> list[Response]:
         return [
             e for e in self.exceptions if "default" not in e.status_codes and e.type and isinstance(e.type, ModelType)
         ]
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-
-        response_types = [r.type_annotation(async_mode=async_mode, **kwargs) for r in self.responses if r.type]
-        if len(set(response_types)) > 1:
-            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.added_on:
-            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="_validation"),
-                "api_version_validation",
-                ImportType.LOCAL,
-            )
-        return file_import
-
     @property
     def need_import_iobase(self) -> bool:
         return self.parameters.has_body and isinstance(self.parameters.body_parameter.type, CombinedType)
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        if self.abstract:
-            return FileImport(self.code_model)
-        file_import = self._imports_shared(async_mode, **kwargs)
-        for param in self.parameters.method:
-            file_import.merge(
-                param.imports_for_multiapi(
-                    async_mode,
-                    need_import_iobase=self.need_import_iobase,
-                    **kwargs,
-                )
-            )
-        for response in self.responses:
-            file_import.merge(
-                response.imports_for_multiapi(
-                    async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs
-                )
-            )
-        if self.code_model.options["models-mode"]:
-            for exception in self.exceptions:
-                file_import.merge(
-                    exception.imports_for_multiapi(
-                        async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs
-                    )
-                )
-        return file_import
-
     @staticmethod
     def has_kwargs_to_pop_with_default(
-        kwargs_to_pop: List[
+        kwargs_to_pop: list[
             Union[
                 Parameter,
                 RequestBuilderParameter,
@@ -326,7 +281,19 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             return FileImport(self.code_model)
 
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
-        file_import = self._imports_shared(async_mode, **kwargs)
+        file_import = FileImport(self.code_model)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+
+        response_types = [r.type_annotation(async_mode=async_mode, **kwargs) for r in self.responses if r.type]
+        if len(set(response_types)) > 1:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.added_on:
+            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="_validation"),
+                "api_version_validation",
+                ImportType.LOCAL,
+            )
 
         for param in self.parameters.method:
             file_import.merge(
@@ -427,7 +394,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         file_import.add_submodule_import("rest", "HttpRequest", ImportType.SDKCORE)
         file_import.add_submodule_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
             file_import.add_submodule_import(
@@ -438,6 +404,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         file_import.merge(self.get_request_builder_import(self.request_builder, async_mode, serialize_namespace))
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
+        if self.name == "list":
+            # if there is a function named `list` we have to make sure there's no conflict with the built-in `list`
+            # not doing for dict or set yet, though we might have to later
+            file_import.define_mypy_type("List", "list")
         if self.code_model.options["models-mode"] == "dpg":
             relative_path = self.code_model.get_relative_import_path(
                 serialize_namespace, module_name="_utils.model_base"
@@ -479,7 +449,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             raise ValueError(f"Incorrect status code {status_code}, operation {self.name}") from exc
 
     @property
-    def success_status_codes(self) -> List[Union[int, str, List[int]]]:
+    def success_status_codes(self) -> list[Union[int, str, list[int]]]:
         """The list of all successfull status code."""
         return sorted([code for response in self.responses for code in response.status_codes])
 
@@ -499,13 +469,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         return any(r.is_stream_response for r in self.responses)
 
     @classmethod
-    def get_request_builder(cls, yaml_data: Dict[str, Any], client: "Client"):
+    def get_request_builder(cls, yaml_data: dict[str, Any], client: "Client"):
         return client.lookup_request_builder(id(yaml_data))
 
     @classmethod
     def from_yaml(
         cls,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
     ):
@@ -548,7 +518,7 @@ class Operation(OperationBase[Response]):
         return file_import
 
 
-def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client") -> "OperationType":
+def get_operation(yaml_data: dict[str, Any], code_model: "CodeModel", client: "Client") -> "OperationType":
     if yaml_data["discriminator"] == "lropaging":
         from .lro_paging_operation import LROPagingOperation as OperationCls
     elif yaml_data["discriminator"] == "lro":