@autorest/python 6.38.2 → 6.39.0

package/generator/build/lib/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/build/lib/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/build/lib/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/build/lib/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":

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, List, Any, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from .utils import OrderedSet
 
@@ -26,11 +26,11 @@ class OperationGroup(BaseModel):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
-        operations: List["OperationType"],
-        api_versions: List[str],
+        operations: list["OperationType"],
+        api_versions: list[str],
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.client = client
@@ -38,7 +38,7 @@ class OperationGroup(BaseModel):
         self.property_name: str = yaml_data["propertyName"]
         self.operations = operations
         self.api_versions = api_versions
-        self.operation_groups: List[OperationGroup] = []
+        self.operation_groups: list[OperationGroup] = []
         if self.code_model.options["show-operations"]:
             self.operation_groups = [
                 OperationGroup.from_yaml(op_group, code_model, client)
@@ -53,7 +53,7 @@ class OperationGroup(BaseModel):
     @property
     def class_name(self) -> str:
         """The class name of the operation group."""
-        if self.is_mixin and not self.code_model.options["multiapi"]:
+        if self.is_mixin:
             return "_" + self.yaml_data["className"]
         return self.yaml_data["className"]
 
@@ -73,22 +73,11 @@ class OperationGroup(BaseModel):
         pipeline_client = (
             f"{'Async' if async_mode else ''}PipelineClient[HttpRequest, {'Async' if async_mode else ''}HttpResponse]"
         )
-        base_classes: List[str] = []
+        base_classes: list[str] = []
         if self.is_mixin:
             base_classes.append(f"ClientMixinABC[{pipeline_client}, {self.client.name}Configuration]")
         return ", ".join(base_classes)
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
-        file_import = FileImport(self.code_model)
-        relative_path = ".." if async_mode else "."
-        for operation in self.operations:
-            file_import.merge(operation.imports_for_multiapi(async_mode, **kwargs))
-        if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
-            "models-mode"
-        ] == "msrest":
-            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
-        return file_import
-
     def pylint_disable(self) -> str:
         retval: str = ""
         if self.has_abstract_operations:
@@ -141,7 +130,7 @@ class OperationGroup(BaseModel):
                         og.class_name,
                         ImportType.LOCAL,
                     )
-        # for multiapi
+        # shared code for imports
         if (
             (self.code_model.public_model_types)
             and self.code_model.options["models-mode"] == "msrest"
@@ -206,7 +195,7 @@ class OperationGroup(BaseModel):
             return file_import
         file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.define_mypy_type("T", "TypeVar('T')")
-        type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
+        type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, dict[str, Any]], Any]]"
         file_import.define_mypy_type("ClsType", type_value.format(""), type_value.format("Async"))
         return file_import
 
@@ -233,7 +222,7 @@ class OperationGroup(BaseModel):
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
     @property
-    def lro_operations(self) -> List["OperationType"]:
+    def lro_operations(self) -> list["OperationType"]:
         return [operation for operation in self.operations if operation.operation_type in ("lro", "lropaging")] + [
             operation for operation_group in self.operation_groups for operation in operation_group.lro_operations
         ]
@@ -250,7 +239,7 @@ class OperationGroup(BaseModel):
     @classmethod
     def from_yaml(
         cls,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
     ) -> "OperationGroup":

package/generator/build/lib/pygen/codegen/models/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 Dict, List, Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
+from typing import Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
 
 from .operation import Operation, OperationBase
 from .response import PagingResponse, LROPagingResponse, Response
@@ -28,16 +28,16 @@ PagingResponseType = TypeVar("PagingResponseType", bound=Union[PagingResponse, L
 class PagingOperationBase(OperationBase[PagingResponseType]):
     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[PagingResponseType],
-        exceptions: List[Response],
+        responses: list[PagingResponseType],
+        exceptions: list[Response],
         *,
-        overloads: Optional[List[Operation]] = None,
+        overloads: Optional[list[Operation]] = None,
         override_success_response_to_200: bool = False,
     ) -> None:
         super().__init__(
@@ -59,8 +59,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.override_success_response_to_200 = override_success_response_to_200
         self.pager_sync: str = yaml_data.get("pagerSync") or f"{self.code_model.core_library}.paging.ItemPaged"
         self.pager_async: str = yaml_data.get("pagerAsync") or f"{self.code_model.core_library}.paging.AsyncItemPaged"
-        self.continuation_token: Dict[str, Any] = yaml_data.get("continuationToken", {})
-        self.next_link_reinjected_parameters: List[Parameter] = [
+        self.continuation_token: dict[str, Any] = yaml_data.get("continuationToken", {})
+        self.next_link_reinjected_parameters: list[Parameter] = [
             Parameter.from_yaml(p, code_model) for p in yaml_data.get("nextLinkReInjectedParameters", [])
         ]
 
@@ -119,8 +119,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
         return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode, **kwargs)}]"
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = super()._imports_shared(async_mode, **kwargs)
+    @property
+    def has_optional_return_type(self) -> bool:
+        return False
+
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport(self.code_model)
+        file_import = super().imports(async_mode, **kwargs)
         if async_mode:
             default_paging_submodule = f"{'async_' if self.code_model.is_azure_flavor else ''}paging"
             file_import.add_submodule_import(
@@ -139,16 +145,6 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports(**kwargs))
-        return file_import
-
-    @property
-    def has_optional_return_type(self) -> bool:
-        return False
-
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        if self.abstract:
-            return FileImport(self.code_model)
-        file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         if self.code_model.options["tracing"] and self.want_tracing:

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

