@autorest/python 6.1.0 → 6.1.3

package/ChangeLog.md

@@ -1,5 +1,51 @@
 # Release History
 
+### 2022-08-22 - 6.1.3
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.4`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.2`     |
+
+**Bug Fixes**
+
+- Fix circular recursion for lropaging  #1400
+
+### 2022-08-16 - 6.1.2
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Bug Fixes**
+
+- Correctly document polymorphic page responses  #1389
+- Add `__version__` to `__init__.py` for multiapi  #1393
+
+### 2022-07-20 - 6.1.1
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Other Changes**
+
+- Get skeleton for cadl generation released  #1358
+
 ### 2022-07-20 - 6.1.0
 
 | Library                                                                 | Min Version |

package/README.md

@@ -1,4 +1,4 @@
-# Generating with Autorest for Python v5.0.0
+# Generating with Autorest for Python
 
 See [here](https://github.com/Azure/autorest.python/wiki/Generating-with-autorest-for-python-v5.0.0) for Python-specific docs, and [here] for general docs
 

package/autorest/__init__.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 import logging
 from pathlib import Path
+import json
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Union
 
@@ -21,7 +22,19 @@ _LOGGER = logging.getLogger(__name__)
 class ReaderAndWriter:
     def __init__(self, *, output_folder: Union[str, Path], **kwargs: Any) -> None:
         self.output_folder = Path(output_folder)
+        try:
+            with open(
+                Path(self.output_folder) / Path("..") / Path("python.json"), "r"
+            ) as fd:
+                python_json = json.load(fd)
+        except Exception:  # pylint: disable=broad-except
+            python_json = {}
         self.options = kwargs
+        if python_json:
+            _LOGGER.warning(
+                "Loading python.json file. This behavior will be depreacted"
+            )
+        self.options.update(python_json)
 
     def read_file(self, path: Union[str, Path]) -> str:
         """How does one read a file in cadl?"""

package/autorest/_utils.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Any, Dict
 import re
 import argparse
 
@@ -54,3 +55,21 @@ def parse_args(need_cadl_file: bool = True):
     )
 
     return parser.parse_args()
+
+
+def get_body_type_for_description(body_parameter: Dict[str, Any]) -> str:
+    if body_parameter["type"]["type"] == "binary":
+        return "binary"
+    if body_parameter["type"]["type"] == "string":
+        return "string"
+    return "JSON"
+
+
+# used if we want to get a string / binary type etc
+KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
+    "string": {"type": "string"},
+    "binary": {"type": "binary"},
+    "anydict": {"type": "dict", "elementType": {"type": "any"}},
+}
+
+JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")

package/autorest/cadlflags/__init__.py

