@autorest/python 6.1.11 → 6.2.1

package/autorest/codegen/models/imports.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum, auto
-from typing import Dict, List, Optional, Tuple, Union, Set, Mapping, TYPE_CHECKING
+from typing import Dict, List, Optional, Tuple, Union, Set, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -15,6 +15,7 @@ class ImportType(str, Enum):
     THIRDPARTY = "thirdparty"
     AZURECORE = "azurecore"
     LOCAL = "local"
+    BYVERSION = "by_version"
 
 
 class TypingSection(str, Enum):
@@ -42,12 +43,19 @@ class ImportModel:
         *,
         submodule_name: Optional[str] = None,
         alias: 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
         self.module_name = module_name
         self.submodule_name = submodule_name
         self.alias = alias
+        # version_modules: this field is for imports submodule from specified module by python version.
+        #                  It's a list of "python version, module_name, comments".
+        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
+        self.version_modules = version_modules
 
     def __eq__(self, other):
         try:
@@ -74,14 +82,9 @@ class TypeDefinition:
         self,
         sync_definition: str,
         async_definition: str,
-        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
     ):
-        # version_imports: a map of "python version -> ImportModel".
-        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
-        #                  If the python version is None, it's a default ImportModel.
         self.sync_definition = sync_definition
         self.async_definition = async_definition
-        self.version_imports = version_imports
 
 
 class FileImport:
@@ -114,6 +117,9 @@ 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,
     ) -> None:
         """Add an import to this import block."""
         self._append_import(
@@ -123,6 +129,7 @@ class FileImport:
                 module_name=module_name,
                 submodule_name=submodule_name,
                 alias=alias,
+                version_modules=version_modules,
             )
         )
 
@@ -148,10 +155,9 @@ class FileImport:
         type_name: str,
         type_value: str,
         async_type_value: Optional[str] = None,
-        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
     ):
         self.type_definitions[type_name] = TypeDefinition(
-            type_value, async_type_value or type_value, version_imports
+            type_value, async_type_value or type_value
         )
 
     def merge(self, file_import: "FileImport") -> None:
@@ -162,24 +168,18 @@ class FileImport:
 
     def define_mutable_mapping_type(self) -> None:
         """Helper function for defining the mutable mapping type"""
+        self.add_import("sys", ImportType.STDLIB)
+        self.add_submodule_import(
+            "typing",
+            "MutableMapping",
+            ImportType.BYVERSION,
+            TypingSection.REGULAR,
+            None,
+            (((3, 9), "collections.abc", None),),
+        )
         self.define_mypy_type(
             "JSON",
             "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",
-            None,
-            {
-                (3, 9): ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "collections.abc",
-                    submodule_name="MutableMapping",
-                ),
-                None: ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "typing",
-                    submodule_name="MutableMapping",
-                ),
-            },
         )
         self.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
@@ -187,18 +187,67 @@ class FileImport:
         self,
     ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[str, str],
+                            Tuple[
+                                str,
+                                Optional[str],
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]:
         retval: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[str, str],
+                                Tuple[
+                                    str,
+                                    Optional[str],
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = dict()
         for i in self.imports:
-            name_import: Optional[Union[str, Tuple[str, str]]] = None
+            name_import: Optional[
+                Union[
+                    str,
+                    Tuple[str, str],
+                    Tuple[
+                        str,
+                        Optional[str],
+                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                    ],
+                ]
+            ] = None
             if i.submodule_name:
-                name_import = (
-                    (i.submodule_name, i.alias) if i.alias else i.submodule_name
-                )
+                if i.version_modules:
+                    name_import = (i.submodule_name, i.alias, i.version_modules)
+                elif i.alias:
+                    name_import = (i.submodule_name, i.alias)
+                else:
+                    name_import = i.submodule_name
             retval.setdefault(i.typing_section, dict()).setdefault(
                 i.import_type, dict()
             ).setdefault(i.module_name, set()).add(name_import)

package/autorest/codegen/models/list_type.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, Union, TYPE_CHECKING, List
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:

package/autorest/codegen/models/lro_operation.py

@@ -13,6 +13,7 @@ from .parameter_list import ParameterList
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
 
 LROResponseType = TypeVar(
     "LROResponseType", bound=Union[LROResponse, LROPagingResponse]
@@ -24,6 +25,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
@@ -36,6 +38,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
     ) -> None:
         super().__init__(
             code_model=code_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             request_builder=request_builder,
@@ -90,7 +93,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
         return Operation(
             yaml_data=self.yaml_data,
             code_model=self.code_model,
-            request_builder=self.code_model.lookup_request_builder(id(self.yaml_data)),
+            client=self.client,
+            request_builder=self.client.lookup_request_builder(id(self.yaml_data)),
             name=self.name[5:] + "_initial",
             overloads=self.overloads,
             parameters=self.parameters,

package/autorest/codegen/models/model_type.py

@@ -7,7 +7,7 @@ from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 
 from autorest.codegen.models.utils import add_to_pylint_disable
-from .base_type import BaseType
+from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
@@ -284,7 +284,6 @@ class ModelType(
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        file_import.add_import("sys", ImportType.STDLIB)
         file_import.define_mutable_mapping_type()
         if self.is_xml:
             file_import.add_submodule_import(

package/autorest/codegen/models/operation.py

@@ -19,7 +19,6 @@ from typing import (
 from .request_builder_parameter import RequestBuilderParameter
 
 from .utils import OrderedSet, add_to_pylint_disable
-
 from .base_builder import BaseBuilder
 from .imports import FileImport, ImportType, TypingSection
 from .response import (
@@ -41,6 +40,7 @@ from .request_builder import OverloadedRequestBuilder, RequestBuilder
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
 
 ResponseType = TypeVar(
     "ResponseType",
@@ -55,6 +55,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         name: str,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
         parameters: ParameterList,
@@ -67,6 +68,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     ) -> None:
         super().__init__(
             code_model=code_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             parameters=parameters,
@@ -202,13 +204,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         )
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def _imports_shared(
+        self, async_mode: bool, **kwargs: Any  # pylint: disable=unused-argument
+    ) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        for param in self.parameters.method:
-            file_import.merge(param.imports(async_mode, **kwargs))
 
         response_types = [
             r.type_annotation(async_mode=async_mode) for r in self.responses if r.type
@@ -229,6 +231,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.abstract:
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports_for_multiapi(
+                    async_mode,
+                    **kwargs,
+                )
+            )
         for response in self.responses:
             file_import.merge(
                 response.imports_for_multiapi(async_mode=async_mode, **kwargs)
@@ -300,6 +309,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
 
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports(
+                    async_mode,
+                    **kwargs,
+                )
+            )
         for response in self.responses:
             file_import.merge(response.imports(async_mode=async_mode, **kwargs))
         if self.code_model.options["models_mode"]:
@@ -409,7 +425,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         basename = self.group_name
         if basename == "":
             # in a mixin
-            basename = self.code_model.module_name
+            basename = self.code_model.clients[0].legacy_filename
 
         if (
             basename == "operations"
@@ -423,9 +439,14 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         return any(r.is_stream_response for r in self.responses)
 
     @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",
+        client: "Client",
+    ):
         name = yaml_data["name"]
-        request_builder = code_model.lookup_request_builder(id(yaml_data))
+        request_builder = client.lookup_request_builder(id(yaml_data))
         responses = [
             cast(ResponseType, get_response(r, code_model))
             for r in yaml_data["responses"]
@@ -435,13 +456,14 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         ]
         parameter_list = ParameterList.from_yaml(yaml_data, code_model)
         overloads = [
-            cls.from_yaml(overload, code_model)
+            cls.from_yaml(overload, code_model, client)
             for overload in yaml_data.get("overloads", [])
         ]
 
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
+            client=client,
             request_builder=request_builder,
             name=name,
             parameters=parameter_list,
@@ -486,7 +508,9 @@ class Operation(OperationBase[Response]):
         return file_import
 
 
-def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel") -> OperationBase:
+def get_operation(
+    yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client"
+) -> OperationBase:
     if yaml_data["discriminator"] == "lropaging":
         from .lro_paging_operation import LROPagingOperation as OperationCls
     elif yaml_data["discriminator"] == "lro":
@@ -495,4 +519,4 @@ def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Operati
         from .paging_operation import PagingOperation as OperationCls  # type: ignore
     else:
         from . import Operation as OperationCls  # type: ignore
-    return OperationCls.from_yaml(yaml_data, code_model)
+    return OperationCls.from_yaml(yaml_data, code_model, client)

package/autorest/codegen/models/operation_group.py

@@ -7,13 +7,14 @@ from typing import Dict, List, Any, TYPE_CHECKING
 
 from autorest.codegen.models.utils import OrderedSet
 
-from .base_model import BaseModel
+from .base import BaseModel
 from .operation import OperationBase, get_operation
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_pylint_disable
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
 
 
 class OperationGroup(BaseModel):
@@ -23,10 +24,12 @@ class OperationGroup(BaseModel):
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         operations: List[OperationBase],
         api_versions: List[str],
     ) -> None:
         super().__init__(yaml_data, code_model)
+        self.client = client
         self.class_name: str = yaml_data["className"]
         self.property_name: str = yaml_data["propertyName"]
         self.operations = operations
@@ -40,7 +43,7 @@ class OperationGroup(BaseModel):
     def base_class(self) -> str:
         base_classes: List[str] = []
         if self.is_mixin and self.code_model.need_mixin_abc:
-            base_classes.append("MixinABC")
+            base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -87,7 +90,9 @@ class OperationGroup(BaseModel):
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )
         if self.code_model.need_mixin_abc:
-            file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
+            file_import.add_submodule_import(
+                ".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL
+            )
         if self.has_abstract_operations:
             file_import.add_submodule_import(
                 ".._vendor", "raise_if_not_implemented", ImportType.LOCAL
@@ -115,9 +120,14 @@ class OperationGroup(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
     ) -> "OperationGroup":
-        operations = [get_operation(o, code_model) for o in yaml_data["operations"]]
+        operations = [
+            get_operation(o, code_model, client) for o in yaml_data["operations"]
+        ]
         api_versions: OrderedSet[str] = {}
         for operation in operations:
             for api_version in operation.api_versions:
@@ -125,6 +135,7 @@ class OperationGroup(BaseModel):
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
+            client=client,
             operations=operations,
             api_versions=list(api_versions.keys()),
         )

package/autorest/codegen/models/paging_operation.py

@@ -18,6 +18,7 @@ from .model_type import ModelType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
 
 PagingResponseType = TypeVar(
     "PagingResponseType", bound=Union[PagingResponse, LROPagingResponse]
@@ -29,6 +30,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
@@ -42,6 +44,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     ) -> None:
         super().__init__(
             code_model=code_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             request_builder=request_builder,
@@ -55,7 +58,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.next_request_builder: Optional[
             Union[RequestBuilder, OverloadedRequestBuilder]
         ] = (
-            get_request_builder(self.yaml_data["nextOperation"], code_model)
+            get_request_builder(self.yaml_data["nextOperation"], code_model, client)
             if self.yaml_data.get("nextOperation")
             else None
         )
@@ -140,9 +143,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             file_import.merge(
                 self.get_request_builder_import(self.next_request_builder, async_mode)
             )
-        elif "api-version" in [
-            p.rest_api_name for p in self.code_model.client.parameters
-        ]:
+        elif "api-version" in [p.rest_api_name for p in self.client.parameters]:
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/models/parameter.py

@@ -19,8 +19,8 @@ from typing import (
 )
 
 from .imports import FileImport, ImportType
-from .base_model import BaseModel
-from .base_type import BaseType
+from .base import BaseModel
+from .base import BaseType
 from .constant_type import ConstantType
 from .model_type import ModelType
 from .combined_type import CombinedType
@@ -149,11 +149,8 @@ class _ParameterBase(
     def serialization_type(self) -> str:
         return self.type.serialization_type
 
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
         file_import = FileImport()
-        file_import.merge(
-            self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
-        )
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.added_on:
@@ -164,6 +161,22 @@ class _ParameterBase(
             )
         return file_import
 
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+        file_import.merge(
+            self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
+        )
+        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(
+                is_operation_file=True, async_mode=async_mode, **kwargs
+            )
+        )
+        return file_import
+
     @property
     def method_location(self) -> ParameterMethodLocation:
         raise NotImplementedError("Please implement in children")

package/autorest/codegen/models/primitive_types.py

@@ -7,7 +7,7 @@ import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description
 
@@ -197,7 +197,6 @@ class AnyObjectType(PrimitiveType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         file_import.define_mutable_mapping_type()
-        file_import.add_import("sys", ImportType.STDLIB)
         return file_import
 
 

package/autorest/codegen/models/property.py

@@ -5,9 +5,9 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, TYPE_CHECKING, List
 
-from .base_model import BaseModel
+from .base import BaseModel
 from .constant_type import ConstantType
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description, add_to_pylint_disable
 
@@ -125,10 +125,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         retval.update(self.type.validation or {})
         return retval or None
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs) -> FileImport:
         from .model_type import ModelType
 
-        file_import = self.type.imports(is_operation_file=False)
+        file_import = self.type.imports(**kwargs, is_operation_file=False)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, ModelType):

package/autorest/codegen/models/request_builder.py

@@ -24,6 +24,7 @@ from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -36,6 +37,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         name: str,
         parameters: ParameterListType,
         *,
@@ -43,6 +45,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     ) -> None:
         super().__init__(
             code_model=code_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             parameters=parameters,
@@ -122,7 +125,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         ...
 
     @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",
+        client: "Client",
+    ):
         # when combine embedded builders into one operation file, we need to avoid duplicated build function name.
         # So add operation group name is effective method
         additional_mark = ""
@@ -130,7 +138,9 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             code_model.options["combine_operation_files"]
             and code_model.options["builders_visibility"] == "embedded"
         ):
-            additional_mark = yaml_data["groupName"]
+            additional_mark = (
+                yaml_data["groupName"] or client.yaml_data["builderPadName"]
+            )
         names = [
             "build",
             additional_mark,
@@ -139,7 +149,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         ]
         name = "_".join([n for n in names if n])
         overloads = [
-            RequestBuilder.from_yaml(rb_yaml_data, code_model)
+            RequestBuilder.from_yaml(rb_yaml_data, code_model, client)
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
         parameter_list = cls.parameter_list_type()(yaml_data, code_model)
@@ -147,6 +157,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
+            client=client,
             name=name,
             parameters=parameter_list,
             overloads=overloads,
@@ -172,8 +183,8 @@ class OverloadedRequestBuilder(
 
 
 def get_request_builder(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
+    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)
-    return RequestBuilder.from_yaml(yaml_data, code_model)
+        return OverloadedRequestBuilder.from_yaml(yaml_data, code_model, client)
+    return RequestBuilder.from_yaml(yaml_data, code_model, client)

package/autorest/codegen/models/request_builder_parameter.py

@@ -11,7 +11,7 @@ from .parameter import (
     BodyParameter,
     _MultipartBodyParameter,
 )
-from .base_type import BaseType
+from .base import BaseType
 from .primitive_types import BinaryType, StringType
 from .combined_type import CombinedType
 
@@ -93,7 +93,10 @@ class RequestBuilderParameter(Parameter):
     """Basic RequestBuilder Parameter."""
 
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", type: BaseType
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        type: BaseType,
     ) -> None:
         super().__init__(yaml_data, code_model, type)
         # we don't want any default content type behavior in request builder