@@ -7,10 +7,8 @@ import abc
 from enum import Enum
 
 from typing import (
-    Dict,
     Any,
     TYPE_CHECKING,
-    List,
     Optional,
     TypeVar,
     Union,
@@ -35,6 +33,7 @@ class ParameterLocation(str, Enum):
     ENDPOINT_PATH = "endpointPath"
     QUERY = "query"
     BODY = "body"
+    KEYWORD = "keyword"
     OTHER = "other"
 
 
@@ -56,7 +55,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -75,13 +74,13 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         self.grouped_by: Optional[str] = self.yaml_data.get("groupedBy")
         # property matching property name to parameter name for grouping params
         # and flattened body params
-        self.property_to_parameter_name: Optional[Dict[str, str]] = self.yaml_data.get("propertyToParameterName")
+        self.property_to_parameter_name: Optional[dict[str, str]] = self.yaml_data.get("propertyToParameterName")
         self.flattened: bool = self.yaml_data.get("flattened", False)
         self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
         self.grouper: bool = self.yaml_data.get("grouper", False)
         self.check_client_input: bool = self.yaml_data.get("checkClientInput", False)
         self.added_on: Optional[str] = self.yaml_data.get("addedOn")
-        self.api_versions: Optional[List[str]] = self.yaml_data.get("apiVersions", [])
+        self.api_versions: Optional[list[str]] = self.yaml_data.get("apiVersions", [])
         self.is_api_version: bool = self.yaml_data.get("isApiVersion", False)
         self.in_overload: bool = self.yaml_data.get("inOverload", False)
         self.default_to_unset_sentinel: bool = self.yaml_data.get("defaultToUnsetSentinel", False)
@@ -160,7 +159,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
     def serialization_type(self, **kwargs: Any) -> str:
         return self.type.serialization_type(**kwargs)
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
@@ -178,10 +177,6 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
                 ImportType.LOCAL,
                 TypingSection.TYPING,
             )
-        return file_import
-
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
         # special logic for api-version parameter
         if not self.is_api_version:
             file_import.merge(self.type.imports(async_mode=async_mode, **kwargs))
@@ -193,11 +188,6 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
             )
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(self.type.imports_for_multiapi(async_mode=async_mode, **kwargs))
-        return file_import
-
     @property
     def method_location(self) -> ParameterMethodLocation:
         raise NotImplementedError("Please implement in children")
@@ -227,7 +217,7 @@ class BodyParameter(_ParameterBase):
     """Body parameter."""
 
     @property
-    def entries(self) -> List["BodyParameter"]:
+    def entries(self) -> list["BodyParameter"]:
         return [BodyParameter.from_yaml(e, self.code_model) for e in self.yaml_data.get("entries", [])]
 
     @property
@@ -258,7 +248,7 @@ class BodyParameter(_ParameterBase):
         return not (self.flattened or self.grouped_by)
 
     @property
-    def content_types(self) -> List[str]:
+    def content_types(self) -> list[str]:
         return self.yaml_data["contentTypes"]
 
     @property
@@ -280,11 +270,10 @@ class BodyParameter(_ParameterBase):
                 "prepare_multipart_form_data",
                 ImportType.LOCAL,
             )
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BodyParameter":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "BodyParameter":
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
@@ -300,7 +289,7 @@ class Parameter(_ParameterBase):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -364,7 +353,7 @@ class Parameter(_ParameterBase):
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel"):
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
@@ -396,6 +385,8 @@ class ClientParameter(Parameter):
             and not self.code_model.options["azure-arm"]
         ):
             return ParameterMethodLocation.KEYWORD_ONLY
+        if self.location == ParameterLocation.KEYWORD:
+            return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL