@autorest/python 6.13.19 → 6.14.1

package/autorest/codegen/models/client.py

@@ -111,7 +111,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                         )
                     )
 
-        queue = self.yaml_data["operationGroups"].copy()
+        queue = self.yaml_data.get("operationGroups", []).copy()
         while queue:
             now = queue.pop(0)
             add_og_request_builder(now)
@@ -225,6 +225,13 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy",
                 ImportType.SDKCORE,
             )
+
+        # import for "Self"
+        file_import.add_submodule_import(
+            "typing_extensions",
+            "Self",
+            ImportType.STDLIB,
+        )
         return file_import
 
     @property
@@ -253,18 +260,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 if isinstance(operation, (LROOperation, LROPagingOperation)):
                     operation.initial_operation = self.lookup_operation(id(operation.yaml_data["initialOperation"]))
 
-    @property
-    def need_request_converter(self) -> bool:
-        """
-        Whether we need to convert our created azure.core.rest.HttpRequest to
-        azure.core.pipeline.transport.HttpRequest
-        """
-        return (
-            self.code_model.options["show_operations"]
-            and bool(self.request_builders)
-            and not self.code_model.options["version_tolerant"]
-        )
-
     @property
     def has_abstract_operations(self) -> bool:
         """Whether there is abstract operation in any operation group."""

package/autorest/codegen/models/code_model.py

@@ -120,11 +120,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return True
         if async_mode:
             return self.need_mixin_abc
-        return self.need_request_converter or self.need_mixin_abc or self.has_etag or self.has_form_data
-
-    @property
-    def need_request_converter(self) -> bool:
-        return any(c for c in self.clients if c.need_request_converter)
+        return self.need_mixin_abc or self.has_etag or self.has_form_data
 
     @property
     def need_mixin_abc(self) -> bool:
@@ -241,9 +237,3 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     @property
     def is_legacy(self) -> bool:
         return _is_legacy(self.options)
-
-    @property
-    def need_typing_extensions(self) -> bool:
-        if self.options["models_mode"] == "dpg":
-            return True
-        return False

package/autorest/codegen/models/model_type.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from enum import Enum
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 import sys
@@ -24,6 +25,15 @@ if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
+class UsageFlags(Enum):
+    Default = 0
+    Input = 2
+    Output = 4
+    ApiVersionEnum = 8
+    JsonMergePatch = 16
+    MultipartFormData = 32
+
+
 def _get_properties(type: "ModelType", properties: List[Property]) -> List[Property]:
     for parent in type.parents:
         # here we're adding the properties from our parents
