@autorest/python 6.10.2 → 6.11.1

package/autorest/codegen/models/client.py

@@ -83,8 +83,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         self,
     ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
         request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
-        for og_group in self.yaml_data["operationGroups"]:
-            for operation_yaml in og_group["operations"]:
+
+        def add_og_request_builder(og: Dict[str, Any]):
+            for operation_yaml in og["operations"]:
                 request_builder = get_request_builder(
                     operation_yaml,
                     code_model=self.code_model,
@@ -111,6 +112,14 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                             client=self,
                         )
                     )
+
+        queue = self.yaml_data["operationGroups"].copy()
+        while queue:
+            now = queue.pop(0)
+            add_og_request_builder(now)
+            if now.get("operationGroups"):
+                queue.extend(now["operationGroups"])
+
         return request_builders
 
     def pipeline_class(self, async_mode: bool) -> str:
@@ -247,7 +256,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def has_mixin(self) -> bool:
         """Do we want a mixin ABC class for typing purposes?"""
-        return any(o for o in self.operation_groups if o.is_mixin)
+        return any(og for og in self.operation_groups if og.is_mixin)
 
     @property
     def lro_operations(self) -> List["OperationType"]:
@@ -255,8 +264,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         return [
             operation
             for operation_group in self.operation_groups
-            for operation in operation_group.operations
-            if operation.operation_type in ("lro", "lropaging")
+            for operation in operation_group.lro_operations
         ]
 
     @property
@@ -267,8 +275,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def has_operations(self) -> bool:
         return any(
-            bool(operation_group.operations)
-            for operation_group in self.operation_groups
+            operation_group.has_operations for operation_group in self.operation_groups
         )
 
     def link_lro_initial_operations(self) -> None:

package/autorest/codegen/models/code_model.py

@@ -77,6 +77,15 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
 
+    @property
+    def has_form_data(self) -> bool:
+        for client in self.clients:
+            for operation_group in client.operation_groups:
+                for operation in operation_group.operations:
+                    if operation.has_form_data_body:
+                        return True
+        return False
+
     @property
     def has_etag(self) -> bool:
         return any(client.has_etag for client in self.clients)
@@ -133,7 +142,12 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return True
         if async_mode:
             return self.need_mixin_abc
-        return self.need_request_converter or self.need_mixin_abc or self.has_etag
+        return (
+            self.need_request_converter
+            or self.need_mixin_abc
+            or self.has_etag
+            or self.has_form_data
+        )
 
     @property
     def need_request_converter(self) -> bool:

package/autorest/codegen/models/combined_type.py

