@autorest/python 6.38.2 → 6.39.0

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

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 import datetime
 import decimal
-from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
+from typing import Any, Optional, Union, TYPE_CHECKING
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
@@ -61,7 +61,7 @@ class BooleanType(PrimitiveType):
 
 
 class BinaryType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
@@ -176,7 +176,7 @@ class AnyObjectType(PrimitiveType):
 
 
 class NumberType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision: Optional[int] = yaml_data.get("precision")
         self.multiple: Optional[int] = yaml_data.get("multipleOf")
@@ -186,7 +186,7 @@ class NumberType(PrimitiveType):
         self.exclusive_minimum: Optional[int] = yaml_data.get("exclusiveMinimum")
 
     @property
-    def serialization_constraints(self) -> List[str]:
+    def serialization_constraints(self) -> list[str]:
         validation_constraints = [
             (f"maximum_ex={self.maximum}" if self.maximum is not None and self.exclusive_maximum else None),
             (f"maximum={self.maximum}" if self.maximum is not None and not self.exclusive_maximum else None),
@@ -197,8 +197,8 @@ class NumberType(PrimitiveType):
         return [x for x in validation_constraints if x is not None]
 
     @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.maximum is not None:
             if self.exclusive_maximum:
                 validation["maximum_ex"] = self.maximum
@@ -221,7 +221,7 @@ class NumberType(PrimitiveType):
 
 class IntegerType(NumberType):
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         if yaml_data.get("encode") == "string":
             self.encode = "str"
@@ -294,7 +294,7 @@ class DecimalType(NumberType):
 
 
 class StringType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length: Optional[int] = yaml_data.get("maxLength")
         self.min_length: Optional[int] = (
@@ -303,7 +303,7 @@ class StringType(PrimitiveType):
         self.pattern: Optional[str] = yaml_data.get("pattern")
 
     @property
-    def serialization_constraints(self) -> List[str]:
+    def serialization_constraints(self) -> list[str]:
         validation_constraints = [
             f"max_length={self.max_length}" if self.max_length is not None else None,
             f"min_length={self.min_length}" if self.min_length is not None else None,
@@ -312,8 +312,8 @@ class StringType(PrimitiveType):
         return [x for x in validation_constraints if x is not None]
 
     @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_length is not None:
             validation["max_length"] = self.max_length
         if self.min_length is not None:
@@ -338,7 +338,7 @@ class StringType(PrimitiveType):
 
 
 class DatetimeType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = (
             "rfc3339"
@@ -564,7 +564,7 @@ class DurationType(PrimitiveType):
 
 
 class ByteArraySchema(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = yaml_data.get("encode", "base64")
 
@@ -585,20 +585,26 @@ class ByteArraySchema(PrimitiveType):
 
 
 class SdkCoreType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = yaml_data.get("name", "")
         self.submodule = yaml_data.get("submodule", "")
+        self.is_typing_only = yaml_data.get("isTypingOnly", False)
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.core_library}.{self.type_annotation(**kwargs)}"
+        return f"~{self.code_model.core_library}.{self.name}"
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return self.name
+        return f'"{self.name}"' if self.is_typing_only else self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
-        file_import.add_submodule_import(self.submodule, self.name, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            self.submodule,
+            self.name,
+            ImportType.SDKCORE,
+            typing_section=TypingSection.TYPING if self.is_typing_only else TypingSection.REGULAR,
+        )
         return file_import
 
     @property
@@ -610,7 +616,7 @@ class SdkCoreType(PrimitiveType):
 
 
 class MultiPartFileType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = "FileType"
 

package/generator/pygen/codegen/models/property.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, TYPE_CHECKING, List, cast, Union
+from typing import Any, Optional, TYPE_CHECKING, cast, Union
 
 from .base import BaseModel
 from .constant_type import ConstantType
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -30,13 +30,13 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.type = type
         self.optional: bool = self.yaml_data["optional"]
         self.readonly: bool = self.yaml_data.get("readonly", False)
-        self.visibility: List[str] = self.yaml_data.get("visibility", [])
+        self.visibility: list[str] = self.yaml_data.get("visibility", [])
         self.is_polymorphic: bool = self.yaml_data.get("isPolymorphic", False)
         self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
         self.client_default_value = yaml_data.get("clientDefaultValue", None)
         if self.client_default_value is None:
             self.client_default_value = self.type.client_default_value
-        self.flattened_names: List[str] = yaml_data.get("flattenedNames", [])
+        self.flattened_names: list[str] = yaml_data.get("flattenedNames", [])
         self.is_multipart_file_input: bool = yaml_data.get("isMultipartFileInput", False)
         self.flatten = self.yaml_data.get("flatten", False) and not getattr(self.type, "flattened_property", False)
 
@@ -101,7 +101,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
 
     @property
-    def xml_metadata(self) -> Optional[Dict[str, Union[str, bool]]]:
+    def xml_metadata(self) -> Optional[dict[str, Union[str, bool]]]:
         return self.yaml_data.get("xmlMetadata")
 
     def type_annotation(self, *, is_operation_file: bool = False, **kwargs: Any) -> str:
@@ -127,22 +127,22 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             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:
         from .model_type import ModelType
 
         if isinstance(self.type, ModelType):
             self.type.get_polymorphic_subtypes(polymorphic_subtypes)
 
     @property
-    def validation(self) -> Optional[Dict[str, Any]]:
-        retval: Dict[str, Any] = {}
+    def validation(self) -> Optional[dict[str, Any]]:
+        retval: dict[str, Any] = {}
         if not self.optional:
             retval["required"] = True
         if self.readonly:
             retval["readonly"] = True
         if self.constant:
             retval["constant"] = True
-        retval.update(self.type.validation or {})
+        retval |= self.type.validation or {}
         return retval or None
 
     def imports(self, **kwargs) -> FileImport:
@@ -164,7 +164,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     @classmethod
     def from_yaml(
         cls,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
     ) -> "Property":
         from . import build_type  # pylint: disable=import-outside-toplevel

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

@@ -6,7 +6,6 @@
 from typing import (
     Any,
     Callable,
-    Dict,
     TypeVar,
     TYPE_CHECKING,
     Union,
@@ -38,7 +37,7 @@ ParameterListType = TypeVar(
 class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder"]]):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
         name: str,
@@ -116,13 +115,13 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
 
     @staticmethod
     @abstractmethod
-    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], ParameterListType]: ...
+    def parameter_list_type() -> Callable[[dict[str, Any], "CodeModel"], ParameterListType]: ...
 
     @classmethod
     def get_name(
         cls,
         name: str,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
     ) -> str:
@@ -140,7 +139,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
     @classmethod
     def from_yaml(
         cls,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
     ):
@@ -165,18 +164,18 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
 
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]:
+    def parameter_list_type() -> Callable[[dict[str, Any], "CodeModel"], RequestBuilderParameterList]:
         return RequestBuilderParameterList.from_yaml
 
 
 class OverloadedRequestBuilder(RequestBuilderBase[OverloadedRequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]:
+    def parameter_list_type() -> Callable[[dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]:
         return OverloadedRequestBuilderParameterList.from_yaml
 
 
 def get_request_builder(
-    yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client"
+    yaml_data: dict[str, Any], code_model: "CodeModel", client: "Client"
 ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
     if yaml_data.get("overloads"):
         return OverloadedRequestBuilder.from_yaml(yaml_data, code_model, client)

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any
 from .parameter import (
     ParameterLocation,
     ParameterMethodLocation,
@@ -52,7 +52,7 @@ class RequestBuilderBodyParameter(BodyParameter):
         )
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "RequestBuilderBodyParameter":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "RequestBuilderBodyParameter":
         return super().from_yaml(yaml_data, code_model)  # type: ignore
 
     @property
@@ -67,7 +67,7 @@ class RequestBuilderParameter(Parameter):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, Optional, List, Any, TYPE_CHECKING, Union
+from typing import Optional, Any, TYPE_CHECKING, Union
 
 from .base import BaseModel
 from .base import BaseType
@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 class ResponseHeader(BaseModel):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -33,7 +33,7 @@ class ResponseHeader(BaseModel):
         return self.type.serialization_type(**kwargs)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ResponseHeader":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "ResponseHeader":
         from . import build_type
 
         return cls(
@@ -46,14 +46,14 @@ class ResponseHeader(BaseModel):
 class Response(BaseModel):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         *,
-        headers: Optional[List[ResponseHeader]] = None,
+        headers: Optional[list[ResponseHeader]] = None,
         type: Optional[BaseType] = None,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.status_codes: List[Union[int, str, List[int]]] = yaml_data["statusCodes"]
+        self.status_codes: list[Union[int, str, list[int]]] = yaml_data["statusCodes"]
         self.headers = headers or []
         self.type = type
         self.nullable = yaml_data.get("nullable")
@@ -66,7 +66,7 @@ class Response(BaseModel):
             return "".join([f'.get("{field}", {{}})' for field in field.split(".")])
         return ""
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         if self.type:
             self.type.get_polymorphic_subtypes(polymorphic_subtypes)
 
@@ -111,7 +111,7 @@ class Response(BaseModel):
             return f"{self.type.docstring_type(**kwargs)} or None"
         return self.type.docstring_type(**kwargs) if self.type else "None"
 
-    def _imports_shared(self, **kwargs: Any) -> FileImport:
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         if self.type:
             file_import.merge(self.type.imports(**kwargs))
@@ -127,12 +127,6 @@ class Response(BaseModel):
             )
         return file_import
 
-    def imports(self, **kwargs: Any) -> FileImport:
-        return self._imports_shared(**kwargs)
-
-    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
-        return self._imports_shared(**kwargs)
-
     def _get_import_type(self, input_path: str) -> ImportType:
         # helper function to return imports for responses based off
         # of whether we're importing from the core library, or users
@@ -140,7 +134,7 @@ class Response(BaseModel):
         return ImportType.SDKCORE if self.code_model.core_library.split(".")[0] in input_path else ImportType.THIRDPARTY
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Response":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "Response":
         type = code_model.lookup_type(id(yaml_data["type"])) if yaml_data.get("type") else None
         # use ByteIteratorType if we are returning a binary type
         default_content_type = yaml_data.get("defaultContentType", "application/json")
@@ -170,7 +164,7 @@ class PagingResponse(Response):
             or f"{self.code_model.core_library}.{default_paging_submodule}.AsyncItemPaged"
         )
 
-    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: list["ModelType"]) -> None:
         return self.item_type.get_polymorphic_subtypes(polymorphic_subtypes)
 
     def get_json_template_representation(self) -> Any:
@@ -198,17 +192,13 @@ class PagingResponse(Response):
     def docstring_type(self, **kwargs: Any) -> str:
         return f"~{self.get_pager_path(kwargs['async_mode'])}[{self.item_type.docstring_type(**kwargs)}]"
 
-    def _imports_shared(self, **kwargs: Any) -> FileImport:
-        file_import = super()._imports_shared(**kwargs)
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
         async_mode = kwargs.get("async_mode", False)
         pager = self.get_pager(async_mode)
         pager_path = self.get_pager_import_path(async_mode)
 
         file_import.add_submodule_import(pager_path, pager, self._get_import_type(pager_path))
-        return file_import
-
-    def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(**kwargs)
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
@@ -219,9 +209,6 @@ class PagingResponse(Response):
 
         return file_import
 
-    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
-        return self._imports_shared(**kwargs)
-
 
 class LROResponse(Response):
     def get_poller_path(self, async_mode: bool) -> str:
@@ -270,16 +257,12 @@ class LROResponse(Response):
             base_description += "either "
         return base_description + super_text
 
-    def _imports_shared(self, **kwargs: Any) -> FileImport:
-        file_import = super()._imports_shared(**kwargs)
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
         async_mode = kwargs["async_mode"]
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
         file_import.add_submodule_import(poller_import_path, poller, self._get_import_type(poller_import_path))
-        return file_import
-
-    def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(**kwargs)
         async_mode = kwargs["async_mode"]
 
         default_polling_method_import_path = ".".join(self.get_polling_method_path(async_mode).split(".")[:-1])
@@ -306,9 +289,6 @@ class LROResponse(Response):
         )
         return file_import
 
-    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
-        return self._imports_shared(**kwargs)
-
 
 class LROPagingResponse(LROResponse, PagingResponse):
     def type_annotation(self, **kwargs: Any) -> str:
@@ -325,18 +305,13 @@ class LROPagingResponse(LROResponse, PagingResponse):
             base_description += "either "
         return base_description + Response.docstring_text(self)
 
-    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
-        file_import = LROResponse.imports_for_multiapi(self, **kwargs)
-        file_import.merge(PagingResponse.imports_for_multiapi(self, **kwargs))
-        return file_import
-
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = LROResponse.imports(self, **kwargs)
         file_import.merge(PagingResponse.imports(self, **kwargs))
         return file_import
 
 
-def get_response(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Response:
+def get_response(yaml_data: dict[str, Any], code_model: "CodeModel") -> Response:
     if yaml_data["discriminator"] == "lropaging":
         return LROPagingResponse.from_yaml(yaml_data, code_model)
     if yaml_data["discriminator"] == "lro":

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

@@ -3,12 +3,12 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import TypeVar, Dict
+from typing import TypeVar
 
 from enum import Enum
 
 T = TypeVar("T")
-OrderedSet = Dict[T, None]
+OrderedSet = dict[T, None]
 
 
 def add_to_description(description: str, entry: str) -> str:

package/generator/pygen/codegen/serializers/__init__.py

@@ -7,7 +7,7 @@ import logging
 import json
 from collections import namedtuple
 import re
-from typing import List, Any, Union, Optional
+from typing import Any, Optional, Union
 from pathlib import Path
 from packaging.version import parse as parse_version
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
@@ -28,7 +28,6 @@ from .model_init_serializer import ModelInitSerializer
 from .model_serializer import DpgModelSerializer, MsrestModelSerializer
 from .operations_init_serializer import OperationsInitSerializer
 from .operation_groups_serializer import OperationGroupsSerializer
-from .metadata_serializer import MetadataSerializer
 from .request_builders_serializer import RequestBuildersSerializer
 from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
@@ -99,7 +98,7 @@ class JinjaSerializer(ReaderAndWriter):
         return self.code_model.options["show-operations"] and bool(self.code_model.has_operations)
 
     @property
-    def serialize_loop(self) -> List[AsyncInfo]:
+    def serialize_loop(self) -> list[AsyncInfo]:
         sync_loop = AsyncInfo(async_mode=False, async_path="")
         async_loop = AsyncInfo(async_mode=True, async_path="aio/")
         return [sync_loop, async_loop] if self.has_aio_folder else [sync_loop]
@@ -149,10 +148,7 @@ class JinjaSerializer(ReaderAndWriter):
                     self._serialize_and_write_package_files()
 
                 # write apiview-properties.json
-                if (
-                    self.code_model.options.get("emit-cross-language-definition-file")
-                    and not self.code_model.options["multiapi"]
-                ):
+                if self.code_model.options.get("emit-cross-language-definition-file"):
                     self.write_file(
                         self._root_of_sdk / Path("apiview-properties.json"),
                         general_serializer.serialize_cross_language_definition_file(),
@@ -208,8 +204,6 @@ class JinjaSerializer(ReaderAndWriter):
                 self._serialize_and_write_operations_folder(
                     client_namespace_type.operation_groups, env=env, namespace=client_namespace
                 )
-                if self.code_model.options["multiapi"]:
-                    self._serialize_and_write_metadata(env=env, namespace=client_namespace)
 
             # if there are only operations under this namespace, we need to add general __init__.py into `aio` folder
             # to make sure all generated files could be packed into .zip/.whl/.tgz package
@@ -256,15 +250,15 @@ class JinjaSerializer(ReaderAndWriter):
             if not self.code_model.is_azure_flavor and template_name == "dev_requirements.txt.jinja2":
                 continue
             file = template_name.replace(".jinja2", "")
-            output_name = root_of_sdk / file
-            if not self.read_file(output_name) or file in _REGENERATE_FILES:
+            output_file = root_of_sdk / file
+            if not self.read_file(output_file) or file in _REGENERATE_FILES:
                 if self.keep_version_file and file == "setup.py" and not self.code_model.options["azure-arm"]:
                     # don't regenerate setup.py file if the version file is more up to date for data-plane
                     continue
-                file_path = self.get_output_folder() / Path(output_name)
+                file_content = self.read_file(output_file) if file == "pyproject.toml" else ""
                 self.write_file(
-                    output_name,
-                    serializer.serialize_package_file(template_name, file_path, **params),
+                    output_file,
+                    serializer.serialize_package_file(template_name, file_content, **params),
                 )
 
     def _keep_patch_file(self, path_file: Path, env: Environment):
@@ -277,7 +271,7 @@ class JinjaSerializer(ReaderAndWriter):
             )
 
     def _serialize_and_write_models_folder(
-        self, env: Environment, namespace: str, models: List[ModelType], enums: List[EnumType]
+        self, env: Environment, namespace: str, models: list[ModelType], enums: list[EnumType]
     ) -> None:
         # Write the models folder
         models_path = self.code_model.get_generation_dir(namespace) / "models"
@@ -320,7 +314,7 @@ class JinjaSerializer(ReaderAndWriter):
         self,
         env: Environment,
         rest_path: Path,
-        request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]],
+        request_builders: list[Union[RequestBuilder, OverloadedRequestBuilder]],
     ) -> None:
         group_name = request_builders[0].group_name
         output_path = rest_path / Path(group_name) if group_name else rest_path
@@ -345,7 +339,7 @@ class JinjaSerializer(ReaderAndWriter):
         )
 
     def _serialize_and_write_operations_folder(
-        self, operation_groups: List[OperationGroup], env: Environment, namespace: str
+        self, operation_groups: list[OperationGroup], env: Environment, namespace: str
     ) -> None:
         operations_folder_name = self.code_model.operations_folder_name(namespace)
         generation_path = self.code_model.get_generation_dir(namespace)