@@ -0,0 +1,128 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Any, Dict, List
+from .. import YamlUpdatePlugin
+from .._utils import parse_args
+
+_LOGGER = logging.getLogger(__name__)
+
+OAUTH_TYPE = "OAuth2"
+KEY_TYPE = "Key"
+
+
+def get_azure_key_credential(key: str) -> Dict[str, Any]:
+    return {
+        "type": KEY_TYPE,
+        "policy": {"type": "AzureKeyCredentialPolicy", "key": key},
+    }
+
+
+class CadlFlags(YamlUpdatePlugin):  # pylint: disable=abstract-method
+    """A plugin to apply flags from backdoor python.json into cadl yaml file"""
+
+    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
+        """Convert in place the YAML str."""
+        if self.options.get("add-credential"):
+            self.update_credential(yaml_data)
+        if self.options.get("namespace"):
+            yaml_data["client"]["namespace"] = self.options["namespace"]
+        if self.options.get("title"):
+            yaml_data["client"]["name"] = self.options["title"]
+
+    def get_credential_scopes_from_flags(self, auth_policy: str) -> List[str]:
+        if self.options.get("azure-arm"):
+            return ["https://management.azure.com/.default"]
+        credential_scopes_temp = self.options.get("credential-scopes")
+        credential_scopes = (
+            credential_scopes_temp.split(",") if credential_scopes_temp else None
+        )
+        if self.options.get("credential-scopes", False) and not credential_scopes:
+            raise ValueError(
+                "--credential-scopes takes a list of scopes in comma separated format. "
+                "For example: --credential-scopes=https://cognitiveservices.azure.com/.default"
+            )
+        if not credential_scopes:
+            _LOGGER.warning(
+                "You have default credential policy %s "
+                "but not the --credential-scopes flag set while generating non-management plane code. "
+                "This is not recommend because it forces the customer to pass credential scopes "
+                "through kwargs if they want to authenticate.",
+                auth_policy,
+            )
+            credential_scopes = []
+        return credential_scopes
+
+    def get_token_credential(self, credential_scopes: List[str]) -> Dict[str, Any]:
+        return {
+            "type": OAUTH_TYPE,
+            "policy": {
+                "type": "ARMChallengeAuthenticationPolicy"
+                if self.options.get("azure-arm")
+                else "BearerTokenCredentialPolicy",
+                "credentialScopes": credential_scopes,
+            },
+        }
+
+    def update_credential_from_flags(self) -> Dict[str, Any]:
+        default_auth_policy = (
+            "ARMChallengeAuthenticationPolicy"
+            if self.options.get("azure-arm")
+            else "BearerTokenCredentialPolicy"
+        )
+        auth_policy = (
+            self.options.get("credential-default-policy-type") or default_auth_policy
+        )
+        credential_scopes = self.get_credential_scopes_from_flags(auth_policy)
+        key = self.options.get("credential-key-header-name")
+        if auth_policy.lower() in (
+            "armchallengeauthenticationpolicy",
+            "bearertokencredentialpolicy",
+        ):
+            if key:
+                raise ValueError(
+                    "You have passed in a credential key header name with default credential policy type "
+                    f"{auth_policy}. This is not allowed, since credential key header "
+                    "name is tied with AzureKeyCredentialPolicy. Instead, with this policy it is recommend you "
+                    "pass in --credential-scopes."
+                )
+            return self.get_token_credential(credential_scopes)
+        # Otherwise you have AzureKeyCredentialPolicy
+        if self.options.get("credential-scopes"):
+            raise ValueError(
+                "You have passed in credential scopes with default credential policy type "
+                "AzureKeyCredentialPolicy. This is not allowed, since credential scopes is tied with "
+                f"{default_auth_policy}. Instead, with this policy "
+                "you must pass in --credential-key-header-name."
+            )
+        if not key:
+            key = "api-key"
+            _LOGGER.info(
+                "Defaulting the AzureKeyCredentialPolicy header's name to 'api-key'"
+            )
+        return get_azure_key_credential(key)
+
+    def update_credential(self, yaml_data: Dict[str, Any]) -> None:
+        credential_type = self.update_credential_from_flags()
+        yaml_data["types"].append(credential_type)
+        credential = {
+            "type": credential_type,
+            "optional": False,
+            "description": "Credential needed for the client to connect to Azure.",
+            "clientName": "credential",
+            "location": "other",
+            "restApiName": "credential",
+            "implementation": "Client",
+            "skipUrlEncoding": True,
+            "inOverload": False,
+        }
+        yaml_data["client"]["parameters"].append(credential)
+
+
+if __name__ == "__main__":
+    # CADL pipeline will call this
+    args = parse_args()
+    CadlFlags(output_folder=args.output_folder, cadl_file=args.cadl_file).process()

package/autorest/codegen/_utils.py

@@ -5,10 +5,8 @@
 # --------------------------------------------------------------------------
 
 DEFAULT_HEADER_TEXT = (
-    "# --------------------------------------------------------------------------\n"
-    "# Copyright (c) Microsoft Corporation. All rights reserved.\n"
-    "# Licensed under the MIT License. See License.txt in the project root for license information.\n"
-    "# Code generated by Microsoft (R) Python Code Generator.\n"
-    "# Changes may cause incorrect behavior and will be lost if the code is regenerated.\n"
-    "# --------------------------------------------------------------------------"
+    "Copyright (c) Microsoft Corporation. All rights reserved.\n"
+    "Licensed under the MIT License. See License.txt in the project root for license information.\n"
+    "Code generated by Microsoft (R) Python Code Generator.\n"
+    "Changes may cause incorrect behavior and will be lost if the code is regenerated."
 )

package/autorest/codegen/models/combined_type.py

@@ -10,6 +10,7 @@ from .base_type import BaseType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class CombinedType(BaseType):
@@ -82,6 +83,9 @@ class CombinedType(BaseType):
             "You shouldn't get a JSON template representation of multiple types"
         )
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        raise ValueError("You shouldn't get polymorphic subtypes of multiple types")
+
     @property
     def instance_check_template(self) -> str:
         """Template of what an instance check of a variable for this type would look like"""

package/autorest/codegen/models/model_type.py

@@ -61,6 +61,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
             "discriminatorValue"
         )
         self._created_json_template_representation = False
+        self._got_polymorphic_subtypes = False
         self.is_public: bool = self.yaml_data.get("isPublic", True)
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
 
@@ -167,9 +168,13 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+
         is_polymorphic_subtype = (
             self.discriminator_value and not self.discriminated_subtypes
         )
+        if self._got_polymorphic_subtypes:
+            return
+        self._got_polymorphic_subtypes = True
         if (
             self.name not in (m.name for m in polymorphic_subtypes)
             and is_polymorphic_subtype
@@ -179,6 +184,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
             discriminated_subtype.get_polymorphic_subtypes(polymorphic_subtypes)
         for property in self.properties:
             property.get_polymorphic_subtypes(polymorphic_subtypes)
+        self._got_polymorphic_subtypes = False
 
     @classmethod
     def from_yaml(

package/autorest/codegen/models/parameter.py

@@ -306,6 +306,10 @@ class Parameter(_ParameterBase):
     def xml_serialization_ctxt(self) -> str:
         return self.type.xml_serialization_ctxt or ""
 
+    @property
+    def is_content_type(self) -> bool:
+        return bool(self.rest_api_name) and self.rest_api_name.lower() == "content-type"
+
     @property
     def method_location(self) -> ParameterMethodLocation:
         if not self.in_method_signature:
@@ -314,7 +318,7 @@ class Parameter(_ParameterBase):
             return ParameterMethodLocation.POSITIONAL
         if self.constant:
             return ParameterMethodLocation.KWARG
-        if self.rest_api_name == "Content-Type":
+        if self.is_content_type:
             if self.in_overload:
                 return ParameterMethodLocation.KEYWORD_ONLY
             return ParameterMethodLocation.KWARG

package/autorest/codegen/models/property.py

@@ -110,14 +110,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         from .model_type import ModelType
 
         if isinstance(self.type, ModelType):
-            is_polymorphic_subtype = (
-                self.type.discriminator_value and not self.type.discriminated_subtypes
-            )
-            if (
-                self.type.name not in (m.name for m in polymorphic_subtypes)
-                and is_polymorphic_subtype
-            ):
-                polymorphic_subtypes.append(self.type)
+            self.type.get_polymorphic_subtypes(polymorphic_subtypes)
 
     @property
     def validation(self) -> Optional[Dict[str, Any]]:

package/autorest/codegen/models/request_builder_parameter.py

@@ -95,7 +95,7 @@ class RequestBuilderParameter(Parameter):
     ) -> None:
         super().__init__(yaml_data, code_model, type)
         # we don't want any default content type behavior in request builder
-        if self.rest_api_name == "Content-Type":
+        if self.is_content_type:
             self.client_default_value = None
         if self.grouped_by and self.client_name[0] == "_":
             # we don't want hidden parameters for grouped by in request builders

package/autorest/codegen/models/response.py

@@ -55,6 +55,10 @@ class Response(BaseModel):
         self.type = type
         self.nullable = yaml_data.get("nullable")
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        if self.type:
+            self.type.get_polymorphic_subtypes(polymorphic_subtypes)
+
     def get_json_template_representation(self) -> Any:
         if not self.type:
             return None
@@ -137,6 +141,9 @@ class PagingResponse(Response):
         super().__init__(*args, **kwargs)
         self.item_type = self.code_model.lookup_type(id(self.yaml_data["itemType"]))
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        return self.item_type.get_polymorphic_subtypes(polymorphic_subtypes)
+
     def get_json_template_representation(self) -> Any:
         return self.item_type.get_json_template_representation()
 

package/autorest/codegen/models/utils.py

@@ -3,11 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import re
 from typing import TypeVar, Dict
 
-JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
-
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -531,7 +531,7 @@ class _OperationSerializer(
             polymorphic_subtypes: List[ModelType] = []
             if not response.type:
                 continue
-            response.type.get_polymorphic_subtypes(polymorphic_subtypes)
+            response.get_polymorphic_subtypes(polymorphic_subtypes)
             if polymorphic_subtypes:
                 # we just assume one kind of polymorphic body for input
                 discriminator_name = cast(
@@ -691,7 +691,9 @@ class _OperationSerializer(
             if (
                 not body_param.default_content_type
                 and not next(
-                    p for p in builder.parameters if p.rest_api_name == "Content-Type"
+                    p
+                    for p in builder.parameters
+                    if p.rest_api_name.lower() == "content-type"
                 ).optional
             ):
                 content_types = "'" + "', '".join(body_param.content_types) + "'"

package/autorest/m4reformatter/__init__.py

@@ -6,28 +6,25 @@
 # --------------------------------------------------------------------------
 """The modelerfour reformatter autorest plugin.
 """
-import re
 import copy
 import logging
 from typing import Callable, Dict, Any, Iterable, List, Optional, Set
 
-from .._utils import to_snake_case
+from .._utils import (
+    to_snake_case,
+    KNOWN_TYPES,
+    get_body_type_for_description,
+    JSON_REGEXP,
+)
 from .. import YamlUpdatePluginAutorest
 
-JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
+
 ORIGINAL_ID_TO_UPDATED_TYPE: Dict[int, Dict[str, Any]] = {}
 OAUTH_TYPE = "OAuth2"
 KEY_TYPE = "Key"
 
 _LOGGER = logging.getLogger(__name__)
 
-# used if we want to get a string / binary type etc
-KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
-    "string": {"type": "string"},
-    "binary": {"type": "binary"},
-    "anydict": {"type": "dict", "elementType": {"type": "any"}},
-}
-
 
 def is_body(yaml_data: Dict[str, Any]) -> bool:
     """Return true if passed in parameter is a body param"""
@@ -329,14 +326,6 @@ def get_all_body_types(yaml_data: Dict[str, Any]) -> List[Dict[str, Any]]:
     return list(seen_body_types.values())
 
 
-def get_body_type_for_description(body_parameter: Dict[str, Any]) -> str:
-    if body_parameter["type"]["type"] == "binary":
-        return "binary"
-    if body_parameter["type"]["type"] == "string":
-        return "string"
-    return "JSON"
-
-
 def add_lro_information(operation: Dict[str, Any], yaml_data: Dict[str, Any]) -> None:
     operation["discriminator"] = "lro"
     extensions = yaml_data["extensions"]
@@ -479,7 +468,7 @@ class M4Reformatter(
                 group_name, yaml_data, body_type, content_types=content_types
             )
             for parameter in overload["parameters"]:
-                if parameter["restApiName"] == "Content-Type":
+                if parameter["restApiName"].lower() == "content-type":
                     parameter["clientDefaultValue"] = overload["bodyParameter"][
                         "defaultContentType"
                     ]
@@ -557,23 +546,6 @@ class M4Reformatter(
             else None
         )
         content_types = None
-        if (  # pylint: disable=too-many-boolean-expressions
-            body_parameter
-            and body_parameter["type"]["type"] != "combined"
-            and yaml_data.get("requestMediaTypes")
-            and any(
-                ct for ct in yaml_data["requestMediaTypes"] if JSON_REGEXP.match(ct)
-            )
-            and body_parameter["type"]["type"] in ("model", "dict", "list")
-            and not body_parameter["type"]["xmlMetadata"]
-            and not body_parameter.get("flattened")
-            and not body_parameter.get("groupedBy")
-        ):
-            combined_type = update_types(
-                [body_parameter["type"], KNOWN_TYPES["binary"]]
-            )
-            body_parameter["type"] = combined_type
-            content_types = body_parameter["contentTypes"]
         operation = self._update_operation_helper(group_name, yaml_data, body_parameter)
         operation["overloads"] = self.update_overloads(
             group_name, yaml_data, body_parameter, content_types=content_types
@@ -843,7 +815,10 @@ class M4Reformatter(
                 continue
             if is_body(param):
                 continue
-            if param["language"]["default"].get("serializedName") == "Content-Type":
+            if (
+                param["language"]["default"].get("serializedName").lower()
+                == "content-type"
+            ):
                 param = self._update_content_type_parameter(
                     param,
                     body_parameter,

package/autorest/multiapi/templates/multiapi_init.py.jinja2

@@ -15,4 +15,8 @@ try:
     patch_sdk()
 except ImportError:
     pass
+
+from ._version import VERSION
+
+__version__ = VERSION
 {% endif %}

package/autorest/preprocess/__init__.py

@@ -5,13 +5,107 @@
 # --------------------------------------------------------------------------
 """The preprocessing autorest plugin.
 """
+import copy
 from typing import Callable, Dict, Any, List, Optional
+
 from .._utils import to_snake_case
 from .helpers import pad_reserved_words, add_redefined_builtin_info
 from .python_mappings import PadType
 
 from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
-from .._utils import parse_args
+from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES
+
+
+def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, Any]):
+    if (
+        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 not body_parameter["type"].get("xmlMetadata")
+        and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
+    ):
+        body_parameter["type"] = {
+            "type": "combined",
+            "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
+        }
+        code_model["types"].append(body_parameter["type"])
+
+
+def update_overload_section(
+    overload: Dict[str, Any],
+    yaml_data: Dict[str, Any],
+    section: str,
+):
+    for overload_s, original_s in zip(overload[section], yaml_data[section]):
+        if overload_s.get("type"):
+            overload_s["type"] = original_s["type"]
+        if overload_s.get("headers"):
+            for overload_h, original_h in zip(
+                overload_s["headers"], original_s["headers"]
+            ):
+                if overload_h.get("type"):
+                    overload_h["type"] = original_h["type"]
+
+
+def add_overload(yaml_data: Dict[str, Any], body_type: Dict[str, Any]):
+    overload = copy.deepcopy(yaml_data)
+    overload["isOverload"] = True
+    overload["bodyParameter"]["type"] = body_type
+
+    overload["overloads"] = []
+
+    # for yaml sync, we need to make sure all of the responses, parameters, and exceptions' types have the same yaml id
+    for overload_p, original_p in zip(overload["parameters"], yaml_data["parameters"]):
+        overload_p["type"] = original_p["type"]
+    update_overload_section(overload, yaml_data, "responses")
+    update_overload_section(overload, yaml_data, "exceptions")
+
+    # update content type to be an overloads content type
+    content_type_param = next(
+        p for p in overload["parameters"] if p["restApiName"].lower() == "content-type"
+    )
+    content_type_param["inOverload"] = True
+    content_type_param["inDocstring"] = True
+    body_type_description = get_body_type_for_description(overload["bodyParameter"])
+    content_type_param[
+        "description"
+    ] = f"Body Parameter content-type. Content type parameter for {body_type_description} body."
+    content_types = yaml_data["bodyParameter"]["contentTypes"]
+    if body_type["type"] == "binary" and len(content_types) > 1:
+        content_types = "'" + "', '".join(content_types) + "'"
+        content_type_param["description"] += f" Known values are: {content_types}."
+    return overload
+
+
+def add_overloads_for_body_param(yaml_data: Dict[str, Any]) -> None:
+    """If we added a body parameter type, add overloads for that type"""
+    body_parameter = yaml_data["bodyParameter"]
+    if not (
+        body_parameter["type"]["type"] == "combined"
+        and len(yaml_data["bodyParameter"]["type"]["types"])
+        > len(yaml_data["overloads"])
+    ):
+        return
+    for body_type in body_parameter["type"]["types"]:
+        if any(
+            o
+            for o in yaml_data["overloads"]
+            if id(o["bodyParameter"]["type"]) == id(body_type)
+        ):
+            continue
+        yaml_data["overloads"].append(add_overload(yaml_data, body_type))
+    content_type_param = next(
+        p for p in yaml_data["parameters"] if p["restApiName"].lower() == "content-type"
+    )
+    content_type_param["inOverload"] = False
+    content_type_param["inOverriden"] = True
+    content_type_param["inDocstring"] = True
+    content_type_param[
+        "clientDefaultValue"
+    ] = None  # make it none bc it will be overriden, we depend on default of overloads
+    content_type_param["optional"] = True
 
 
 def _remove_paging_maxpagesize(yaml_data: Dict[str, Any]) -> None:
@@ -103,7 +197,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def get_operation_updater(
         self, yaml_data: Dict[str, Any]
-    ) -> Callable[[Dict[str, Any]], None]:
+    ) -> Callable[[Dict[str, Any], Dict[str, Any]], None]:
         if yaml_data["discriminator"] == "lropaging":
             return self.update_lro_paging_operation
         if yaml_data["discriminator"] == "lro":
@@ -112,7 +206,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             return self.update_paging_operation
         return self.update_operation
 
-    def update_operation(self, yaml_data: Dict[str, Any]) -> None:
+    def update_operation(
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        *,
+        is_overload: bool = False,
+    ) -> None:
         yaml_data["groupName"] = pad_reserved_words(
             yaml_data["groupName"], PadType.OPERATION_GROUP
         )
@@ -123,6 +223,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             yaml_data["description"], yaml_data["name"]
         )
         yaml_data["summary"] = update_description(yaml_data.get("summary", ""))
+        body_parameter = yaml_data.get("bodyParameter")
         for parameter in yaml_data["parameters"]:
             update_parameter(parameter)
         if yaml_data.get("bodyParameter"):
@@ -130,9 +231,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             for entry in yaml_data["bodyParameter"].get("entries", []):
                 update_parameter(entry)
         for overload in yaml_data.get("overloads", []):
-            self.update_operation(overload)
+            self.update_operation(code_model, overload, is_overload=True)
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "operation"
+        if body_parameter and not is_overload:
+            # if we have a JSON body, we add a binary overload
+            add_body_param_type(code_model, body_parameter)
+            add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
         azure_arm = self.options.get("azure-arm", False)
@@ -157,23 +262,38 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                     else "azure.core.polling.async_base_polling.AsyncLROBasePolling"
                 )
 
-    def update_lro_paging_operation(self, yaml_data: Dict[str, Any]) -> None:
-        self.update_lro_operation(yaml_data)
-        self.update_paging_operation(yaml_data)
+    def update_lro_paging_operation(
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
+    ) -> None:
+        self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload)
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
         for overload in yaml_data.get("overloads", []):
-            self.update_lro_paging_operation(overload)
+            self.update_lro_paging_operation(code_model, overload, is_overload=True)
 
-    def update_lro_operation(self, yaml_data: Dict[str, Any]) -> None:
-        self.update_operation(yaml_data)
+    def update_lro_operation(
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
+    ) -> None:
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
 
-    def update_paging_operation(self, yaml_data: Dict[str, Any]) -> None:
-        self.update_operation(yaml_data)
+    def update_paging_operation(
+        self,
+        code_model: Dict[str, Any],
+        yaml_data: Dict[str, Any],
+        is_overload: bool = False,
+    ) -> None:
+        self.update_operation(code_model, yaml_data, is_overload=is_overload)
         if not yaml_data.get("pagerSync"):
             yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
         if not yaml_data.get("pagerAsync"):
@@ -208,7 +328,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(overload)
+            self.update_paging_operation(code_model, overload, is_overload=True)
 
     def update_operation_groups(self, yaml_data: Dict[str, Any]) -> None:
         operation_groups_yaml_data = yaml_data["operationGroups"]
@@ -223,13 +343,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 yaml_data, operation_group["className"]
             )
             for operation in operation_group["operations"]:
-                self.get_operation_updater(operation)(operation)
+                self.get_operation_updater(operation)(yaml_data, operation)
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
         update_client(yaml_data["client"])
-        update_types(yaml_data["types"])
         self.update_operation_groups(yaml_data)
+        update_types(yaml_data["types"])
 
 
 class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "6.1.0",
+    "version": "6.1.3",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -38,6 +38,7 @@
         "start.py",
         "venvtools.py",
         "run-python3.js",
-        "requirements.txt"
+        "requirements.txt",
+        "run_cadl.py"
     ]
 }

package/run_cadl.py

@@ -0,0 +1,27 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import sys
+import venv
+from pathlib import Path
+from venvtools import python_run
+
+_ROOT_DIR = Path(__file__).parent
+
+if __name__ == "__main__":
+    venv_path = _ROOT_DIR / "venv"
+    venv_prexists = venv_path.exists()
+
+    assert venv_prexists  # Otherwise install was not done
+
+    env_builder = venv.EnvBuilder(with_pip=True)
+    venv_context = env_builder.ensure_directories(venv_path)
+
+    # run m2r
+    python_run(venv_context, "autorest.m2r.__init__", command=sys.argv[1:])
+    python_run(venv_context, "autorest.preprocess.__init__", command=sys.argv[1:])
+    python_run(venv_context, "autorest.cadlflags.__init__", command=sys.argv[1:])
+    python_run(venv_context, "autorest.codegen.__init__", command=sys.argv[1:])
+    python_run(venv_context, "autorest.black.__init__", command=sys.argv[1:])