@autorest/python 6.38.1 → 6.39.0

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

@@ -5,8 +5,6 @@
 # --------------------------------------------------------------------------
 import logging
 from typing import (
-    List,
-    Dict,
     Any,
     Generic,
     TypeVar,
@@ -52,7 +50,7 @@ class BaseBuilder(
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
         name: str,
@@ -70,9 +68,9 @@ class BaseBuilder(
         self.want_tracing: bool = yaml_data.get("wantTracing", True)
         self.group_name: str = yaml_data["groupName"]  # either operationGroup or client I am on
         self.is_overload: bool = yaml_data["isOverload"]
-        self.api_versions: List[str] = yaml_data["apiVersions"]
+        self.api_versions: list[str] = yaml_data["apiVersions"]
         self.added_on: Optional[str] = yaml_data.get("addedOn")
-        self.external_docs: Optional[Dict[str, Any]] = yaml_data.get("externalDocs")
+        self.external_docs: Optional[dict[str, Any]] = yaml_data.get("externalDocs")
         self.client_namespace: str = yaml_data.get("clientNamespace", code_model.namespace)
 
         if code_model.options["version-tolerant"] and yaml_data.get("abstract"):
@@ -114,7 +112,7 @@ class BaseBuilder(
             )
         return self._description or self.name
 
-    def method_signature(self, async_mode: bool, **kwargs: Any) -> List[str]:
+    def method_signature(self, async_mode: bool, **kwargs: Any) -> list[str]:
         if self.abstract:
             return ["*args,", "**kwargs"]
         return self.parameters.method_signature(async_mode, **kwargs)

package/generator/pygen/codegen/models/client.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, TYPE_CHECKING, TypeVar, Generic, Union, List, Optional
+from typing import Any, TYPE_CHECKING, TypeVar, Generic, Union, Optional
 
 from .base import BaseModel
 from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
@@ -35,7 +35,7 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         parameters: ParameterListType,
     ):
@@ -54,19 +54,19 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
         return self.yaml_data["name"]
 
 
-class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=too-many-public-methods
+class Client(_ClientConfigBase[ClientGlobalParameterList]):
     """Model representing our service client"""
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         parameters: ClientGlobalParameterList,
         *,
         is_subclient: bool = False,
     ):
         super().__init__(yaml_data, code_model, parameters)
-        self.operation_groups: List[OperationGroup] = []
+        self.operation_groups: list[OperationGroup] = []
         self.config = Config.from_yaml(yaml_data, self.code_model)
         self.is_subclient = is_subclient
         self.request_builders = self._build_request_builders()
@@ -81,12 +81,18 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
 
         # update the host parameter value. In later logic, SDK will overwrite it
         # with value from cloud_setting if users don't provide it.
-        if self.need_cloud_setting:
-            for p in self.parameters.parameters:
-                if p.location == ParameterLocation.ENDPOINT_PATH:
-                    p.client_default_value = None
-                    p.optional = True
-                    break
+        if self.code_model.options.get("azure-arm"):
+            if self.need_cloud_setting:
+                for p in self.parameters.parameters:
+                    if p.location == ParameterLocation.ENDPOINT_PATH:
+                        p.client_default_value = None
+                        p.optional = True
+                        break
+            else:
+                for idx, p in enumerate(self.parameters.parameters):
+                    if p.client_name == "cloud_setting":
+                        self.parameters.parameters.pop(idx)
+                        break
 
     @property
     def need_cloud_setting(self) -> bool:
@@ -102,10 +108,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
 
     def _build_request_builders(
         self,
-    ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
-        request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
+    ) -> list[Union[RequestBuilder, OverloadedRequestBuilder]]:
+        request_builders: list[Union[RequestBuilder, OverloadedRequestBuilder]] = []
 
-        def add_og_request_builder(og: Dict[str, Any]):
+        def add_og_request_builder(og: dict[str, Any]):
             for operation_yaml in og["operations"]:
                 request_builder = get_request_builder(
                     operation_yaml,
@@ -203,7 +209,43 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
         except StopIteration as exc:
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
-    def _imports_shared(self, async_mode: bool, **kwargs) -> FileImport:
+    @property
+    def has_mixin(self) -> bool:
+        """Do we want a mixin ABC class for typing purposes?"""
+        return any(og for og in self.operation_groups if og.is_mixin)
+
+    @property
+    def lro_operations(self) -> list["OperationType"]:
+        """all LRO operations in this SDK?"""
+        return [operation for operation_group in self.operation_groups for operation in operation_group.lro_operations]
+
+    @property
+    def has_public_lro_operations(self) -> bool:
+        """Are there any public LRO operations in this SDK?"""
+        return any(not operation.internal for operation in self.lro_operations)
+
+    @property
+    def has_operations(self) -> bool:
+        return any(operation_group.has_operations for operation_group in self.operation_groups)
+
+    def link_lro_initial_operations(self) -> None:
+        """Link each LRO operation to its initial operation"""
+        for operation_group in self.operation_groups:
+            for operation in operation_group.operations:
+                if isinstance(operation, (LROOperation, LROPagingOperation)):
+                    operation.initial_operation = self.lookup_operation(id(operation.yaml_data["initialOperation"]))
+
+    @property
+    def has_abstract_operations(self) -> bool:
+        """Whether there is abstract operation in any operation group."""
+        return any(og.has_abstract_operations for og in self.operation_groups)
+
+    @property
+    def has_non_abstract_operations(self) -> bool:
+        """Whether there is non-abstract operation in any operation group."""
+        return any(og.has_non_abstract_operations for og in self.operation_groups)
+
+    def imports(self, async_mode: bool, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.code_model.options["azure-arm"]:
@@ -259,46 +301,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
             file_import.add_submodule_import("azure.core.settings", "settings", ImportType.SDKCORE)
             file_import.add_submodule_import("azure.mgmt.core.tools", "get_arm_endpoints", ImportType.SDKCORE)
-        return file_import
-
-    @property
-    def has_mixin(self) -> bool:
-        """Do we want a mixin ABC class for typing purposes?"""
-        return any(og for og in self.operation_groups if og.is_mixin)
-
-    @property
-    def lro_operations(self) -> List["OperationType"]:
-        """all LRO operations in this SDK?"""
-        return [operation for operation_group in self.operation_groups for operation in operation_group.lro_operations]
-
-    @property
-    def has_public_lro_operations(self) -> bool:
-        """Are there any public LRO operations in this SDK?"""
-        return any(not operation.internal for operation in self.lro_operations)
-
-    @property
-    def has_operations(self) -> bool:
-        return any(operation_group.has_operations for operation_group in self.operation_groups)
-
-    def link_lro_initial_operations(self) -> None:
-        """Link each LRO operation to its initial operation"""
-        for operation_group in self.operation_groups:
-            for operation in operation_group.operations:
-                if isinstance(operation, (LROOperation, LROPagingOperation)):
-                    operation.initial_operation = self.lookup_operation(id(operation.yaml_data["initialOperation"]))
-
-    @property
-    def has_abstract_operations(self) -> bool:
-        """Whether there is abstract operation in any operation group."""
-        return any(og.has_abstract_operations for og in self.operation_groups)
-
-    @property
-    def has_non_abstract_operations(self) -> bool:
-        """Whether there is non-abstract operation in any operation group."""
-        return any(og.has_non_abstract_operations for og in self.operation_groups)
-
-    def imports(self, async_mode: bool, **kwargs) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
         if async_mode:
             file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
             file_import.add_submodule_import(
@@ -334,32 +336,11 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
         if self.code_model.model_types and self.code_model.options["models-mode"] == "msrest":
             path_to_models = ".." if async_mode else "."
             file_import.add_submodule_import(path_to_models, "models", ImportType.LOCAL, alias="_models")
-        elif self.code_model.options["models-mode"] == "msrest":
-            # in this case, we have client_models = {} in the service client, which needs a type annotation
-            # this import will always be commented, so will always add it to the typing section
-            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
         file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        try:
-            mixin_operation = next(og for og in self.operation_groups if og.is_mixin)
-            file_import.add_submodule_import("._operations_mixin", mixin_operation.class_name, ImportType.LOCAL)
-        except StopIteration:
-            pass
-        file_import.add_submodule_import("azure.profiles", "KnownProfiles", import_type=ImportType.SDKCORE)
-        file_import.add_submodule_import("azure.profiles", "ProfileDefinition", import_type=ImportType.SDKCORE)
-        file_import.add_submodule_import(
-            "azure.profiles.multiapiclient",
-            "MultiApiClientMixin",
-            import_type=ImportType.SDKCORE,
-        )
-        return file_import
-
     @property
-    def credential_scopes(self) -> Optional[List[str]]:
+    def credential_scopes(self) -> Optional[list[str]]:
         """Credential scopes for this client"""
 
         if self.credential:
@@ -373,7 +354,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):  # pylint: disable=t
     @classmethod
     def from_yaml(
         cls,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         *,
         is_subclient: bool = False,
@@ -413,7 +394,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
     def name(self) -> str:
         return f"{super().name}Configuration"
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def imports(self, async_mode: bool, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "pipeline" if self.code_model.is_azure_flavor else "runtime",
@@ -432,11 +413,6 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
             file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.SDKCORE)
             file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.SDKCORE)
-
-        return file_import
-
-    def imports(self, async_mode: bool, **kwargs) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
         for gp in self.parameters:
             if gp.method_location == ParameterMethodLocation.KWARG and gp not in self.parameters.kwargs_to_pop:
                 continue
@@ -448,25 +424,8 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             )
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
-        for gp in self.parameters:
-            if (
-                gp.method_location == ParameterMethodLocation.KWARG
-                and gp not in self.parameters.kwargs_to_pop
-                and gp.client_name == "api_version"
-            ):
-                continue
-            file_import.merge(
-                gp.imports_for_multiapi(
-                    async_mode=async_mode,
-                    **kwargs,
-                )
-            )
-        return file_import
-
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Config":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "Config":
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,

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