@@ -414,7 +408,7 @@ class JinjaSerializer(ReaderAndWriter):
     def _serialize_client_and_config_files(
         self,
         namespace: str,
-        clients: List[Client],
+        clients: list[Client],
         env: Environment,
     ) -> None:
         generation_path = self.code_model.get_generation_dir(namespace)
@@ -491,11 +485,7 @@ class JinjaSerializer(ReaderAndWriter):
 
         # write the empty py.typed file
         pytyped_value = "# Marker file for PEP 561."
-        # TODO: remove this when we remove legacy multiapi generation
-        if self.code_model.options["multiapi"]:
-            self.write_file(self.code_model.get_generation_dir(namespace) / Path("py.typed"), pytyped_value)
-        else:
-            self.write_file(root_dir / Path("py.typed"), pytyped_value)
+        self.write_file(root_dir / Path("py.typed"), pytyped_value)
 
         # write _validation.py
         if any(og for client in self.code_model.clients for og in client.operation_groups if og.need_validation):
@@ -511,22 +501,16 @@ class JinjaSerializer(ReaderAndWriter):
                 TypesSerializer(code_model=self.code_model, env=env).serialize(),
             )
 
-    def _serialize_and_write_metadata(self, env: Environment, namespace: str) -> None:
-        metadata_serializer = MetadataSerializer(self.code_model, env)
-        self.write_file(
-            self.code_model.get_generation_dir(namespace) / Path("_metadata.json"), metadata_serializer.serialize()
-        )
-
     # pylint: disable=line-too-long
     @property
     def sample_additional_folder(self) -> Path:
         # For special package, we need to additional folder when generate samples.
