@autorest/python 5.17.0 → 5.18.0

package/ChangeLog.md

@@ -1,4 +1,38 @@
-# Change Log
+# Change
+
+### 2022-07-09 - 5.18.0
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.23.0`    |
+| `msrest` dep of generated code                                          | `0.6.21`    |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Breaking Changes in Version Tolerant**
+
+- No longer allow users to specify `api_version` on the method level  #1281
+- Make `content_type` param required with no default if streaming with no `application/octet-stream`  #1288
+
+**Bug Fixes**
+
+- Fix duplicate params in signature with `--payload-flattening-threshold`  #1289
+- Fix overloaded request builder signatures  #1289
+
+### 2022-xx-xx - 5.17.1
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.23.0`    |
+| `msrest` dep of generated code                                          | `0.6.21`    |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Bug Fixes**
+
+- Improve docstring templates, specifically for polymorphic bodies  #1279
 
 ### 2022-06-02 - 5.17.0
 

package/autorest/codegen/models/base_type.py

@@ -11,6 +11,7 @@ from .imports import FileImport
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class BaseType(BaseModel, ABC):
@@ -143,6 +144,11 @@ class BaseType(BaseModel, ABC):
         """Template of what this schema would look like as JSON input"""
         ...
 
+    def get_polymorphic_subtypes(  # pylint: disable=no-self-use
+        self, polymorphic_subtypes: List["ModelType"]  # pylint: disable=unused-argument
+    ) -> None:
+        return None
+
     @property
     @abstractmethod
     def instance_check_template(self) -> str:

package/autorest/codegen/models/dictionary_type.py

@@ -3,12 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, TYPE_CHECKING
+from typing import Any, Dict, Optional, TYPE_CHECKING, List
 from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class DictionaryType(BaseType):
@@ -79,6 +80,20 @@ class DictionaryType(BaseType):
             )
         }
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        from .model_type import ModelType
+
+        if isinstance(self.element_type, ModelType):
+            is_polymorphic_subtype = (
+                self.element_type.discriminator_value
+                and not self.element_type.discriminated_subtypes
+            )
+            if (
+                self.element_type.name not in (m.name for m in polymorphic_subtypes)
+                and is_polymorphic_subtype
+            ):
+                polymorphic_subtypes.append(self.element_type)
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"

package/autorest/codegen/models/list_type.py

@@ -3,12 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, Union, TYPE_CHECKING
+from typing import Any, Dict, Optional, Union, TYPE_CHECKING, List
 from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class ListType(BaseType):
@@ -104,6 +105,20 @@ class ListType(BaseType):
             )
         ]
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        from .model_type import ModelType
+
+        if isinstance(self.element_type, ModelType):
+            is_polymorphic_subtype = (
+                self.element_type.discriminator_value
+                and not self.element_type.discriminated_subtypes
+            )
+            if (
+                self.element_type.name not in (m.name for m in polymorphic_subtypes)
+                and is_polymorphic_subtype
+            ):
+                polymorphic_subtypes.append(self.element_type)
+
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, list)"

package/autorest/codegen/models/model_type.py

@@ -47,7 +47,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         *,
         properties: Optional[List[Property]] = None,
         parents: Optional[List["ModelType"]] = None,
-        discriminated_subtypes: Optional[Dict[str, str]] = None,
+        discriminated_subtypes: Optional[Dict[str, "ModelType"]] = None,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name: str = self.yaml_data["name"]
@@ -61,6 +61,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         )
         self._created_json_template_representation = False
         self.is_public: bool = self.yaml_data.get("isPublic", True)
+        self.snake_case_name: str = self.yaml_data["snakeCaseName"]
 
     @property
     def is_xml(self) -> bool:
@@ -111,6 +112,10 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         # but we don't want to write a serialization context for an object.
         return super().xml_serialization_ctxt
 