@@ -72,6 +82,11 @@ class ModelType(  # pylint: disable=abstract-method
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
         self.page_result_model: bool = self.yaml_data.get("pageResultModel", False)
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
+        self.usage: int = self.yaml_data.get("usage", 0)
+
+    @property
+    def is_usage_output(self) -> bool:
+        return self.usage == UsageFlags.Output.value
 
     @property
     def flattened_property(self) -> Optional[Property]:

package/autorest/codegen/models/operation.py

@@ -91,6 +91,14 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         self.has_etag: bool = self.yaml_data.get("hasEtag", False)
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
 
+    @property
+    def stream_value(self) -> Union[str, bool]:
+        return (
+            f'kwargs.pop("stream", {self.has_stream_response})'
+            if self.expose_stream_keyword and self.has_response_body
+            else self.has_stream_response
+        )
+
     @property
     def has_form_data_body(self):
         return self.parameters.has_form_data_body
@@ -366,8 +374,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.add_import("warnings", ImportType.STDLIB)
 
         relative_path = "..." if async_mode else ".."
-        if self.code_model.need_request_converter:
-            file_import.add_submodule_import(f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL)
         if self.has_etag:
             file_import.add_submodule_import(
                 "exceptions",
@@ -377,32 +383,18 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             if not async_mode:
                 file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_match", ImportType.LOCAL)
                 file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_none_match", ImportType.LOCAL)
-        if self.code_model.need_request_converter:
-            if async_mode:
-                file_import.add_submodule_import(
-                    "azure.core.pipeline.transport",
-                    "AsyncHttpResponse",
-                    ImportType.SDKCORE,
-                )
-            else:
-                file_import.add_submodule_import(
-                    "azure.core.pipeline.transport",
-                    "HttpResponse",
-                    ImportType.SDKCORE,
-                )
+        if async_mode:
+            file_import.add_submodule_import(
+                "rest",
+                "AsyncHttpResponse",
+                ImportType.SDKCORE,
+            )
         else:
-            if async_mode:
-                file_import.add_submodule_import(
-                    "rest",
-                    "AsyncHttpResponse",
-                    ImportType.SDKCORE,
-                )
-            else:
-                file_import.add_submodule_import(
-                    "rest",
-                    "HttpResponse",
-                    ImportType.SDKCORE,
-                )
+            file_import.add_submodule_import(
+                "rest",
+                "HttpResponse",
+                ImportType.SDKCORE,
+            )
         if self.code_model.options["builders_visibility"] == "embedded" and not async_mode:
             file_import.merge(self.request_builder.imports())
         file_import.add_submodule_import(

package/autorest/codegen/serializers/builder_serializer.py

@@ -189,6 +189,8 @@ def _get_json_response_template_to_status_codes(
 
 
 def _api_version_validation(builder: OperationType) -> str:
+    if builder.is_overload:
+        return ""
     retval: List[str] = []
     if builder.added_on:
         retval.append(f'    method_added_on="{builder.added_on}",')
@@ -560,13 +562,8 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
-        stream_value = (
-            f'kwargs.pop("stream", {builder.has_stream_response})'
-            if builder.expose_stream_keyword and builder.has_response_body
-            else builder.has_stream_response
-        )
         return [
-            f"_stream = {stream_value}",
+            f"_stream = {builder.stream_value}",
             f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    _request,",
@@ -846,11 +843,6 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
 
     def _postprocess_http_request(self, builder: OperationType, template_url: Optional[str] = None) -> List[str]:
         retval: List[str] = []
-        if not self.code_model.options["version_tolerant"]:
-            pass_files = ""
-            if builder.parameters.has_body and builder.parameters.body_parameter.client_name == "files":
-                pass_files = ", _files"
-            retval.append(f"_request = _convert_request(_request{pass_files})")
         if builder.parameters.path:
             retval.extend(self.serialize_path(builder))
         url_to_format = "_request.url"
@@ -930,7 +922,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
             if self.code_model.options["models_mode"] == "msrest":
                 deserialize_code.append("deserialized = self._deserialize(")
                 deserialize_code.append(f"    '{response.serialization_type}',{pylint_disable}")
-                deserialize_code.append("    pipeline_response")
+                deserialize_code.append(" pipeline_response.http_response")
                 deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
                 if builder.has_stream_response:
@@ -969,13 +961,11 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
     def handle_error_response(self, builder: OperationType) -> List[str]:
         async_await = "await " if self.async_mode else ""
         retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
-        if not self.code_model.need_request_converter:
-            retval.extend(
-                [
-                    "    if _stream:",
-                    f"        {async_await} response.read()  # Load the body in memory and close the socket",
-                ]
-            )
+        response_read = f"    {async_await}response.read()  # Load the body in memory and close the socket"
+        if builder.stream_value is True:  # _stream is True so no need to judge it
+            retval.append(response_read)
+        elif isinstance(builder.stream_value, str):  # _stream is not sure, so we need to judge it
+            retval.extend(["    if _stream:", f"    {response_read}"])
         type_ignore = "  # type: ignore" if _need_type_ignore(builder) else ""
         retval.append(
             f"    map_error(status_code=response.status_code, response=response, error_map=error_map){type_ignore}"
@@ -1224,12 +1214,15 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):  #
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
         if self.code_model.options["models_mode"] == "msrest":
+            suffix = ".http_response" if hasattr(builder, "initial_operation") else ""
             deserialize_type = response.serialization_type
             pylint_disable = "  # pylint: disable=protected-access"
             if isinstance(response.type, ModelType) and not response.type.internal:
                 deserialize_type = f'"{response.serialization_type}"'
                 pylint_disable = ""
-            deserialized = f"self._deserialize(\n    {deserialize_type},{pylint_disable}\n    pipeline_response\n)"
+            deserialized = (
+                f"self._deserialize(\n    {deserialize_type},{pylint_disable}\n    pipeline_response{suffix}\n)"
+            )
             retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
             # we don't want to generate paging models for DPG
@@ -1324,6 +1317,8 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("        params=_params,")
         retval.append("        **kwargs")
         retval.append("    )")
+        retval.append(f"    {'await ' if self.async_mode else ''}raw_result.http_response.read() # type: ignore")
+
         retval.append("kwargs.pop('error_map', None)")
         return retval
 

package/autorest/codegen/serializers/general_serializer.py

@@ -87,13 +87,6 @@ class GeneralSerializer(BaseSerializer):
 
         # configure imports
         file_import = FileImport(self.code_model)
-        if self.code_model.need_request_converter:
-            file_import.add_submodule_import(
-                "azure.core.pipeline.transport",
-                "HttpRequest",
-                ImportType.SDKCORE,
-            )
-
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",

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

@@ -29,7 +29,7 @@
     {{ keywords.def }} close(self) -> None:
         {{ keywords.await }}self._client.close()
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ " -> \"" + client.name + "\"" }}:
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self) -> Self:
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self
 

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

@@ -894,5 +894,6 @@ def rest_discriminator(
     *,
     name: typing.Optional[str] = None,
     type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
+    visibility: typing.Optional[typing.List[str]] = None,
 ) -> typing.Any:
-    return _RestField(name=name, type=type, is_discriminator=True)
+    return _RestField(name=name, type=type, is_discriminator=True, visibility=visibility)

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

@@ -14,8 +14,10 @@
     {% endif %}
     {% if (model.properties | selectattr('optional', "equalto", false) | first) is defined %}
 
+    {% if not model.is_usage_output %}
     All required parameters must be populated in order to send to server.
     {% endif %}
+    {% endif %}
 
     {% if model.properties != None %}
         {% for p in model.properties %}

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -96,9 +96,7 @@ setup(
         {% else %}
         "corehttp[requests]",
         {% endif %}
-        {% if code_model.need_typing_extensions %}
         "typing-extensions>=4.6.0",
-        {% endif %}
     ],
     {% if package_mode %}
     python_requires=">=3.8",

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

@@ -3,14 +3,6 @@
 
 {{ imports }}
 
-{% if code_model.need_request_converter and not async_mode %}
-def _convert_request(request, files=None):
-    data = request.content if not files else None
-    request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
-    if files:
-        request.set_formdata_body(files)
-    return request
-{% endif %}
 {% if code_model.need_mixin_abc %}
     {% for client in clients | selectattr("has_mixin") %}
 {% set pylint_disable = "# pylint: disable=name-too-long" if (client.name | length) + ("MixinABC" | length) > 40 else "" %}

package/autorest/preprocess/__init__.py

@@ -17,7 +17,7 @@ from .helpers import (
 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
+from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES, update_enum_value
 
 
 def update_overload_section(
@@ -241,11 +241,24 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 type["snakeCaseName"] = to_snake_case(type["name"])
             if type.get("values"):
                 # we're enums
+                values_to_add = []
                 for value in type["values"]:
                     padded_name = self.pad_reserved_words(value["name"].lower(), PadType.ENUM).upper()
-                    if padded_name[0] in "0123456789":
-                        padded_name = "ENUM_" + padded_name
-                    value["name"] = padded_name
+                    if self.version_tolerant:
+                        if padded_name[0] in "0123456789":
+                            padded_name = "ENUM_" + padded_name
+                            value["name"] = padded_name
+                    else:
+                        if value["name"] != padded_name:
+                            values_to_add.append(
+                                update_enum_value(
+                                    name=padded_name,
+                                    value=value["value"],
+                                    description=value["description"],
+                                    enum_type=value["enumType"],
+                                )
+                            )
+                type["values"].extend(values_to_add)
 
         # add type for reference
         for v in HEADERS_CONVERT_IN_METHOD.values():
@@ -274,7 +287,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         if prop_name.endswith("Client"):
             prop_name = prop_name[: len(prop_name) - len("Client")]
         yaml_data["builderPadName"] = to_snake_case(prop_name)
-        for og in yaml_data["operationGroups"]:
+        for og in yaml_data.get("operationGroups", []):
             for o in og["operations"]:
                 property_if_match = None
                 property_if_none_match = None
@@ -412,12 +425,18 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
+        def convert_initial_operation_response_type(data: Dict[str, Any]) -> None:
+            for response in data.get("responses", []):
+                response["type"] = KNOWN_TYPES["binary"]
+
         self.update_operation(code_model, yaml_data, is_overload=is_overload)
         self.update_operation(code_model, yaml_data["initialOperation"], is_overload=is_overload)
+        convert_initial_operation_response_type(yaml_data["initialOperation"])
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
             self.update_operation(code_model, overload["initialOperation"], is_overload=True)
+            convert_initial_operation_response_type(overload["initialOperation"])
 
     def update_paging_operation(
         self,
@@ -443,7 +462,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             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]) -> None:
-        operation_groups_yaml_data = client["operationGroups"]
+        operation_groups_yaml_data = client.get("operationGroups", [])
         for operation_group in operation_groups_yaml_data:
             operation_group["identifyName"] = self.pad_reserved_words(
                 operation_group.get("name", operation_group["propertyName"]),
@@ -466,6 +485,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
         self.update_types(yaml_data["types"])
+        yaml_data["types"] += KNOWN_TYPES.values()
         for client in yaml_data["clients"]:
             self.update_client(client)
             self.update_operation_groups(yaml_data, client)

package/package.json

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