@autorest/python 6.4.2 → 6.4.3

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/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,17 @@ class _OperationSerializer(
                     if response.type.is_xml
                     else "response.json()"
                 )
-                retval.append("if response.content:")
-                retval.append(f"    deserialized = {deserialized_value}")
-                retval.append("else:")
-                retval.append("    deserialized = None")
+                deserialize_code.append("if response.content:")
+                deserialize_code.append(f"    deserialized = {deserialized_value}")
+                deserialize_code.append("else:")
+                deserialize_code.append("    deserialized = None")
+        if builder.expose_stream_keyword:
+            retval.append("if _stream:")
+            retval.append("    deserialized = response.iter_bytes()")
+            retval.append("else:")
+            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 +1126,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 = (
@@ -1559,7 +1581,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/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/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", []):
@@ -360,7 +379,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         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(
@@ -381,7 +400,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 +414,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.3",
   "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