+    @property
+    def discriminated_subtypes_name_mapping(self) -> Dict[str, str]:
+        return {k: v.name for k, v in self.discriminated_subtypes.items()}
+
     def get_json_template_representation(
         self,
         *,
@@ -121,6 +126,11 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         if self._created_json_template_representation:
             return "..."  # do this to avoid loop
         self._created_json_template_representation = True
+        if self.discriminated_subtypes:
+            # we will instead print the discriminated subtypes
+            self._created_json_template_representation = False
+            return self.snake_case_name
+
         # don't add additional properties, because there's not really a concept of
         # additional properties in the template
         representation = {
@@ -135,20 +145,30 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
                 if not (p.is_discriminator or p.client_name == "additional_properties")
             ]
         }
-        try:
-            # add discriminator prop if there is one
-            discriminator = next(p for p in self.properties if p.is_discriminator)
-            representation[discriminator.rest_api_name] = (
-                self.discriminator_value or discriminator.rest_api_name
-            )
-        except StopIteration:
-            pass
+        if self.discriminator and self.discriminator_value:
+            representation[
+                f'"{self.discriminator.rest_api_name}"'
+            ] = f'"{self.discriminator_value}"'
 
         # once we've finished, we want to reset created_json_template_representation to false
         # so we can call it again
         self._created_json_template_representation = False
         return representation
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        is_polymorphic_subtype = (
+            self.discriminator_value and not self.discriminated_subtypes
+        )
+        if (
+            self.name not in (m.name for m in polymorphic_subtypes)
+            and is_polymorphic_subtype
+        ):
+            polymorphic_subtypes.append(self)
+        for discriminated_subtype in self.discriminated_subtypes.values():
+            discriminated_subtype.get_polymorphic_subtypes(polymorphic_subtypes)
+        for property in self.properties:
+            property.get_polymorphic_subtypes(polymorphic_subtypes)
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
@@ -172,7 +192,10 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         ]
         self.properties = _get_properties(self, properties)
         # checking to see if this is a polymorphic class
-        self.discriminated_subtypes = self.yaml_data.get("discriminatedSubtypes", {})
+        self.discriminated_subtypes = {
+            k: cast(ModelType, build_type(v, code_model))
+            for k, v in self.yaml_data.get("discriminatedSubtypes", {}).items()
+        }
 
     @property
     def has_readonly_or_constant_property(self) -> bool:

package/autorest/codegen/models/parameter_list.py

@@ -416,10 +416,17 @@ class RequestBuilderParameterList(_RequestBuilderParameterList):
 class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
     """Parameter list for OverloadedRequestBuilder"""
 
-    def method_signature(self, is_python3_file: bool, async_mode: bool) -> List[str]:
-        return self.method_signature_positional(
-            is_python3_file, async_mode
-        ) + self.method_signature_kwargs(is_python3_file)
+    def method_signature_keyword_only(
+        self, is_python3_file: bool, async_mode: bool
+    ) -> List[str]:
+        """Signature for keyword only parameters"""
+        if not (self.keyword_only and is_python3_file):
+            return []
+        return ["*,"] + [
+            parameter.method_signature(is_python3_file, async_mode)
+            for parameter in self.keyword_only
+            if parameter.location != ParameterLocation.BODY
+        ]
 
 
 class _ClientGlobalParameterList(

package/autorest/codegen/models/property.py

@@ -13,6 +13,7 @@ from .utils import add_to_description, add_to_pylint_disable
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
@@ -105,6 +106,19 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             description=description,
         )
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        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)
+
     @property
     def validation(self) -> Optional[Dict[str, Any]]:
         retval: Dict[str, Any] = {}

package/autorest/codegen/models/request_builder.py

@@ -64,7 +64,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     def response_docstring_text(self, **kwargs) -> str:
         return (
             "Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
-            + "`send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to "
+            + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -30,6 +30,7 @@ from ..models import (
     OverloadedRequestBuilder,
     ConstantType,
     MultipartBodyParameter,
+    Property,
     RequestBuilderType,
 )
 from .parameter_serializer import ParameterSerializer, PopKwargType
@@ -83,6 +84,37 @@ def _json_dumps_template(template_representation: Any) -> Any:
     )
 
 
+def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[str]:
+    retval: List[str] = []
+    retval.append("")
+    retval.append(
+        f'# JSON input template for discriminator value "{polymorphic_subtype.discriminator_value}":'
+    )
+    subtype_template = _json_dumps_template(
+        polymorphic_subtype.get_json_template_representation(),
+    )
+
+    def _get_polymorphic_parent(
+        polymorphic_subtype: Optional[ModelType],
+    ) -> Optional[ModelType]:
+        if not polymorphic_subtype:
+            return None
+        try:
+            return next(
+                p for p in polymorphic_subtype.parents if p.discriminated_subtypes
+            )
+        except StopIteration:
+            return None
+
+    polymorphic_parent = _get_polymorphic_parent(polymorphic_subtype)
+    while _get_polymorphic_parent(polymorphic_parent):
+        polymorphic_parent = _get_polymorphic_parent(polymorphic_parent)
+    retval.extend(
+        f"{cast(ModelType, polymorphic_parent).snake_case_name} = {subtype_template}".splitlines()
+    )
+    return retval
+
+
 def _serialize_grouped_body(builder: BuilderType) -> List[str]:
     retval: List[str] = []
     for grouped_parameter in builder.parameters.grouped:
@@ -268,6 +300,11 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             return []
         return self.param_description(builder) + self.response_docstring(builder)
 
+    @property
+    @abstractmethod
+    def _json_response_template_name(self) -> str:
+        ...
+
     def _json_input_example_template(self, builder: BuilderType) -> List[str]:
         template: List[str] = []
         if self.code_model.options["models_mode"]:
@@ -287,14 +324,26 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         if not isinstance(body_param.type, (ListType, DictionaryType, ModelType)):
             return template
 
-        if isinstance(body_param.type, ModelType) and body_param.type.discriminator:
-            discriminator_name = body_param.type.discriminator.client_name
-            discriminator_values = body_param.type.discriminated_subtypes.keys()
+        polymorphic_subtypes: List[ModelType] = []
+        body_param.type.get_polymorphic_subtypes(polymorphic_subtypes)
+        if polymorphic_subtypes:
+            # we just assume one kind of polymorphic body for input
+            discriminator_name = cast(
+                Property, polymorphic_subtypes[0].discriminator
+            ).rest_api_name
             template.append(
-                "{} = '{}'".format(
-                    discriminator_name, "' or '".join(discriminator_values)
-                )
+                "# The input is polymorphic. The following are possible polymorphic "
+                f'inputs based off discriminator "{discriminator_name}":'
             )
+            for idx in range(
+                min(
+                    self.code_model.options["polymorphic_examples"],
+                    len(polymorphic_subtypes),
+                )
+            ):
+                template.extend(
+                    _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
+                )
             template.append("")
         template.append(
             "# JSON input template you can fill out and use as your body input."
@@ -337,7 +386,7 @@ class RequestBuilderSerializer(
     def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
-            "See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this "
+            "See https://aka.ms/azsdk/dpcodegen/python/send_request for how to incorporate this "
             "request builder into your code flow.",
             "",
         ]
@@ -351,6 +400,10 @@ class RequestBuilderSerializer(
     def serializer_name(self) -> str:
         return "_SERIALIZER"
 
+    @property
+    def _json_response_template_name(self) -> str:
+        return "response.json()"
+
     @staticmethod
     def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
         def _get_value(param):
@@ -381,7 +434,7 @@ class RequestBuilderSerializer(
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
         response_str = (
             f":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
-            + "`send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to "
+            + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
         rtype_str = f":rtype: ~azure.core.rest.HttpRequest"
@@ -473,10 +526,38 @@ class _OperationSerializer(
             retval.append("")
         return retval
 
+    @property
+    def _json_response_template_name(self) -> str:
+        return "response"
+
     def example_template(self, builder: OperationType) -> List[str]:
         retval = super().example_template(builder)
         if self.code_model.options["models_mode"]:
             return retval
+        for response in builder.responses:
+            polymorphic_subtypes: List[ModelType] = []
+            if not response.type:
+                continue
+            response.type.get_polymorphic_subtypes(polymorphic_subtypes)
+            if polymorphic_subtypes:
+                # we just assume one kind of polymorphic body for input
+                discriminator_name = cast(
+                    Property, polymorphic_subtypes[0].discriminator
+                ).rest_api_name
+                retval.append(
+                    "# The response is polymorphic. The following are possible polymorphic "
+                    f'responses based off discriminator "{discriminator_name}":'
+                )
+                for idx in range(
+                    min(
+                        self.code_model.options["polymorphic_examples"],
+                        len(polymorphic_subtypes),
+                    )
+                ):
+                    retval.extend(
+                        _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
+                    )
+
         if _get_json_response_template_to_status_codes(builder):
             retval.append("")
             for (
@@ -488,7 +569,9 @@ class _OperationSerializer(
                         ", ".join(status_codes)
                     )
                 )
-                retval.extend(f"response.json() == {response_body}".splitlines())
+                retval.extend(
+                    f"{self._json_response_template_name} == {response_body}".splitlines()
+                )
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
@@ -616,6 +699,20 @@ class _OperationSerializer(
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         if isinstance(body_param.type, BinaryType):
             retval.append(f"_{body_kwarg_name} = {body_param.client_name}")
+            if (
+                not body_param.default_content_type
+                and not next(
+                    p for p in builder.parameters if p.rest_api_name == "Content-Type"
+                ).optional
+            ):
+                content_types = "'" + "', '".join(body_param.content_types) + "'"
+                retval.extend(
+                    [
+                        "if not content_type:",
+                        f'    raise TypeError("Missing required keyword-only argument: content_type. '
+                        f'Known values are:" + "{content_types}")',
+                    ]
+                )
         else:
             retval.extend(self._serialize_body_parameter(builder))
         return retval

package/autorest/codegen/serializers/client_serializer.py

@@ -224,7 +224,7 @@ class ClientSerializer:
             retval.extend(self._rest_request_example(async_mode))
         retval.append("")
         retval.append(
-            "For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart"
+            "For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request"
         )
         retval.append(f"")
         retval.append(":param request: The network request you want to make. Required.")

package/autorest/codegen/serializers/model_base_serializer.py

@@ -127,7 +127,7 @@ class ModelBaseSerializer:
     def discriminator_docstring(model: ModelType) -> str:
         return (
             "You probably want to use the sub-classes and not this class directly. "
-            f"Known sub-classes are: {', '.join(model.discriminated_subtypes.values())}"
+            f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
         )
 
     @abstractmethod

package/autorest/codegen/serializers/utils.py

@@ -3,6 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+
+
 def method_signature_and_response_type_annotation_template(
     *,
     is_python3_file: bool,

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

@@ -45,7 +45,7 @@
     {% if model.discriminated_subtypes %}
 
     _subtype_map = {
-        '{{ model.discriminator.client_name }}': {{ str(model.discriminated_subtypes) }}
+        '{{ model.discriminator.client_name }}': {{ str(model.discriminated_subtypes_name_mapping) }}
     }
     {% endif %}
     {% if model.xml_map_content %}

package/autorest/m4reformatter/__init__.py

@@ -134,7 +134,7 @@ def update_property(
 
 def update_discriminated_subtypes(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     return {
-        obj["discriminatorValue"]: obj["language"]["default"]["name"]
+        obj["discriminatorValue"]: update_type(obj)
         for obj in yaml_data.get("discriminator", {}).get("immediate", {}).values()
     }
 
@@ -431,39 +431,6 @@ def update_client_url(yaml_data: Dict[str, Any]) -> str:
     ]["uri"]
 
 
-def update_content_type_parameter(
-    yaml_data: Dict[str, Any],
-    body_parameter: Optional[Dict[str, Any]],
-    request_media_types: List[str],
-    *,
-    in_overload: bool = False,
-    in_overriden: bool = False,
-) -> Dict[str, Any]:
-    # override content type type to string
-    if not body_parameter:
-        return yaml_data
-    param = copy.deepcopy(yaml_data)
-    param["schema"] = KNOWN_TYPES["string"]  # override to string type
-    param["required"] = False
-    description = param["language"]["default"]["description"]
-    if description and description[-1] != ".":
-        description += "."
-    if not (in_overriden or in_overload):
-        param["inDocstring"] = False
-    elif in_overload:
-        description += (
-            " Content type parameter for "
-            f"{get_body_type_for_description(body_parameter)} body."
-        )
-    elif not in_overload:
-        content_types = "'" + "', '".join(request_media_types) + "'"
-        description += f" Known values are: {content_types}."
-    if not in_overload and not in_overriden:
-        param["clientDefaultValue"] = body_parameter["defaultContentType"]
-    param["language"]["default"]["description"] = description
-    return param
-
-
 class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-methods
     """Add Python naming information."""
 
@@ -471,11 +438,23 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
     def azure_arm(self) -> bool:
         return bool(self._autorestapi.get_boolean_value("azure-arm"))
 
+    @property
+    def version_tolerant(self) -> bool:
+        return bool(self._autorestapi.get_boolean_value("version-tolerant"))
+
+    @property
+    def low_level_client(self) -> bool:
+        return bool(self._autorestapi.get_boolean_value("low-level-client"))
+
+    @property
+    def legacy(self) -> bool:
+        return not (self.version_tolerant or self.low_level_client)
+
     @property
     def default_optional_constants_to_none(self) -> bool:
         return bool(
             self._autorestapi.get_boolean_value("default-optional-constants-to-none")
-            or self._autorestapi.get_boolean_value("version-tolerant")
+            or self.version_tolerant
         )
 
     def update_overloads(
@@ -689,6 +668,9 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         body_param["defaultContentType"] = _get_default_content_type(
             body_param["contentTypes"]
         )
+        # python supports IO input with all kinds of content_types
+        if body_type["type"] == "binary":
+            body_param["contentTypes"] = content_types or list(yaml_data.keys())
         if body_param["type"]["type"] == "constant":
             if not body_param["optional"] or (
                 body_param["optional"] and not self.default_optional_constants_to_none
@@ -771,11 +753,53 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         param["inFlattenedBody"] = True
         return param
 
+    def _update_content_type_parameter(
+        self,
+        yaml_data: Dict[str, Any],
+        body_parameter: Optional[Dict[str, Any]],
+        request_media_types: List[str],
+        *,
+        in_overload: bool = False,
+        in_overriden: bool = False,
+    ) -> Dict[str, Any]:
+        # override content type type to string
+        if not body_parameter:
+            return yaml_data
+        param = copy.deepcopy(yaml_data)
+        param["schema"] = KNOWN_TYPES["string"]  # override to string type
+        if (
+            body_parameter["type"]["type"] == "binary"
+            and not body_parameter["defaultContentType"]
+            and not self.legacy
+        ):
+            param["required"] = True
+        else:
+            param["required"] = False
+        description = param["language"]["default"]["description"]
+        if description and description[-1] != ".":
+            description += "."
+        if not (in_overriden or in_overload):
+            param["inDocstring"] = False
+        elif in_overload:
+            description += (
+                " Content type parameter for "
+                f"{get_body_type_for_description(body_parameter)} body."
+            )
+        if not in_overload or (
+            body_parameter["type"]["type"] == "binary" and len(request_media_types) > 1
+        ):
+            content_types = "'" + "', '".join(request_media_types) + "'"
+            description += f" Known values are: {content_types}."
+        if not in_overload and not in_overriden:
+            param["clientDefaultValue"] = body_parameter["defaultContentType"]
+        param["language"]["default"]["description"] = description
+        return param
+
     def _update_parameters_helper(
         self,
         parameters: List[Dict[str, Any]],
         body_parameter: Optional[Dict[str, Any]],
-        seen_rest_api_names: Set[str],
+        seen_client_names: Set[str],
         groupers: Dict[str, Dict[str, Any]],
         request_media_types: List[str],
         *,
@@ -785,15 +809,17 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         retval: List[Dict[str, Any]] = []
         has_flattened_body = body_parameter and body_parameter.get("flattened")
         for param in parameters:
-            serialized_name = param["language"]["default"].get("serializedName")
+            client_name = param["language"]["default"]["name"]
             if param["language"]["default"]["name"] == "$host" or (
-                serialized_name and serialized_name in seen_rest_api_names
+                client_name in seen_client_names
             ):
                 continue
+            seen_client_names.add(client_name)
             if param.get("origin") == "modelerfour:synthesized/api-version":
                 param["inDocstring"] = False
-                param["implementation"] = "Method"
-                param["checkClientInput"] = True
+                if self.legacy:
+                    param["implementation"] = "Method"
+                    param["checkClientInput"] = True
             if has_flattened_body and param.get("targetProperty"):
                 retval.append(self.update_flattened_parameter(param, body_parameter))
                 continue
@@ -806,8 +832,8 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
                 continue
             if is_body(param):
                 continue
-            if serialized_name == "Content-Type":
-                param = update_content_type_parameter(
+            if param["language"]["default"].get("serializedName") == "Content-Type":
+                param = self._update_content_type_parameter(
                     param,
                     body_parameter,
                     request_media_types,
@@ -818,7 +844,6 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
                 param, in_overload=in_overload, in_overriden=in_overriden
             )
             retval.append(updated_param)
-            seen_rest_api_names.add(updated_param["restApiName"])
         return retval
 
     def update_parameters(
@@ -830,7 +855,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         in_overriden: bool = False,
     ) -> List[Dict[str, Any]]:
         retval: List[Dict[str, Any]] = []
-        seen_rest_api_names: Set[str] = set()
+        seen_client_names: Set[str] = set()
         groupers: Dict[str, Dict[str, Any]] = {}
         # first update top level parameters
         request_media_types = yaml_data.get("requestMediaTypes", [])
@@ -838,7 +863,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             self._update_parameters_helper(
                 yaml_data["parameters"],
                 body_parameter,
-                seen_rest_api_names,
+                seen_client_names,
                 groupers,
                 request_media_types,
                 in_overload=in_overload,
@@ -857,7 +882,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
                 self._update_parameters_helper(
                     request.get("parameters", []),
                     body_parameter,
-                    seen_rest_api_names,
+                    seen_client_names,
                     groupers,
                     request_media_types,
                     in_overload=in_overload,
@@ -921,15 +946,8 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             name = global_parameter["language"]["default"]["name"]
             if name == "$host":
                 # I am the non-parameterized endpoint. Modify name based off of flag
-                version_tolerant = self._autorestapi.get_boolean_value(
-                    "version-tolerant", False
-                )
-                low_level_client = self._autorestapi.get_boolean_value(
-                    "low-level-client", False
-                )
-                client_name = (
-                    "endpoint" if (version_tolerant or low_level_client) else "base_url"
-                )
+
+                client_name = "base_url" if self.legacy else "endpoint"
                 global_parameter["language"]["default"]["description"] = "Service URL."
             global_params.append(
                 self.update_parameter(

package/autorest/preprocess/__init__.py

@@ -62,6 +62,7 @@ def update_types(yaml_data: List[Dict[str, Any]]) -> None:
             add_redefined_builtin_info(property["clientName"], property)
         if type.get("name"):
             type["description"] = update_description(type["description"], type["name"])
+            type["snakeCaseName"] = to_snake_case(type["name"])
 
 
 def update_client(yaml_data: Dict[str, Any]) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "5.17.0",
+    "version": "5.18.0",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -27,7 +27,7 @@
         "@autorest/system-requirements": "~1.0.0"
     },
     "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "^3.3.26"
+        "@microsoft.azure/autorest.testserver": "^3.3.28"
     },
     "files": [
         "autorest/**/*.py",