-        # For example, azure-mgmt-resource is combined by multiple modules, and each module is multiapi package.
+        # For example, azure-mgmt-resource is combined by multiple modules, and each module is a package.
         # one of namespace is "azure.mgmt.resource.resources.v2020_01_01", then additional folder is "resources"
         # so that we could avoid conflict when generate samples.
         # python config: https://github.com/Azure/azure-rest-api-specs/blob/main/specification/resources/resource-manager/readme.python.md
         # generated SDK: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/resources/azure-mgmt-resource/generated_samples
-        namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
+        namespace_config = get_namespace_config(self.code_model.namespace)
         num_of_namespace = namespace_config.count(".") + 1
         num_of_package_namespace = (
             get_namespace_from_package_name(self.code_model.options.get("package-name", "")).count(".") + 1
@@ -540,11 +524,6 @@ class JinjaSerializer(ReaderAndWriter):
         for client in self.code_model.clients:
             for op_group in client.operation_groups:
                 for operation in op_group.operations:
-                    if (
-                        self.code_model.options["multiapi"]
-                        and operation.api_versions[0] != self.code_model.options["default-api-version"]
-                    ):
-                        continue
                     samples = operation.yaml_data.get("samples")
                     if not samples or operation.name.startswith("_"):
                         continue
@@ -584,10 +563,6 @@ class JinjaSerializer(ReaderAndWriter):
 
         for client in self.code_model.clients:
             for og in client.operation_groups:
-                if self.code_model.options["multiapi"] and any(
-                    o.api_versions[0] != self.code_model.options["default-api-version"] for o in og.operations
-                ):
-                    continue
                 test_serializer = TestSerializer(self.code_model, env, client=client, operation_group=og)
                 for async_mode in (True, False):
                     try: