@autorest/python 6.4.2 → 6.4.4

package/autorest/_utils.py

@@ -24,7 +24,6 @@ def to_snake_case(name: str) -> str:
             and len(name) - next_non_upper_case_char_location > 1
             and name[next_non_upper_case_char_location].isalpha()
         ):
-
             return (
                 prefix
                 + match_str[: len(match_str) - 1]

package/autorest/codegen/__init__.py

@@ -17,7 +17,6 @@ from ._utils import DEFAULT_HEADER_TEXT
 
 
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
-
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
         raise ValueError(
             "The value of --builders-visibility must be either 'public', 'hidden', "

package/autorest/codegen/models/model_type.py

@@ -163,7 +163,6 @@ class ModelType(  # pylint: disable=abstract-method
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
-
         is_polymorphic_subtype = (
             self.discriminator_value and not self.discriminated_subtypes
         )

package/autorest/codegen/models/operation.py

@@ -83,6 +83,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         )
         self.include_documentation: bool = not self.is_lro_initial_operation
 
+    @property
+    def expose_stream_keyword(self) -> bool:
+        return self.yaml_data.get("exposeStreamKeyword", False)
+
     @property
     def operation_type(self) -> str:
         return "operation"

package/autorest/codegen/models/paging_operation.py

@@ -84,17 +84,28 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if not rest_api_name:
             # That's an ok scenario, it just means no next page possible
             return None
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
     @property
     def item_name(self) -> str:
         rest_api_name = self.yaml_data["itemName"]
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
+            # we don't use the paging model for dpg
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
+    @property
+    def item_type(self) -> ModelType:
+        try:
+            item_type_yaml = self.yaml_data["itemType"]
+        except KeyError as e:
+            raise ValueError(
+                "Only call this for DPG paging model deserialization"
+            ) from e
+        return cast(ModelType, self.code_model.types_map[id(item_type_yaml)])
+
     @property
     def operation_type(self) -> str:
         return "paging"
@@ -144,6 +155,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
             )
+        if self.code_model.options["models_mode"] == "dpg":
+            file_import.merge(self.item_type.imports(**kwargs))
         return file_import
 
 

package/autorest/codegen/models/parameter_list.py

@@ -118,9 +118,9 @@ class _ParameterListBase(
 
     @staticmethod
     @abstractmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameterType
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], BodyParameterType]
+    ):
         """Callable for creating body parameters"""
 
     @property
@@ -317,9 +317,11 @@ class _ParameterList(
         return Parameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
-    ]:
+    def body_parameter_creator() -> (
+        Callable[
+            [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
+        ]
+    ):
         return get_body_parameter
 
     @property
@@ -345,15 +347,15 @@ class _RequestBuilderParameterList(
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod
-    def parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameter
-    ]:
+    def parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameter]
+    ):
         return RequestBuilderParameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType]
+    ):
         return get_request_body_parameter
 
     @property
@@ -422,9 +424,9 @@ class _ClientGlobalParameterList(  # pylint: disable=abstract-method
     """Base parameter list for client and config classes"""
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameter
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], BodyParameter]
+    ):
         return BodyParameter.from_yaml
 
     @property

package/autorest/codegen/models/request_builder.py

@@ -121,9 +121,9 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     @staticmethod
     @abstractmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], ParameterListType
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], ParameterListType]
+    ):
         ...
 
     @classmethod
@@ -178,9 +178,9 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameterList
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]
+    ):
         return RequestBuilderParameterList.from_yaml
 
 
@@ -188,9 +188,9 @@ class OverloadedRequestBuilder(
     RequestBuilderBase[OverloadedRequestBuilderParameterList]
 ):
     @staticmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]
+    ):
         return OverloadedRequestBuilderParameterList.from_yaml
 
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -639,11 +639,17 @@ class _OperationSerializer(
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
+        stream_value = (
+            'kwargs.pop("stream", False)'
+            if builder.expose_stream_keyword
+            else builder.has_stream_response
+        )
         return [
+            f"_stream = {stream_value}",
             f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    request,",
-            f"    stream={builder.has_stream_response},",
+            "    stream=_stream,",
             "    **kwargs",
             ")",
         ]
@@ -669,6 +675,11 @@ class _OperationSerializer(
 
     def param_description(self, builder: OperationType) -> List[str]:
         description_list = super().param_description(builder)
+        if builder.expose_stream_keyword:
+            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"
@@ -1014,6 +1025,7 @@ class _OperationSerializer(
 
     def response_headers_and_deserialization(
         self,
+        builder: OperationType,
         response: Response,
     ) -> List[str]:
         retval: List[str] = [
@@ -1025,8 +1037,9 @@ class _OperationSerializer(
         ]
         if response.headers:
             retval.append("")
+        deserialize_code: List[str] = []
         if response.is_stream_response:
-            retval.append(
+            deserialize_code.append(
                 "deserialized = {}".format(
                     "response.iter_bytes()"
                     if self.code_model.options["version_tolerant"]
@@ -1035,11 +1048,11 @@ class _OperationSerializer(
             )
         elif response.type:
             if self.code_model.options["models_mode"] == "msrest":
-                retval.append(
+                deserialize_code.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
             elif self.code_model.options["models_mode"] == "dpg":
-                retval.append(
+                deserialize_code.append(
                     f"deserialized = _deserialize({response.type.type_annotation(is_operation_file=True)}"
                     ", response.json())"
                 )
@@ -1049,10 +1062,18 @@ class _OperationSerializer(
                     if response.type.is_xml
                     else "response.json()"
                 )
-                retval.append("if response.content:")
-                retval.append(f"    deserialized = {deserialized_value}")
+                deserialize_code.append("if response.content:")
+                deserialize_code.append(f"    deserialized = {deserialized_value}")
+                deserialize_code.append("else:")
+                deserialize_code.append("    deserialized = None")
+        if len(deserialize_code) > 0:
+            if builder.expose_stream_keyword:
+                retval.append("if _stream:")
+                retval.append("    deserialized = response.iter_bytes()")
                 retval.append("else:")
-                retval.append("    deserialized = None")
+                retval.extend([f"    {dc}" for dc in deserialize_code])
+            else:
+                retval.extend(deserialize_code)
         return retval
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
@@ -1106,14 +1127,16 @@ class _OperationSerializer(
                             [
                                 f"    {line}"
                                 for line in self.response_headers_and_deserialization(
-                                    response
+                                    builder, response
                                 )
                             ]
                         )
                         retval.append("")
             else:
                 retval.extend(
-                    self.response_headers_and_deserialization(builder.responses[0])
+                    self.response_headers_and_deserialization(
+                        builder, builder.responses[0]
+                    )
                 )
                 retval.append("")
         type_ignore = (
@@ -1362,32 +1385,32 @@ class _PagingOperationSerializer(
             deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
             retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
-            pylint_disable = (
-                "  # pylint: disable=protected-access\n"
-                if isinstance(response.type, ModelType) and not response.type.is_public
-                else ""
-            )
-            deserialized = f"_deserialize({response.serialization_type}{pylint_disable}, pipeline_response)"
-            retval.append(
-                f"    deserialized: {response.serialization_type} = ({pylint_disable}"
-            )
-            retval.append(f"        {deserialized})")
+            # we don't want to generate paging models for DPG
+            retval.append(f"    deserialized = {deserialized}")
         else:
             retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
-        list_of_elem = (
+        access = (
             f".{item_name}"
-            if self.code_model.options["models_mode"]
+            if self.code_model.options["models_mode"] == "msrest"
             else f'["{item_name}"]'
         )
-        retval.append(f"    list_of_elem = deserialized{list_of_elem}")
+        list_of_elem_deserialized = ""
+        if self.code_model.options["models_mode"] == "dpg":
+            item_type = builder.item_type.type_annotation(is_operation_file=True)
+            list_of_elem_deserialized = (
+                f"_deserialize({item_type}, deserialized{access})"
+            )
+        else:
+            list_of_elem_deserialized = f"deserialized{access}"
+        retval.append(f"    list_of_elem = {list_of_elem_deserialized}")
         retval.append("    if cls:")
         retval.append("        list_of_elem = cls(list_of_elem) # type: ignore")
 
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
             cont_token_property = "None"
-        elif self.code_model.options["models_mode"]:
+        elif self.code_model.options["models_mode"] == "msrest":
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
             cont_token_property = (
@@ -1559,7 +1582,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 [
                     f"    {line}"
                     for line in self.response_headers_and_deserialization(
-                        builder.lro_response
+                        builder, builder.lro_response
                     )
                 ]
             )

package/autorest/codegen/serializers/general_serializer.py

@@ -83,7 +83,6 @@ class GeneralSerializer:
         )
 
     def serialize_service_client_file(self, clients: List[Client]) -> str:
-
         template = self.env.get_template("client_container.py.jinja2")
 
         imports = FileImport()

package/autorest/codegen/serializers/import_serializer.py

@@ -108,8 +108,8 @@ class FileImportSerializer:
                 "typing", "TYPE_CHECKING", ImportType.STDLIB
             )
 
-    def _get_typing_definitions(self) -> str:
-        def declare_defintion(
+    def get_typing_definitions(self) -> str:
+        def declare_definition(
             type_name: str, type_definition: TypeDefinition
         ) -> List[str]:
             ret: List[str] = []
@@ -125,7 +125,7 @@ class FileImportSerializer:
             return ""
         declarations: List[str] = [""]
         for type_name, value in self.file_import.type_definitions.items():
-            declarations.extend(declare_defintion(type_name, value))
+            declarations.extend(declare_definition(type_name, value))
         return "\n".join(declarations)
 
     def __str__(self) -> str:
@@ -151,4 +151,4 @@ class FileImportSerializer:
             typing_imports += "\n\n    ".join(
                 _get_import_clauses(typing_imports_list, "\n    ")
             )
-        return regular_imports + typing_imports + self._get_typing_definitions()
+        return regular_imports + typing_imports + self.get_typing_definitions()

package/autorest/codegen/serializers/metadata_serializer.py

@@ -16,6 +16,7 @@ from ..models import (
     CodeModel,
 )
 from .builder_serializer import get_operation_serializer
+from .import_serializer import FileImportSerializer
 
 
 def _to_string(data: Union[Tuple[Any], List[Any], str]) -> str:
@@ -91,6 +92,24 @@ def _mixin_imports(
     ), _json_serialize_imports(async_mixin_imports.to_dict())
 
 
+def _mixin_typing_definitions(
+    mixin_operation_group: Optional[OperationGroup],
+) -> Tuple[Optional[str], Optional[str]]:
+    if not mixin_operation_group:
+        return None, None
+
+    sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
+    async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
+    sync_mixin_typing_definitions = FileImportSerializer(
+        sync_mixin_imports, False
+    ).get_typing_definitions()
+    async_mixin_typing_definitions = FileImportSerializer(
+        async_mixin_imports, True
+    ).get_typing_definitions()
+
+    return sync_mixin_typing_definitions, async_mixin_typing_definitions
+
+
 class MetadataSerializer:
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         self.code_model = code_model
@@ -141,6 +160,10 @@ class MetadataSerializer:
             mixin_operation_group.operations if mixin_operation_group else []
         )
         sync_mixin_imports, async_mixin_imports = _mixin_imports(mixin_operation_group)
+        (
+            sync_mixin_typing_definitions,
+            async_mixin_typing_definitions,
+        ) = _mixin_typing_definitions(mixin_operation_group)
 
         chosen_version, total_api_version_list = self._choose_api_version()
 
@@ -161,6 +184,8 @@ class MetadataSerializer:
             str=str,
             sync_mixin_imports=sync_mixin_imports,
             async_mixin_imports=async_mixin_imports,
+            sync_mixin_typing_definitions=sync_mixin_typing_definitions,
+            async_mixin_typing_definitions=async_mixin_typing_definitions,
             sync_client_imports=_json_serialize_imports(
                 self.client.imports_for_multiapi(async_mode=False).to_dict()
             ),

package/autorest/codegen/templates/metadata.json.jinja2

@@ -115,6 +115,8 @@
     "operation_mixins": {
         "sync_imports": {{ str(sync_mixin_imports) | tojson }},
         "async_imports": {{ str(async_mixin_imports) | tojson }},
+        "sync_mixin_typing_definitions": {{ str(sync_mixin_typing_definitions) | tojson }},
+        "async_mixin_typing_definitions": {{ str(async_mixin_typing_definitions) | tojson }},
         "operations": {
             {% for operation in mixin_operations %}
             {{ operation.name | tojson }} : {

package/autorest/jsonrpc/server.py

@@ -37,7 +37,6 @@ def Process(plugin_name: str, session_id: str) -> bool:
     from .stdstream import StdStreamAutorestAPI
 
     with contextlib.closing(StdStreamAutorestAPI(session_id)) as stdstream_connection:
-
         _LOGGER.debug(
             "Autorest called process with plugin_name '%s' and session_id: '%s'",
             plugin_name,

package/autorest/m4reformatter/__init__.py

@@ -595,6 +595,19 @@ class M4Reformatter(
         operation["continuationTokenName"] = yaml_data["extensions"][
             "x-ms-pageable"
         ].get("nextLinkName")
+        returned_response_object = (
+            operation["nextOperation"]["responses"][0]
+            if operation.get("nextOperation")
+            else operation["responses"][0]
+        )
+        if self.version_tolerant:
+            # if we're in version tolerant, hide the paging model
+            returned_response_object["type"]["isPublic"] = False
+        operation["itemType"] = next(
+            p["type"]
+            for p in returned_response_object["type"]["properties"]
+            if p["restApiName"] == operation["itemName"]
+        )
         if yaml_data["language"]["default"]["paging"].get("nextLinkOperation"):
             operation["nextOperation"] = self.update_operation(
                 group_name=group_name,

package/autorest/multiapi/models/operation_mixin_group.py

@@ -31,6 +31,20 @@ class OperationMixinGroup:
                 imports.merge(current_version_imports)
         return imports
 
+    def typing_definitions(self, async_mode: bool) -> str:
+        key = (
+            "sync_mixin_typing_definitions"
+            if async_mode
+            else "async_mixin_typing_definitions"
+        )
+        origin = "".join(
+            [
+                metadata_json.get("operation_mixins", {}).get(key, "")
+                for metadata_json in self.version_path_to_metadata.values()
+            ]
+        )
+        return "\n".join(set(origin.split("\n")))
+
     def _use_metadata_of_default_api_version(
         self, mixin_operations: List[MixinOperation]
     ) -> List[MixinOperation]:

package/autorest/multiapi/serializers/__init__.py

@@ -101,7 +101,8 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         # serialize mixins
         if code_model.operation_mixin_group.mixin_operations:
             imports = FileImportSerializer(
-                code_model.operation_mixin_group.imports(async_mode)
+                code_model.operation_mixin_group.imports(async_mode),
+                code_model.operation_mixin_group.typing_definitions(async_mode),
             )
             self.write_file(
                 _get_file_path("_operations_mixin", async_mode),

package/autorest/multiapi/serializers/import_serializer.py

@@ -135,8 +135,9 @@ def _get_import_clauses(
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport) -> None:
+    def __init__(self, file_import: FileImport, typing_definitions: str = "") -> None:
         self._file_import = file_import
+        self._typing_definitions = typing_definitions
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
@@ -193,4 +194,4 @@ class FileImportSerializer:
                 _get_import_clauses(typing_imports_dict, "\n    ")
             )
 
-        return regular_imports + typing_imports
+        return regular_imports + typing_imports + self._typing_definitions

package/autorest/preprocess/__init__.py

@@ -10,11 +10,11 @@ from typing import Callable, Dict, Any, List, Optional
 
 from .._utils import to_snake_case
 from .helpers import (
-    pad_reserved_words,
     add_redefined_builtin_info,
     pad_builtin_namespaces,
+    pad_special_chars,
 )
-from .python_mappings import PadType
+from .python_mappings import CADL_RESERVED_WORDS, RESERVED_WORDS, PadType
 
 from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
 from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES
@@ -168,51 +168,6 @@ def update_operation_group_class_name(
     return class_name + "Operations"
 
 
-def update_parameter(yaml_data: Dict[str, Any]) -> None:
-    yaml_data["description"] = update_description(yaml_data["description"])
-    if not (
-        yaml_data["location"] == "header"
-        and yaml_data["clientName"] in ("content_type", "accept")
-    ):
-        yaml_data["clientName"] = pad_reserved_words(
-            yaml_data["clientName"].lower(), PadType.PARAMETER
-        )
-    if yaml_data.get("propertyToParameterName"):
-        # need to create a new one with padded keys and values
-        yaml_data["propertyToParameterName"] = {
-            pad_reserved_words(prop, PadType.PROPERTY)
-            .lower(): pad_reserved_words(param_name, PadType.PARAMETER)
-            .lower()
-            for prop, param_name in yaml_data["propertyToParameterName"].items()
-        }
-
-
-def update_types(yaml_data: List[Dict[str, Any]]) -> None:
-    for type in yaml_data:
-        for property in type.get("properties", []):
-            property["description"] = update_description(property["description"])
-            property["clientName"] = pad_reserved_words(
-                property["clientName"].lower(), PadType.PROPERTY
-            )
-            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:
-    yaml_data["description"] = update_description(
-        yaml_data["description"], default_description=yaml_data["name"]
-    )
-    yaml_data["legacyFilename"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
-    for parameter in yaml_data["parameters"]:
-        update_parameter(parameter)
-    prop_name = yaml_data["name"]
-    if prop_name.endswith("Client"):
-        prop_name = prop_name[: len(prop_name) - len("Client")]
-    yaml_data["builderPadName"] = to_snake_case(prop_name)
-
-
 def update_paging_response(yaml_data: Dict[str, Any]) -> None:
     yaml_data["discriminator"] = "paging"
     yaml_data["pagerSync"] = yaml_data.get("pagerSync") or "azure.core.paging.ItemPaged"
@@ -230,9 +185,55 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     @property
     def models_mode(self) -> Optional[str]:
-        return self.options.get(
-            "models-mode", "dpg" if self.options.get("cadl_file") else None
+        return self.options.get("models-mode", "dpg" if self.is_cadl else None)
+
+    @property
+    def is_cadl(self) -> bool:
+        return self.options.get("cadl_file", False)
+
+    def pad_reserved_words(self, name: str, pad_type: PadType):
+        # we want to pad hidden variables as well
+        if not name:
+            # we'll pass in empty operation groups sometime etc.
+            return name
+
+        if self.is_cadl:
+            reserved_words = copy.copy(CADL_RESERVED_WORDS)
+            reserved_words.update(RESERVED_WORDS)
+        else:
+            reserved_words = RESERVED_WORDS
+        name = pad_special_chars(name)
+        name_prefix = "_" if name[0] == "_" else ""
+        name = name[1:] if name[0] == "_" else name
+        if name.lower() in reserved_words[pad_type]:
+            return name_prefix + name + pad_type
+        return name_prefix + name
+
+    def update_types(self, yaml_data: List[Dict[str, Any]]) -> None:
+        for type in yaml_data:
+            for property in type.get("properties", []):
+                property["description"] = update_description(property["description"])
+                property["clientName"] = self.pad_reserved_words(
+                    property["clientName"].lower(), PadType.PROPERTY
+                )
+                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(self, yaml_data: Dict[str, Any]) -> None:
+        yaml_data["description"] = update_description(
+            yaml_data["description"], default_description=yaml_data["name"]
         )
+        yaml_data["legacyFilename"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
+        for parameter in yaml_data["parameters"]:
+            self.update_parameter(parameter)
+        prop_name = yaml_data["name"]
+        if prop_name.endswith("Client"):
+            prop_name = prop_name[: len(prop_name) - len("Client")]
+        yaml_data["builderPadName"] = to_snake_case(prop_name)
 
     def get_operation_updater(
         self, yaml_data: Dict[str, Any]
@@ -245,6 +246,24 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             return self.update_paging_operation
         return self.update_operation
 
+    def update_parameter(self, yaml_data: Dict[str, Any]) -> None:
+        yaml_data["description"] = update_description(yaml_data["description"])
+        if not (
+            yaml_data["location"] == "header"
+            and yaml_data["clientName"] in ("content_type", "accept")
+        ):
+            yaml_data["clientName"] = self.pad_reserved_words(
+                yaml_data["clientName"].lower(), PadType.PARAMETER
+            )
+        if yaml_data.get("propertyToParameterName"):
+            # need to create a new one with padded keys and values
+            yaml_data["propertyToParameterName"] = {
+                self.pad_reserved_words(prop, PadType.PROPERTY)
+                .lower(): self.pad_reserved_words(param_name, PadType.PARAMETER)
+                .lower()
+                for prop, param_name in yaml_data["propertyToParameterName"].items()
+            }
+
     def update_operation(
         self,
         code_model: Dict[str, Any],
@@ -252,23 +271,23 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         *,
         is_overload: bool = False,
     ) -> None:
-        yaml_data["groupName"] = pad_reserved_words(
+        yaml_data["groupName"] = self.pad_reserved_words(
             yaml_data["groupName"], PadType.OPERATION_GROUP
         )
         yaml_data["groupName"] = to_snake_case(yaml_data["groupName"])
         yaml_data["name"] = yaml_data["name"].lower()
-        yaml_data["name"] = pad_reserved_words(yaml_data["name"], PadType.METHOD)
+        yaml_data["name"] = self.pad_reserved_words(yaml_data["name"], PadType.METHOD)
         yaml_data["description"] = update_description(
             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)
+            self.update_parameter(parameter)
         if yaml_data.get("bodyParameter"):
-            update_parameter(yaml_data["bodyParameter"])
+            self.update_parameter(yaml_data["bodyParameter"])
             for entry in yaml_data["bodyParameter"].get("entries", []):
-                update_parameter(entry)
+                self.update_parameter(entry)
         for overload in yaml_data.get("overloads", []):
             self.update_operation(code_model, overload, is_overload=True)
         for response in yaml_data.get("responses", []):
@@ -337,30 +356,21 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
+        item_type: Optional[Dict[str, Any]] = None,
     ) -> 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"):
             yaml_data["pagerAsync"] = "azure.core.async_paging.AsyncItemPaged"
-        returned_response_object = (
-            yaml_data["nextOperation"]["responses"][0]
-            if yaml_data.get("nextOperation")
-            else yaml_data["responses"][0]
-        )
         if self.version_tolerant:
             # if we're in version tolerant, hide the paging model
-            returned_response_object["type"]["isPublic"] = False
             _remove_paging_maxpagesize(yaml_data)
-        item_type = next(
-            p["type"]["elementType"]
-            for p in returned_response_object["type"]["properties"]
-            if p["restApiName"] == (yaml_data.get("itemName") or "value")
-        )
+        item_type = item_type or yaml_data["itemType"]["elementType"]
         if yaml_data.get("nextOperation"):
             if self.version_tolerant:
                 _remove_paging_maxpagesize(yaml_data["nextOperation"])
-            yaml_data["nextOperation"]["groupName"] = pad_reserved_words(
+            yaml_data["nextOperation"]["groupName"] = self.pad_reserved_words(
                 yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP
             )
             yaml_data["nextOperation"]["groupName"] = to_snake_case(
@@ -373,7 +383,9 @@ 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(code_model, overload, is_overload=True)
+            self.update_paging_operation(
+                code_model, overload, is_overload=True, item_type=item_type
+            )
 
     def update_operation_groups(
         self, code_model: Dict[str, Any], client: Dict[str, Any]
@@ -381,7 +393,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         operation_groups_yaml_data = client["operationGroups"]
         for operation_group in operation_groups_yaml_data:
             operation_group["clientName"] = client["name"]
-            operation_group["propertyName"] = pad_reserved_words(
+            operation_group["propertyName"] = self.pad_reserved_words(
                 operation_group["propertyName"], PadType.OPERATION_GROUP
             )
             operation_group["propertyName"] = to_snake_case(
@@ -395,13 +407,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
-        update_types(yaml_data["types"])
+        self.update_types(yaml_data["types"])
         for client in yaml_data["clients"]:
-            update_client(client)
+            self.update_client(client)
             self.update_operation_groups(yaml_data, client)
         for clients in yaml_data["subnamespaceToClients"].values():
             for client in clients:
-                update_client(client)
+                self.update_client(client)
                 self.update_operation_groups(yaml_data, client)
         if yaml_data.get("namespace"):
             yaml_data["namespace"] = pad_builtin_namespaces(yaml_data["namespace"])

package/autorest/preprocess/helpers.py

@@ -6,26 +6,11 @@
 import re
 from typing import Any, Dict
 from .python_mappings import (
-    PadType,
-    RESERVED_WORDS,
     REDEFINED_BUILTINS,
     BUILTIN_PACKAGES,
 )
 
 
-def pad_reserved_words(name: str, pad_type: PadType):
-    # we want to pad hidden variables as well
-    if not name:
-        # we'll pass in empty operation groups sometime etc.
-        return name
-    name = pad_special_chars(name)
-    name_prefix = "_" if name[0] == "_" else ""
-    name = name[1:] if name[0] == "_" else name
-    if name.lower() in RESERVED_WORDS[pad_type]:
-        return name_prefix + name + pad_type
-    return name_prefix + name
-
-
 def add_redefined_builtin_info(name: str, yaml_data: Dict[str, Any]) -> None:
     if name in REDEFINED_BUILTINS:
         yaml_data["pylintDisable"] = "redefined-builtin"

package/autorest/preprocess/python_mappings.py

@@ -168,6 +168,8 @@ RESERVED_WORDS = {
     PadType.OPERATION_GROUP: [*_always_reserved],
 }
 
+CADL_RESERVED_WORDS = {PadType.PARAMETER: ["stream"]}
+
 REDEFINED_BUILTINS = [  # we don't pad, but we need to do lint ignores
     "id",
     "min",

package/package.json

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

package/requirements.txt

@@ -7,6 +7,6 @@ m2r2==0.3.3
 MarkupSafe==2.1.2
 mistune==0.8.4
 pathspec==0.11.0
-platformdirs==2.6.2
+platformdirs==3.1.0
 PyYAML==6.0
 tomli==2.0.1