@@ -65,8 +65,7 @@ class CombinedType(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         if self.name:
-            ret = f"_types.{self.name}"
-            return ret if kwargs.get("is_operation_file") else f'"{ret}"'
+            return f'"_types.{self.name}"'
         return self.type_definition(**kwargs)
 
     def type_definition(self, **kwargs: Any) -> str:

package/autorest/codegen/models/imports.py

@@ -184,8 +184,7 @@ class FileImport:
             self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
 
-    def define_mutable_mapping_type(self) -> None:
-        """Helper function for defining the mutable mapping type"""
+    def add_mutable_mapping_import(self) -> None:
         self.add_import("sys", ImportType.STDLIB)
         self.add_submodule_import(
             "typing",
@@ -195,6 +194,10 @@ class FileImport:
             None,
             (((3, 9), "collections.abc", None),),
         )
+
+    def define_mutable_mapping_type(self) -> None:
+        """Helper function for defining the mutable mapping type"""
+        self.add_mutable_mapping_import()
         self.define_mypy_type(
             "JSON",
             "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",

package/autorest/codegen/models/operation.py

@@ -92,6 +92,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             self.name = "_" + self.name
         self.has_etag: bool = self.yaml_data.get("hasEtag", False)
 
+    @property
+    def has_form_data_body(self):
+        return self.parameters.has_form_data_body
+
     @property
     def expose_stream_keyword(self) -> bool:
         return self.yaml_data.get("exposeStreamKeyword", False)
@@ -568,13 +572,31 @@ class Operation(OperationBase[Response]):
             and not self.code_model.options["models_mode"]
         ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+        relative_path = "..." if async_mode else ".."
         if self.code_model.options["models_mode"] == "dpg":
-            relative_path = "..." if async_mode else ".."
             if self.parameters.has_body:
-                file_import.add_submodule_import(
-                    f"{relative_path}_model_base", "SdkJSONEncoder", ImportType.LOCAL
-                )
-                file_import.add_import("json", ImportType.STDLIB)
+                if not self.parameters.body_parameter.is_form_data:
+                    file_import.add_submodule_import(
+                        f"{relative_path}_model_base",
+                        "SdkJSONEncoder",
+                        ImportType.LOCAL,
+                    )
+                    file_import.add_import("json", ImportType.STDLIB)
+                else:
+                    file_import.add_submodule_import(
+                        relative_path, "_model_base", ImportType.LOCAL
+                    )
+                    file_import.add_submodule_import("io", "IOBase", ImportType.STDLIB)
+                    file_import.add_submodule_import(
+                        f"{relative_path}_vendor",
+                        "multipart_form_data_file",
+                        ImportType.LOCAL,
+                    )
+                    file_import.add_submodule_import(
+                        f"{relative_path}_vendor",
+                        "handle_multipart_form_data_model",
+                        ImportType.LOCAL,
+                    )
             if self.default_error_deserialization or any(
                 r.type for r in self.responses
             ):

package/autorest/codegen/models/operation_group.py

@@ -11,6 +11,8 @@ from .base import BaseModel
 from .operation import get_operation
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
+from .lro_operation import LROOperation
+from .lro_paging_operation import LROPagingOperation
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -32,9 +34,17 @@ class OperationGroup(BaseModel):
         super().__init__(yaml_data, code_model)
         self.client = client
         self.class_name: str = yaml_data["className"]
+        self.identify_name: str = yaml_data["identifyName"]
         self.property_name: str = yaml_data["propertyName"]
         self.operations = operations
         self.api_versions = api_versions
+        self.operation_groups: List[OperationGroup] = []
+        if self.code_model.options["show_operations"]:
+            self.operation_groups = [
+                OperationGroup.from_yaml(op_group, code_model, client)
+                for op_group in self.yaml_data.get("operationGroups", [])
+            ]
+            self.link_lro_initial_operations()
 
     @property
     def has_abstract_operations(self) -> bool:
@@ -43,7 +53,7 @@ class OperationGroup(BaseModel):
     @property
     def base_class(self) -> str:
         base_classes: List[str] = []
-        if self.is_mixin and self.code_model.need_mixin_abc:
+        if self.is_mixin:
             base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
@@ -71,6 +81,8 @@ class OperationGroup(BaseModel):
             retval = add_to_pylint_disable(retval, "too-many-public-methods")
         if len(self.class_name) > NAME_LENGTH_LIMIT:
             retval = add_to_pylint_disable(retval, "name-too-long")
+        if len(self.operation_groups) > 6:
+            retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
         return retval
 
     @property
@@ -88,6 +100,13 @@ class OperationGroup(BaseModel):
             file_import.merge(
                 operation.imports(async_mode, relative_path=relative_path)
             )
+        if not self.code_model.options["combine_operation_files"]:
+            for og in self.operation_groups:
+                file_import.add_submodule_import(
+                    ".",
+                    og.class_name,
+                    ImportType.LOCAL,
+                )
         # for multiapi
         if (
             (self.code_model.public_model_types)
@@ -124,7 +143,45 @@ class OperationGroup(BaseModel):
     @property
     def is_mixin(self) -> bool:
         """The operation group with no name is the direct client methods."""
-        return self.property_name == ""
+        return self.identify_name == ""
+
+    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"])
+                    )
+
+    def lookup_operation(self, operation_id: int) -> "OperationType":
+        try:
+            return next(
+                o
+                for og in self.operation_groups
+                for o in og.operations
+                if id(o.yaml_data) == operation_id
+            )
+        except StopIteration as exc:
+            raise KeyError(f"No operation with id {operation_id} found.") from exc
+
+    @property
+    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
+        ]
+
+    @property
+    def has_operations(self) -> bool:
+        return any(
+            operation_group.has_operations for operation_group in self.operation_groups
+        ) or bool(self.operations)
 
     @classmethod
     def from_yaml(

package/autorest/codegen/models/parameter.py

@@ -179,7 +179,7 @@ class _ParameterBase(
             )
         if isinstance(self.type, CombinedType) and self.type.name:
             file_import.add_submodule_import(
-                "..",
+                "..." if async_mode else "..",
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,
@@ -243,6 +243,10 @@ class _ParameterBase(
 class BodyParameter(_ParameterBase):
     """Body parameter."""
 
+    @property
+    def is_form_data(self) -> bool:
+        return self.default_content_type == "multipart/form-data"
+
     @property
     def is_partial_body(self) -> bool:
         """Whether it's part of a bigger body parameter, i.e. a MultipartBodyParameter"""

package/autorest/codegen/models/parameter_list.py

@@ -133,6 +133,10 @@ class _ParameterListBase(
             params.append(self.body_parameter)
         return params
 
+    @property
+    def has_form_data_body(self):
+        return self.has_body and self.body_parameter.is_form_data
+
     @property
     def has_body(self) -> bool:
         """Whether there is a body parameter in the parameter list"""

package/autorest/codegen/models/request_builder.py

@@ -57,6 +57,10 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         self.method: str = yaml_data["method"]
         self.want_tracing = False
 
+    @property
+    def has_form_data_body(self):
+        return self.parameters.has_form_data_body
+
     @property
     def is_lro(self) -> bool:
         return self.yaml_data.get("discriminator") in ("lro", "lropaging")

package/autorest/codegen/models/response.py

@@ -120,8 +120,9 @@ class Response(BaseModel):
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, CombinedType) and self.type.name:
+            async_mode = kwargs.get("async_mode", False)
             file_import.add_submodule_import(
-                "..",
+                "..." if async_mode else "..",
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/autorest/codegen/serializers/__init__.py

@@ -34,6 +34,7 @@ from .utils import (
     extract_sample_name,
     get_namespace_from_package_name,
     get_namespace_config,
+    get_all_operation_groups_recursively,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -415,14 +416,15 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 clients=clients,
             )
         else:
-            for client in self.code_model.clients:
-                for operation_group in client.operation_groups:
-                    self._serialize_and_write_operations_file(
-                        env=env,
-                        namespace_path=namespace_path,
-                        operation_group=operation_group,
-                        clients=self.code_model.clients,
-                    )
+            for operation_group in get_all_operation_groups_recursively(
+                self.code_model.clients
+            ):
+                self._serialize_and_write_operations_file(
+                    env=env,
+                    namespace_path=namespace_path,
+                    operation_group=operation_group,
+                    clients=clients,
+                )
 
     def _serialize_and_write_version_file(
         self,

package/autorest/codegen/serializers/builder_serializer.py

@@ -38,6 +38,7 @@ from ..models import (
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from ..models.parameter_list import ParameterType
 from . import utils
+from ..._utils import JSON_REGEXP
 
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
@@ -59,6 +60,14 @@ OperationType = TypeVar(
 )
 
 
+def _need_type_ignore(builder: OperationType) -> bool:
+    for excep in builder.non_default_errors:
+        for status_code in excep.status_codes:
+            if status_code in (401, 404, 409, 304):
+                return True
+    return False
+
+
 def _xml_config(send_xml: bool, content_types: List[str]) -> str:
     if not (send_xml and "xml" in str(content_types)):
         return ""
@@ -547,11 +556,16 @@ class RequestBuilderSerializer(
         return retval
 
     def serialize_headers(self, builder: RequestBuilderType) -> List[str]:
-        retval = ["# Construct headers"]
-        for parameter in builder.parameters.headers:
+        headers = [
+            h
+            for h in builder.parameters.headers
+            if not builder.has_form_data_body or h.wire_name.lower() != "content-type"
+        ]
+        retval = ["# Construct headers"] if headers else []
+        for header in headers:
             retval.extend(
                 self.parameter_serializer.serialize_query_header(
-                    parameter,
+                    header,
                     "headers",
                     self.serializer_name,
                     self.code_model.is_legacy,
@@ -747,8 +761,17 @@ class _OperationSerializer(
 
         This function serializes the body params that need to be serialized.
         """
-        retval: List[str] = []
         body_param = cast(BodyParameter, builder.parameters.body_parameter)
+        if body_param.is_form_data:
+            return [
+                f"if isinstance({body_param.client_name}, _model_base.Model):",
+                f"    _body = handle_multipart_form_data_model({body_param.client_name})",
+                "else:",
+                f"    _body = {body_param.client_name}",
+                "_files = {k: multipart_form_data_file(v) for k, v in _body.items() if isinstance(v, (IOBase, bytes))}",
+                "_data = {k: v for k, v in _body.items() if not isinstance(v, (IOBase, bytes))}",
+            ]
+        retval: List[str] = []
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         send_xml = builder.parameters.body_parameter.type.is_xml
         xml_serialization_ctxt = (
@@ -769,17 +792,20 @@ class _OperationSerializer(
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
         elif self.code_model.options["models_mode"] == "dpg":
-            if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
-                create_body_call = (
-                    f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=SdkJSONEncoder, exclude_readonly=True, "
-                    f"format='{body_param.type.encode}')  # type: ignore"  # type: ignore
-                )
+            if JSON_REGEXP.match(body_param.default_content_type):
+                if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
+                    create_body_call = (
+                        f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
+                        "cls=SdkJSONEncoder, exclude_readonly=True, "
+                        f"format='{body_param.type.encode}')  # type: ignore"  # type: ignore
+                    )
+                else:
+                    create_body_call = (
+                        f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
+                        "cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore"
+                    )
             else:
-                create_body_call = (
-                    f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore"
-                )
+                create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         if body_param.optional:
@@ -959,7 +985,10 @@ class _OperationSerializer(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
                 f"{'  # type: ignore' if type_ignore else ''}"
             )
-        if request_builder.overloads:
+        if request_builder.has_form_data_body:
+            retval.append("    data=_data,")
+            retval.append("    files=_files,")
+        elif request_builder.overloads:
             seen_body_params = set()
             for overload in request_builder.overloads:
                 body_param = cast(
@@ -1030,7 +1059,9 @@ class _OperationSerializer(
                     builder.parameters.body_parameter, builder.parameters.parameters
                 )
             )
-        if builder.overloads:
+        if builder.has_form_data_body:
+            retval.extend(self._create_body_parameter(builder))
+        elif builder.overloads:
             # we are only dealing with two overloads. If there are three, we generate an abstract operation
             retval.extend(self._initialize_overloads(builder, is_paging=is_paging))
         elif builder.parameters.has_body:
@@ -1097,12 +1128,17 @@ class _OperationSerializer(
                         and response.default_content_type == "application/json"
                         else ""
                     )
+                    response_attr = (
+                        "json"
+                        if JSON_REGEXP.match(str(response.default_content_type))
+                        else "text"
+                    )
                     deserialize_code.append("deserialized = _deserialize(")
                     deserialize_code.append(
                         f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
                     )
                     deserialize_code.append(
-                        f"    response.json(){response.result_property}{format_filed}"
+                        f"    response.{response_attr}(){response.result_property}{format_filed}"
                     )
                     deserialize_code.append(")")
 
@@ -1138,8 +1174,9 @@ class _OperationSerializer(
                     f"        {async_await} response.read()  # Load the body in memory and close the socket",
                 ]
             )
+        type_ignore = "  # type: ignore" if _need_type_ignore(builder) else ""
         retval.append(
-            "    map_error(status_code=response.status_code, response=response, error_map=error_map)"
+            f"    map_error(status_code=response.status_code, response=response, error_map=error_map){type_ignore}"
         )
         error_model = ""
         if (

package/autorest/codegen/serializers/client_serializer.py

@@ -48,9 +48,8 @@ class ClientSerializer:
     @property
     def class_definition(self) -> str:
         class_name = self.client.name
-        has_mixin_og = any(og for og in self.client.operation_groups if og.is_mixin)
         base_class = ""
-        if has_mixin_og:
+        if self.client.has_mixin:
             base_class = f"{class_name}OperationsMixin"
         pylint_disable = self.client.pylint_disable
         if base_class:

package/autorest/codegen/serializers/general_serializer.py

@@ -130,6 +130,14 @@ class GeneralSerializer(BaseSerializer):
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
+        if self.code_model.has_form_data:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+            file_import.add_submodule_import("io", "IOBase", ImportType.STDLIB)
+            file_import.add_submodule_import("io", "BytesIO", ImportType.STDLIB)
+            file_import.add_import("uuid", ImportType.STDLIB)
+            file_import.add_mutable_mapping_import()
+            file_import.add_submodule_import("._model_base", "Model", ImportType.LOCAL)
 
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -7,6 +7,7 @@ from typing import Optional, List, Union
 import functools
 from jinja2 import Environment
 
+from .utils import get_all_operation_groups_recursively
 from ..models import (
     CodeModel,
     OperationGroup,
@@ -45,18 +46,18 @@ class OperationGroupsSerializer(BaseSerializer):
             for client in self.clients
             for r in client.request_builders
             if r.client.name == operation_group.client.name
-            and r.group_name == operation_group.property_name
+            and r.group_name == operation_group.identify_name
             and not r.is_overload
             and not r.abstract
             and not r.is_lro  # lro has already initial builder
         ]
 
     def serialize(self) -> str:
-        operation_groups = (
-            [self.operation_group]
-            if self.operation_group
-            else [og for client in self.clients for og in client.operation_groups]
-        )
+        if self.operation_group:
+            operation_groups = [self.operation_group]
+        else:
+            operation_groups = get_all_operation_groups_recursively(self.clients)
+
         imports = FileImport(self.code_model)
         for operation_group in operation_groups:
             imports.merge(

package/autorest/codegen/serializers/utils.py

@@ -3,9 +3,11 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional
+from typing import Optional, List
 from pathlib import Path
 
+from ..models import Client, OperationGroup
+
 
 def method_signature_and_response_type_annotation_template(
     *,
@@ -30,3 +32,15 @@ def get_namespace_config(namespace: str, multiapi: bool) -> str:
 
 def get_namespace_from_package_name(package_name: Optional[str]) -> str:
     return (package_name or "").replace("-", ".")
+
+
+def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
+    operation_groups = []
+    queue = []
+    for client in clients:
+        queue.extend(client.operation_groups)
+    while queue:
+        operation_groups.append(queue.pop(0))
+        if operation_groups[-1].operation_groups:
+            queue.extend(operation_groups[-1].operation_groups)
+    return operation_groups

package/autorest/codegen/templates/model_base.py.jinja2

@@ -726,7 +726,11 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     ):
         if obj is None:
             return obj
-        return _deserialize_with_callable(deserializer, obj)
+        try:
+            return _deserialize_with_callable(deserializer, obj)
+        except Exception:
+            pass
+        return obj
 
     if get_deserializer(annotation, rf):
         return functools.partial(_deserialize_default, get_deserializer(annotation, rf))

package/autorest/codegen/templates/operation_group.py.jinja2

@@ -38,6 +38,13 @@ class {{ operation_group.class_name }}: {{ operation_group.pylint_disable }}
         {% if code_model.options["multiapi"] %}
         self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version")
         {% endif %}
+
+        {% for og in operation_group.operation_groups %}
+        self.{{ og.property_name }} = {{ og.class_name }}(
+            self._client, self._config, self._serialize, self._deserialize{{ ", self._api_version" if code_model.options["multiapi"] else "" }}
+        )
+        {% endfor %}
+
 {{ check_abstract_methods() }}
 {% elif operation_group.has_abstract_operations %}
 

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -94,7 +94,7 @@ setup(
         {% elif azure_arm %}
         "azure-mgmt-core<2.0.0,>=1.3.2",
         {% else %}
-        "azure-core<2.0.0,>=1.28.0",
+        "azure-core<2.0.0,>=1.29.5",
         {% endif %}
         {% if code_model.need_typing_extensions %}
         "typing-extensions>=4.3.0; python_version<'3.8.0'",

package/autorest/codegen/templates/vendor.py.jinja2

@@ -65,3 +65,33 @@ def prep_if_none_match(etag: Optional[str], match_condition: Optional[MatchCondi
         return "*"
     return None
 {% endif %}
+{% if code_model.has_form_data %}
+class NamedBytesIO(BytesIO):
+    def __init__(self, name: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = name
+
+def multipart_form_data_file(file: Union[IOBase, bytes]) -> IOBase:
+    if isinstance(file, IOBase):
+        return file
+    return NamedBytesIO("auto-name-" + str(uuid.uuid4()), file)
+
+def handle_multipart_form_data_model(body: Model) -> MutableMapping[str, Any]:  # pylint: disable=unsubscriptable-object
+    """handle first layer of model. 
+    If its value is bytes or IO, replace it with raw value instead of serialized value.
+
+    :param body: The model to handle.
+    :type body: ~payload.multipart._model_base.Model
+    :return: The handled model.
+    :rtype: MutableMapping[str, Any]
+    """
+    result = body.as_dict()
+    rest_name_attr = {v._rest_name: k for k, v in body._attr_to_rest_field.items()}  # pylint: disable=protected-access
+    for rest_name in result.keys():
+        attr = rest_name_attr.get(rest_name)
+        if attr is not None:
+            raw_value = getattr(body, attr, None)
+            if isinstance(raw_value, (bytes, IOBase)):
+                result[rest_name] = raw_value
+    return result
+{% endif %}

package/autorest/preprocess/__init__.py

@@ -124,11 +124,9 @@ def update_description(
     return description
 
 
-def update_operation_group_class_name(
-    yaml_data: Dict[str, Any], class_name: str
-) -> str:
+def update_operation_group_class_name(prefix: str, class_name: str) -> str:
     if class_name == "":
-        return yaml_data["name"] + "OperationsMixin"
+        return prefix + "OperationsMixin"
     if class_name == "Operations":
         return "Operations"
     return class_name + "Operations"
@@ -173,6 +171,16 @@ def headers_convert(yaml_data: Dict[str, Any], replace_data: Any) -> None:
             yaml_data[k] = v
 
 
+def has_json_content_type(yaml_data: Dict[str, Any]) -> bool:
+    return any(ct for ct in yaml_data.get("contentTypes", []) if JSON_REGEXP.match(ct))
+
+
+def has_multi_part_content_type(yaml_data: Dict[str, Any]) -> bool:
+    return any(
+        ct for ct in yaml_data.get("contentTypes", []) if ct == "multipart/form-data"
+    )
+
+
 class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     """Add Python naming information."""
 
@@ -197,13 +205,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         code_model: Dict[str, Any],
         body_parameter: Dict[str, Any],
     ):
-        if (
+        # only add overload for special content type
+        if (  # pylint: disable=too-many-boolean-expressions
             body_parameter
             and body_parameter["type"]["type"] in ("model", "dict", "list")
-            and any(
-                ct
-                for ct in body_parameter.get("contentTypes", [])
-                if JSON_REGEXP.match(ct)
+            and (
+                has_json_content_type(body_parameter)
+                or (self.is_cadl and has_multi_part_content_type(body_parameter))
             )
             and not body_parameter["type"].get("xmlMetadata")
             and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
@@ -212,8 +220,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             is_dpg_model = body_parameter["type"].get("base") == "dpg"
             body_parameter["type"] = {
                 "type": "combined",
-                "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
+                "types": [body_parameter["type"]],
             }
+            # don't add binary overload for multipart content type
+            if not (self.is_cadl and has_multi_part_content_type(body_parameter)):
+                body_parameter["type"]["types"].append(KNOWN_TYPES["binary"])
+
             if origin_type == "model" and is_dpg_model and self.models_mode == "dpg":
                 body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
             code_model["types"].append(body_parameter["type"])
@@ -373,9 +385,9 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 for prop, param_name in yaml_data["propertyToParameterName"].items()
             }
         wire_name_lower = (yaml_data.get("wireName") or "").lower()
-        if (
-            yaml_data["location"] == "header"
-            and wire_name_lower in HEADERS_HIDE_IN_METHOD
+        if yaml_data["location"] == "header" and (
+            wire_name_lower in HEADERS_HIDE_IN_METHOD
+            or yaml_data.get("clientDefaultValue") == "multipart/form-data"
         ):
             yaml_data["hideInMethod"] = True
         if (
@@ -511,7 +523,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     ) -> None:
         operation_groups_yaml_data = client["operationGroups"]
         for operation_group in operation_groups_yaml_data:
-            operation_group["clientName"] = client["name"]
+            operation_group["identifyName"] = self.pad_reserved_words(
+                operation_group.get("name", operation_group["propertyName"]),
+                PadType.OPERATION_GROUP,
+            )
+            operation_group["identifyName"] = to_snake_case(
+                operation_group["identifyName"]
+            )
             operation_group["propertyName"] = self.pad_reserved_words(
                 operation_group["propertyName"], PadType.OPERATION_GROUP
             )
@@ -519,11 +537,14 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 operation_group["propertyName"]
             )
             operation_group["className"] = update_operation_group_class_name(
-                client, operation_group["className"]
+                client["name"], operation_group["className"]
             )
             for operation in operation_group["operations"]:
                 self.get_operation_updater(operation)(code_model, operation)
 
+            if operation_group.get("operationGroups"):
+                self.update_operation_groups(code_model, operation_group)
+
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
         self.update_types(yaml_data["types"])

package/autorest/preprocess/python_mappings.py

@@ -93,6 +93,7 @@ _always_reserved = [
     "yield",
     "async",
     "await",
+    "int",
 ]
 
 RESERVED_WORDS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.10.2",
+  "version": "6.11.1",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {