@autorest/python 6.12.2 → 6.12.4

package/autorest/_utils.py

@@ -73,7 +73,7 @@ def parse_args(
         dest="debug",
         help="Debug mode",
         required=False,
-        action="store_true",
+        action="store",
     )
     args, unknown_args = parser.parse_known_args()
 

package/autorest/codegen/models/__init__.py

@@ -43,7 +43,6 @@ from .parameter import (
     ParameterLocation,
     BodyParameter,
     ParameterDelimeter,
-    MultipartBodyParameter,
     ClientParameter,
     ConfigParameter,
 )
@@ -115,7 +114,6 @@ __all__ = [
     "BodyParameter",
     "RequestBuilderBodyParameter",
     "ParameterDelimeter",
-    "MultipartBodyParameter",
     "CredentialType",
     "ClientParameter",
     "ConfigParameter",

package/autorest/codegen/models/base.py

@@ -186,3 +186,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     @property
     def type_description(self) -> str:
         return self.type_annotation()
+
+    @property
+    def is_form_data(self) -> bool:
+        return False

package/autorest/codegen/models/combined_type.py

@@ -79,6 +79,10 @@ class CombinedType(BaseType):
         pattern = re.compile(r"Union\[.*\]")
         return f'Union[{", ".join(map(lambda x: x[6: -1] if pattern.match(x) else x, inside_types))}]'
 
+    @property
+    def is_form_data(self) -> bool:
+        return any(t.is_form_data for t in self.types)
+
     def get_json_template_representation(
         self,
         *,

package/autorest/codegen/models/model_type.py

@@ -76,6 +76,10 @@ class ModelType(  # pylint: disable=abstract-method
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
         self.page_result_model: bool = self.yaml_data.get("pageResultModel", False)
 
+    @property
+    def is_form_data(self) -> bool:
+        return any(p.is_multipart_file_input for p in self.properties)
+
     @property
     def is_xml(self) -> bool:
         return self.yaml_data.get("isXml", False)
@@ -314,6 +318,15 @@ class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
                 if kwargs.get("model_typing")
                 else TypingSection.REGULAR,
             )
+            if self.is_form_data:
+                file_import.add_submodule_import(
+                    relative_path,
+                    "_model_base",
+                    ImportType.LOCAL,
+                    typing_section=TypingSection.TYPING
+                    if kwargs.get("model_typing")
+                    else TypingSection.REGULAR,
+                )
         return file_import
 
 

package/autorest/codegen/models/operation.py

@@ -30,7 +30,6 @@ from .response import (
 )
 from .parameter import (
     BodyParameter,
-    MultipartBodyParameter,
     Parameter,
     ParameterLocation,
 )
@@ -290,7 +289,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 Parameter,
                 RequestBuilderParameter,
                 BodyParameter,
-                MultipartBodyParameter,
             ]
         ],
         location: ParameterLocation,
@@ -575,33 +573,13 @@ class Operation(OperationBase[Response]):
         relative_path = "..." if async_mode else ".."
         if self.code_model.options["models_mode"] == "dpg":
             if self.parameters.has_body:
-                if not self.parameters.body_parameter.is_form_data:
+                if not self.has_form_data_body:
                     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_file",
-                        ImportType.LOCAL,
-                    )
-                    file_import.add_submodule_import(
-                        f"{relative_path}_vendor",
-                        "multipart_data",
-                        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/parameter.py

@@ -14,7 +14,6 @@ from typing import (
     Optional,
     TypeVar,
     Union,
-    Generic,
 )
 
 from .imports import FileImport, ImportType, TypingSection
@@ -243,9 +242,18 @@ class _ParameterBase(
 class BodyParameter(_ParameterBase):
     """Body parameter."""
 
+    @property
+    def entries(self) -> List["BodyParameter"]:
+        return [
+            BodyParameter.from_yaml(e, self.code_model)
+            for e in self.yaml_data.get("entries", [])
+        ]
+
     @property
     def is_form_data(self) -> bool:
-        return self.default_content_type == "multipart/form-data"
+        # hacky, but rn in legacy, there is no formdata model type, it's just a dict
+        # with all of the entries splatted out
+        return self.type.is_form_data or bool(self.entries)
 
     @property
     def is_partial_body(self) -> bool:
@@ -262,6 +270,10 @@ class BodyParameter(_ParameterBase):
 
     @property
     def in_method_signature(self) -> bool:
+        if self.yaml_data.get("entries"):
+            # Right now, only legacy generates with multipart bodies and entries
+            # and legacy generates with the multipart body arguments splatted out
+            return False
         return not (self.flattened or self.grouped_by)
 
     @property
@@ -278,6 +290,18 @@ class BodyParameter(_ParameterBase):
             return self.type.target_model_subtype((JSONModelType,)) is not None
         return isinstance(self.type, JSONModelType)
 
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = super().imports(async_mode, **kwargs)
+        if self.is_form_data:
+            relative_path = "..." if async_mode else ".."
+            file_import.add_submodule_import(
+                f"{relative_path}_vendor",
+                "prepare_multipart_form_data",
+                ImportType.LOCAL,
+            )
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
+        return file_import
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
@@ -294,46 +318,6 @@ EntryBodyParameterType = TypeVar(
 )
 
 
-class _MultipartBodyParameter(Generic[EntryBodyParameterType], BodyParameter):
-    """Base class for MultipartBodyParameter and RequestBuilderMultipartBodyParameter"""
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        type: BaseType,
-        entries: List[EntryBodyParameterType],
-    ) -> None:
-        super().__init__(yaml_data, code_model, type)
-        self.entries = entries
-
-    @property
-    def in_method_signature(self) -> bool:
-        # Right now, only legacy generates with multipart bodies
-        # and legacy generates with the multipart body arguments splatted out
-        return False
-
-
-class MultipartBodyParameter(
-    _MultipartBodyParameter[BodyParameter]  # pylint: disable=unsubscriptable-object
-):
-    """Multipart body parameter for Operation. Used for files and data input."""
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "MultipartBodyParameter":
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
-            entries=[
-                BodyParameter.from_yaml(entry, code_model)
-                for entry in yaml_data["entries"]
-            ],
-        )
-
-
 class Parameter(_ParameterBase):
     """Basic Parameter class"""
 
@@ -455,12 +439,3 @@ class ConfigParameter(Parameter):
         if self.constant:
             return ParameterMethodLocation.KWARG
         return ParameterMethodLocation.POSITIONAL
-
-
-def get_body_parameter(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
-) -> Union[BodyParameter, MultipartBodyParameter]:
-    """Creates a regular body parameter or Multipart body parameter"""
-    if yaml_data.get("entries"):
-        return MultipartBodyParameter.from_yaml(yaml_data, code_model)
-    return BodyParameter.from_yaml(yaml_data, code_model)

package/autorest/codegen/models/parameter_list.py

@@ -22,19 +22,15 @@ from enum import Enum
 
 from .request_builder_parameter import (
     RequestBuilderBodyParameter,
-    RequestBuilderMultipartBodyParameter,
     RequestBuilderParameter,
-    get_request_body_parameter,
 )
 from .parameter import (
-    MultipartBodyParameter,
     ParameterLocation,
     BodyParameter,
     Parameter,
     ParameterMethodLocation,
     ClientParameter,
     ConfigParameter,
-    get_body_parameter,
 )
 
 ParameterType = TypeVar(
@@ -43,10 +39,6 @@ ParameterType = TypeVar(
 BodyParameterType = TypeVar(
     "BodyParameterType", bound=Union[BodyParameter, RequestBuilderBodyParameter]
 )
-RequestBuilderBodyParameterType = Union[
-    RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter
-]
-
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -314,7 +306,7 @@ class _ParameterListBase(
 
 class _ParameterList(
     _ParameterListBase[  # pylint: disable=unsubscriptable-object
-        Parameter, Union[MultipartBodyParameter, BodyParameter]
+        Parameter, BodyParameter
     ]
 ):
     """Base Parameter class for the two operation ParameterLists"""
@@ -325,11 +317,9 @@ class _ParameterList(
 
     @staticmethod
     def body_parameter_creator() -> (
-        Callable[
-            [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
-        ]
+        Callable[[Dict[str, Any], "CodeModel"], BodyParameter]
     ):
-        return get_body_parameter
+        return BodyParameter.from_yaml
 
     @property
     def implementation(self) -> str:
@@ -348,7 +338,7 @@ class ParameterList(_ParameterList):
 
 class _RequestBuilderParameterList(
     _ParameterListBase[  # pylint: disable=unsubscriptable-object
-        RequestBuilderParameter, RequestBuilderBodyParameterType
+        RequestBuilderParameter, RequestBuilderBodyParameter
     ]
 ):
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
@@ -361,9 +351,9 @@ class _RequestBuilderParameterList(
 
     @staticmethod
     def body_parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType]
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameter]
     ):
-        return get_request_body_parameter
+        return RequestBuilderBodyParameter.from_yaml
 
     @property
     def implementation(self) -> str:
@@ -372,14 +362,14 @@ class _RequestBuilderParameterList(
     @property
     def unsorted_method_params(
         self,
-    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameterType]]:
+    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
         # don't have access to client params in request builder
         retval = [
             p
             for p in super().unsorted_method_params
             if not (
                 p.location == ParameterLocation.BODY
-                and cast(RequestBuilderBodyParameterType, p).is_partial_body
+                and cast(RequestBuilderBodyParameter, p).is_partial_body
             )
         ]
         retval.extend(
@@ -400,7 +390,7 @@ class _RequestBuilderParameterList(
     @property
     def constant(
         self,
-    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameterType]]:
+    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
         """All constant parameters"""
         return [
             p for p in super().constant if p.location != ParameterLocation.ENDPOINT_PATH

package/autorest/codegen/models/property.py

@@ -37,6 +37,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         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.is_multipart_file_input: bool = yaml_data.get(
+            "isMultipartFileInput", False
+        )
 
     @property
     def pylint_disable(self) -> str:
@@ -94,12 +97,18 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return self.is_discriminator and self.type.type == "enum"
 
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        types_type_annotation = self.type.type_annotation(
+            is_operation_file=is_operation_file
+        )
+        if self.is_multipart_file_input:
+            # we only support FileType or list of FileType
+            types_type_annotation = types_type_annotation.replace("bytes", "FileType")
         if self.is_enum_discriminator:
             # here we are the enum discriminator property on the base model
             return "Literal[None]"
         if self.optional and self.client_default_value is None:
-            return f"Optional[{self.type.type_annotation(is_operation_file=is_operation_file)}]"
-        return self.type.type_annotation(is_operation_file=is_operation_file)
+            return f"Optional[{types_type_annotation}]"
+        return types_type_annotation
 
     def get_declaration(self, value: Any = None) -> Any:
         if self.is_enum_discriminator:
@@ -114,6 +123,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         client_default_value_declaration: Optional[str] = None,
         description: Optional[str] = None,
     ) -> Any:
+        if self.is_multipart_file_input:
+            return "[filetype]" if self.type.type == "list" else "filetype"
         if self.client_default_value:
             client_default_value_declaration = self.get_declaration(
                 self.client_default_value
@@ -161,6 +172,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )
+        if self.is_multipart_file_input:
+            file_import.add_submodule_import(".._vendor", "FileType", ImportType.LOCAL)
         return file_import
 
     @classmethod

package/autorest/codegen/models/request_builder_parameter.py

@@ -3,13 +3,12 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import TYPE_CHECKING, Any, Dict, Union
+from typing import TYPE_CHECKING, Any, Dict
 from .parameter import (
     ParameterLocation,
     ParameterMethodLocation,
     Parameter,
     BodyParameter,
-    _MultipartBodyParameter,
 )
 from .base import BaseType
 from .primitive_types import BinaryType, StringType
@@ -67,32 +66,6 @@ class RequestBuilderBodyParameter(BodyParameter):
         return "_content"
 
 
-class RequestBuilderMultipartBodyParameter(
-    _MultipartBodyParameter[  # pylint: disable=unsubscriptable-object
-        RequestBuilderBodyParameter
-    ]
-):
-    """Multipart body parameter for Request BUilders"""
-
-    @property
-    def name_in_high_level_operation(self) -> str:
-        return f"_{self.client_name}"
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "RequestBuilderMultipartBodyParameter":
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
-            entries=[
-                RequestBuilderBodyParameter.from_yaml(entry, code_model)
-                for entry in yaml_data["entries"]
-            ],
-        )
-
-
 class RequestBuilderParameter(Parameter):
     """Basic RequestBuilder Parameter."""
 
@@ -149,12 +122,3 @@ class RequestBuilderParameter(Parameter):
         if self.implementation == "Client":
             return f"self._config.{self.client_name}"
         return self.client_name
-
-
-def get_request_body_parameter(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
-) -> Union[RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter]:
-    """Get body parameter for a request builder"""
-    if yaml_data.get("entries"):
-        return RequestBuilderMultipartBodyParameter.from_yaml(yaml_data, code_model)
-    return RequestBuilderBodyParameter.from_yaml(yaml_data, code_model)

package/autorest/codegen/serializers/builder_serializer.py

@@ -26,7 +26,6 @@ from ..models import (
     ParameterMethodLocation,
     RequestBuilderBodyParameter,
     OverloadedRequestBuilder,
-    MultipartBodyParameter,
     Property,
     RequestBuilderType,
     CombinedType,
@@ -207,7 +206,7 @@ def _serialize_json_model_body(
 
 def _serialize_multipart_body(builder: BuilderType) -> List[str]:
     retval: List[str] = []
-    body_param = cast(MultipartBodyParameter, builder.parameters.body_parameter)
+    body_param = builder.parameters.body_parameter
     # we have to construct our form data before passing to the request as well
     retval.append("# Construct form data")
     retval.append(f"_{body_param.client_name} = {{")
@@ -349,7 +348,11 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
     def param_description(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         for param in builder.parameters.method:
-            if not param.in_docstring or param.hide_in_operation_signature:
+            if (
+                not param.in_docstring
+                or param.hide_in_operation_signature
+                or param.method_location == ParameterMethodLocation.KWARG
+            ):
                 continue
             description_list.extend(
                 f":{param.description_keyword} {param.client_name}: {param.description}".replace(
@@ -700,19 +703,6 @@ class _OperationSerializer(
             retval.append(_api_version_validation(builder))
         return retval
 
-    def param_description(self, builder: OperationType) -> List[str]:
-        description_list = super().param_description(builder)
-        if builder.expose_stream_keyword and builder.has_response_body:
-            description_list.append(
-                ":keyword bool stream: Whether to stream the response of this operation. "
-                "Defaults to False. You will have to context manage the returned stream."
-            )
-        if not self.code_model.options["version_tolerant"]:
-            description_list.append(
-                ":keyword callable cls: A custom type or function that will be passed the direct response"
-            )
-        return description_list
-
     def pop_kwargs_from_signature(self, builder: OperationType) -> List[str]:
         kwargs_to_pop = builder.parameters.kwargs_to_pop
         kwargs = self.parameter_serializer.pop_kwargs_from_signature(
@@ -761,17 +751,39 @@ class _OperationSerializer(
 
         This function serializes the body params that need to be serialized.
         """
-        body_param = cast(BodyParameter, builder.parameters.body_parameter)
+        retval: List[str] = []
+        body_param = 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_file(v) for k, v in _body.items() if isinstance(v, (IOBase, bytes))}",
-                "_data = {k: multipart_data(v) for k, v in _body.items() if not isinstance(v, (IOBase, bytes))}",
+            model_type = cast(
+                ModelType,
+                (
+                    body_param.type.target_model_subtype((JSONModelType, DPGModelType))
+                    if isinstance(body_param.type, CombinedType)
+                    else body_param.type
+                ),
+            )
+            file_fields = [
+                p.wire_name for p in model_type.properties if p.is_multipart_file_input
             ]
-        retval: List[str] = []
+            data_fields = [
+                p.wire_name
+                for p in model_type.properties
+                if not p.is_multipart_file_input
+            ]
+            retval.extend(
+                [
+                    "_body = (",
+                    f"    {body_param.client_name}.as_dict()",
+                    f"    if isinstance({body_param.client_name}, _model_base.Model) else",
+                    f"    {body_param.client_name}",
+                    ")",
+                    f"_file_fields: List[str] = {file_fields}",
+                    f"_data_fields: List[str] = {data_fields}",
+                    "_files, _data = prepare_multipart_form_data(_body, _file_fields, _data_fields)",
+                ]
+            )
+            return retval
+
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         send_xml = builder.parameters.body_parameter.type.is_xml
         xml_serialization_ctxt = (
@@ -823,8 +835,8 @@ class _OperationSerializer(
     ) -> List[str]:
         """Create the body parameter before we pass it as either json or content to the request builder"""
         retval = []
-        body_param = cast(BodyParameter, builder.parameters.body_parameter)
-        if hasattr(body_param, "entries"):
+        body_param = builder.parameters.body_parameter
+        if body_param.entries:
             return _serialize_multipart_body(builder)
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         body_param_type = body_param.type
@@ -985,9 +997,13 @@ class _OperationSerializer(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
                 f"{'  # type: ignore' if type_ignore else ''}"
             )
-        if request_builder.has_form_data_body:
-            retval.append("    data=_data,")
+        if builder.parameters.has_body and builder.parameters.body_parameter.entries:
+            # this is for legacy
+            client_name = builder.parameters.body_parameter.client_name
+            retval.append(f"    {client_name}=_{client_name},")
+        elif request_builder.has_form_data_body:
             retval.append("    files=_files,")
+            retval.append("    data=_data,")
         elif request_builder.overloads:
             seen_body_params = set()
             for overload in request_builder.overloads:
@@ -1543,25 +1559,6 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
-    def param_description(self, builder: LROOperationType) -> List[str]:
-        retval = super().param_description(builder)
-        retval.append(
-            ":keyword str continuation_token: A continuation token to restart a poller from a saved state."
-        )
-        retval.append(
-            f":keyword polling: By default, your polling method will be {builder.get_polling_method(self.async_mode)}. "
-            "Pass in False for this operation to not poll, or pass in your own initialized polling object for a"
-            " personal polling strategy."
-        )
-        retval.append(
-            f":paramtype polling: bool or ~{builder.get_base_polling_method_path(self.async_mode)}"
-        )
-        retval.append(
-            ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
-            "if no Retry-After header is present."
-        )
-        return retval
-
     def serialize_path(self, builder: LROOperationType) -> List[str]:
         return self.parameter_serializer.serialize_path(
             builder.parameters.path, self.serializer_name

package/autorest/codegen/serializers/general_serializer.py

@@ -130,18 +130,30 @@ class GeneralSerializer(BaseSerializer):
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
-        if self.code_model.has_form_data:
+        if (
+            self.code_model.has_form_data
+            and self.code_model.options["models_mode"] == "dpg"
+        ):
+            file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Sequence", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Dict", 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_import("json", ImportType.STDLIB)
-            file_import.add_mutable_mapping_import()
-            file_import.add_submodule_import("._model_base", "Model", ImportType.LOCAL)
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "._model_base", "SdkJSONEncoder", ImportType.LOCAL
+                "._model_base",
+                "SdkJSONEncoder",
+                ImportType.LOCAL,
             )
+            file_import.add_submodule_import(
+                "._model_base",
+                "Model",
+                ImportType.LOCAL,
+            )
+            file_import.add_import("json", ImportType.STDLIB)
 
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/model_serializer.py

@@ -257,7 +257,10 @@ class DpgModelSerializer(_ModelSerializer):
             args.append(f"visibility=[{v_list}]")
         if prop.client_default_value is not None:
             args.append(f"default={prop.client_default_value_declaration}")
-        if hasattr(prop.type, "encode") and prop.type.encode:  # type: ignore
+
+        if prop.is_multipart_file_input:
+            args.append("is_multipart_file_input=True")
+        elif hasattr(prop.type, "encode") and prop.type.encode:  # type: ignore
             args.append(f'format="{prop.type.encode}"')  # type: ignore
 
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"

package/autorest/codegen/serializers/parameter_serializer.py

@@ -32,8 +32,8 @@ SPECIAL_HEADER_SERIALIZATION: Dict[str, List[str]] = {
     ],
     "repeatability-first-sent": [
         """if "Repeatability-First-Sent" not in _headers:""",
-        """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(datetime.datetime.now(),
-        "rfc-1123")""",
+        """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(""",
+        """        datetime.datetime.now(datetime.timezone.utc), "rfc-1123")""",
     ],
     "client-request-id": [],
     "x-ms-client-request-id": [],

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

@@ -16,7 +16,7 @@ import base64
 import re
 import copy
 import typing
-import email
+import email.utils
 from datetime import datetime, date, time, timedelta, timezone
 from json import JSONEncoder
 import isodate
@@ -470,7 +470,13 @@ def _get_rest_field(
 
 
 def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typing.Any:
-    return _deserialize(rf._type, value) if (rf and rf._is_model) else _serialize(value, rf._format if rf else None)
+    if not rf:
+        return _serialize(value, None)
+    if rf._is_multipart_file_input:
+        return value
+    if rf._is_model:
+        return _deserialize(rf._type, value)
+    return _serialize(value, rf._format)
 
 
 class Model(_MyMutableMapping):
@@ -567,7 +573,12 @@ class Model(_MyMutableMapping):
         for k, v in self.items():
             if exclude_readonly and k in readonly_props:  # pyright: ignore[reportUnboundVariable]
                 continue
-            result[k] = Model._as_dict_value(v, exclude_readonly=exclude_readonly)
+            is_multipart_file_input = False
+            try:
+                is_multipart_file_input = next(rf for rf in self._attr_to_rest_field.values() if rf._rest_name == k)._is_multipart_file_input
+            except StopIteration:
+                pass
+            result[k] = v if is_multipart_file_input else Model._as_dict_value(v, exclude_readonly=exclude_readonly)
         return result
 
     @staticmethod
@@ -575,10 +586,10 @@ class Model(_MyMutableMapping):
         if v is None or isinstance(v, _Null):
             return None
         if isinstance(v, (list, tuple, set)):
-            return [
+            return type(v)(
                 Model._as_dict_value(x, exclude_readonly=exclude_readonly)
                 for x in v
-            ]
+            )
         if isinstance(v, dict):
             return {
                 dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly)
@@ -625,7 +636,7 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
 
     # is it a literal?
     try:
-        if annotation.__origin__ == typing.Literal:
+        if annotation.__origin__ is typing.Literal:
             return None
     except AttributeError:
         pass
@@ -779,6 +790,7 @@ class _RestField:
         visibility: typing.Optional[typing.List[str]] = None,
         default: typing.Any = _UNSET,
         format: typing.Optional[str] = None,
+        is_multipart_file_input: bool = False,
     ):
         self._type = type
         self._rest_name_input = name
@@ -788,6 +800,7 @@ class _RestField:
         self._is_model = False
         self._default = default
         self._format = format
+        self._is_multipart_file_input = is_multipart_file_input
 
     @property
     def _rest_name(self) -> str:
@@ -833,8 +846,9 @@ def rest_field(
     visibility: typing.Optional[typing.List[str]] = None,
     default: typing.Any = _UNSET,
     format: typing.Optional[str] = None,
+    is_multipart_file_input: bool = False,
 ) -> typing.Any:
-    return _RestField(name=name, type=type, visibility=visibility, default=default, format=format)
+    return _RestField(name=name, type=type, visibility=visibility, default=default, format=format, is_multipart_file_input=is_multipart_file_input)
 
 
 def rest_discriminator(

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.29.5",
+        "azure-core<2.0.0,>=1.30.0",
         {% endif %}
     ],
     {% if package_mode %}

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

@@ -65,38 +65,42 @@ 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
+{% if code_model.has_form_data and code_model.options["models_mode"] == "dpg" %}
+# file-like tuple could be `(filename, IO (or bytes))` or `(filename, IO (or bytes), content_type)`
+FileContent = Union[str, bytes, IO[str], IO[bytes]]
 
-def multipart_file(file: Union[IOBase, bytes]) -> IOBase:
-    if isinstance(file, IOBase):
-        return file
-    return NamedBytesIO("auto-name-" + str(uuid.uuid4()), file)
+FileType = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+]
 
-def multipart_data(data: Any) -> Any:
-    if isinstance(data, (list, tuple, dict, Model)):
-        return json.dumps(data, cls=SdkJSONEncoder, exclude_readonly=True)
-    return data
+FilesType = Union[Mapping[str, FileType], Sequence[Tuple[str, FileType]]]
 
-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.
+def serialize_multipart_data_entry(data_entry: Any) -> Any:
+    if isinstance(data_entry, (list, tuple, dict, Model)):
+        return json.dumps(data_entry, cls=SdkJSONEncoder, exclude_readonly=True)
+    return data_entry
 
-    :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 %}
+def prepare_multipart_form_data(
+    body: Mapping[str, Any], multipart_fields: List[str], data_fields: List[str]
+) -> Tuple[List[FileType], Dict[str, Any]]:
+    files: List[FileType] = []
+    data: Dict[str, Any] = {}
+    for multipart_field in multipart_fields:
+        multipart_entry = body.get(multipart_field)
+        if isinstance(multipart_entry, list):
+            files.extend([(multipart_field, e) for e in multipart_entry ])
+        elif multipart_entry:
+            files.append((multipart_field, multipart_entry))
+
+    for data_field in data_fields:
+        data_entry = body.get(data_field)
+        if data_entry:
+            data[data_field] = serialize_multipart_data_entry(data_entry)
+
+    return files, data
+{% endif %}

package/package.json

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

package/requirements.txt

@@ -1,7 +1,7 @@
 black==22.12.0
 click==8.1.3
 docutils==0.19
-Jinja2==3.1.2
+Jinja2==3.1.3
 json-rpc==1.14.0
 m2r2==0.3.3
 MarkupSafe==2.1.2

package/run_cadl.py

@@ -22,7 +22,7 @@ if __name__ == "__main__":
     env_builder = venv.EnvBuilder(with_pip=True)
     venv_context = env_builder.ensure_directories(venv_path)
 
-    if "--debug" in sys.argv:
+    if "--debug" in sys.argv or "--debug=true" in sys.argv:
         try:
             import debugpy  # pylint: disable=import-outside-toplevel
         except ImportError: