@autorest/python 6.15.0 → 6.17.0

package/generator/pygen/__init__.py

@@ -54,7 +54,7 @@ class ReaderAndWriter:
             fd.write(file_content)
 
     def list_file(self) -> List[str]:
-        return [str(f) for f in self.output_folder.glob("**/*") if f.is_file()]
+        return [str(f.relative_to(self.output_folder)) for f in self.output_folder.glob("**/*") if f.is_file()]
 
 
 class Plugin(ReaderAndWriter, ABC):

package/generator/pygen/black.py

@@ -37,15 +37,14 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
                 [
                     Path(f)
                     for f in self.list_file()
-                    if all(
-                        item not in f
-                        for item in (
-                            "__pycache__",
-                            "node_modules",
-                            ".tox",
-                            ".mypy_cache",
-                        )
+                    if Path(f).parts[0]
+                    not in (
+                        "__pycache__",
+                        "node_modules",
+                        "venv",
+                        "env",
                     )
+                    and not Path(f).parts[0].startswith(".")
                     and Path(f).suffix == ".py"
                 ],
             )

package/generator/pygen/codegen/__init__.py

@@ -164,6 +164,10 @@ class OptionsRetriever:
         except AttributeError:
             return packaging_files_config
 
+    @property
+    def package_version(self) -> Optional[str]:
+        return str(self.options.get("package-version", ""))
+
 
 class CodeGenerator(Plugin):
     def __init__(self, *args, **kwargs: Any) -> None:

package/generator/pygen/codegen/models/client.py

@@ -18,6 +18,7 @@ from .request_builder import (
 from .parameter import Parameter, ParameterMethodLocation
 from .lro_operation import LROOperation
 from .lro_paging_operation import LROPagingOperation
+from ...utils import extract_original_name
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -92,7 +93,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 if operation_yaml.get("isLroInitialOperation"):
                     # we want to change the name
                     request_builder.name = request_builder.get_name(
-                        request_builder.yaml_data["name"][1 : -len("_initial")],
+                        extract_original_name(request_builder.yaml_data["name"]),
                         request_builder.yaml_data,
                         request_builder.code_model,
                         request_builder.client,

package/generator/pygen/codegen/models/model_type.py

@@ -32,6 +32,10 @@ class UsageFlags(Enum):
     ApiVersionEnum = 8
     JsonMergePatch = 16
     MultipartFormData = 32
+    Spread = 64
+    Error = 128
+    Json = 256
+    Xml = 512
 
 
 def _get_properties(type: "ModelType", properties: List[Property]) -> List[Property]:
@@ -86,7 +90,7 @@ class ModelType(  # pylint: disable=abstract-method
 
     @property
     def is_usage_output(self) -> bool:
-        return self.usage == UsageFlags.Output.value
+        return self.usage & UsageFlags.Output.value
 
     @property
     def flattened_property(self) -> Optional[Property]:

package/generator/pygen/codegen/models/operation.py

@@ -343,6 +343,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             "ResourceExistsError",
             "ResourceNotModifiedError",
         ]
+        if self.stream_value:
+            errors.extend(["StreamConsumedError", "StreamClosedError"])
         for error in errors:
             file_import.add_submodule_import("exceptions", error, ImportType.SDKCORE)
         if self.code_model.options["azure_arm"]:

package/generator/pygen/codegen/serializers/__init__.py

@@ -555,6 +555,10 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
 
         for client in self.code_model.clients:
             for og in client.operation_groups:
+                if self.code_model.options["multiapi"] and any(
+                    o.api_versions[0] != self.code_model.options["default_api_version"] for o in og.operations
+                ):
+                    continue
                 test_serializer = TestSerializer(self.code_model, env, client=client, operation_group=og)
                 for is_async in (True, False):
                     try:

package/generator/pygen/codegen/serializers/builder_serializer.py

@@ -58,6 +58,10 @@ OperationType = TypeVar(
 )
 
 
+def _all_same(data: List[List[str]]) -> bool:
+    return len(data) > 1 and all(sorted(data[0]) == sorted(data[i]) for i in range(1, len(data)))
+
+
 def _json_serializable(content_type: str) -> bool:
     return bool(JSON_REGEXP.match(content_type.split(";")[0].strip().lower()))
 
@@ -410,14 +414,19 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # p
         return "response.json()"
 
     @staticmethod
-    def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
+    def declare_non_inputtable_headers_queries(builder: RequestBuilderType) -> List[str]:
         def _get_value(param):
+            declaration = param.get_declaration() if param.constant else None
             if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
                 kwarg_dict = "headers" if param.location == ParameterLocation.HEADER else "params"
-                return f"_{kwarg_dict}.pop('{param.wire_name}', {param.get_declaration()})"
-            return f"{param.get_declaration()}"
+                return f"_{kwarg_dict}.pop('{param.wire_name}', {declaration})"
+            return declaration
 
-        return [f"{p.client_name} = {_get_value(p)}" for p in builder.parameters.constant if not p.in_method_signature]
+        return [
+            f"{p.client_name} = {_get_value(p)}"
+            for p in (builder.parameters.headers + builder.parameters.query)
+            if not p.in_method_signature
+        ]
 
     @property
     def _function_def(self) -> str:
@@ -561,16 +570,22 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
+        retval = []
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
-        return [
-            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,",
-            "    stream=_stream,",
-            "    **kwargs",
-            ")",
-        ]
+        if builder.stream_value is True and not self.code_model.options["version_tolerant"]:
+            retval.append("_decompress = kwargs.pop('decompress', True)")
+        retval.extend(
+            [
+                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,",
+                "    stream=_stream,",
+                "    **kwargs",
+                ")",
+            ]
+        )
+        return retval
 
     @property
     def _function_def(self) -> str:
@@ -894,6 +909,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         builder: OperationType,
         response: Response,
     ) -> List[str]:
+        return self.response_headers(response) + self.response_deserialization(builder, response)
+
+    def response_headers(self, response: Response) -> List[str]:
         retval: List[str] = [
             (
                 f"response_headers['{response_header.wire_name}']=self._deserialize("
@@ -903,6 +921,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         ]
         if response.headers:
             retval.append("")
+        return retval
+
+    def response_deserialization(
+        self,
+        builder: OperationType,
+        response: Response,
+    ) -> List[str]:
+        retval: List[str] = []
         deserialize_code: List[str] = []
         stream_logic = True
         if builder.has_stream_response:
@@ -913,7 +939,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
                 if self.code_model.options["version_tolerant"]:
                     deserialized = "response.iter_bytes()"
                 else:
-                    deserialized = f"response.stream_download(self._client.{self.pipeline_name})"
+                    deserialized = (
+                        f"response.stream_download(self._client.{self.pipeline_name}, decompress=_decompress)"
+                    )
             deserialize_code.append(f"deserialized = {deserialized}")
         elif response.type:
             pylint_disable = ""
@@ -961,11 +989,17 @@ 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)}:"]
-        response_read = f"    {async_await}response.read()  # Load the body in memory and close the socket"
+        response_read = [
+            "    try:",
+            f"        {async_await}response.read()  # Load the body in memory and close the socket",
+            "    except (StreamConsumedError, StreamClosedError):",
+            "        pass",
+        ]
         if builder.stream_value is True:  # _stream is True so no need to judge it
-            retval.append(response_read)
+            retval.extend(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}"])
+            retval.append("    if _stream:")
+            retval.extend([f"    {l}" for l in 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}"
@@ -999,13 +1033,34 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
             retval.append("response_headers = {}")
         if builder.has_response_body or builder.any_response_has_headers:
             if len(builder.responses) > 1:
+                status_codes, res_headers, res_deserialization = [], [], []
                 for status_code in builder.success_status_codes:
                     response = builder.get_response_from_status(status_code)
                     if response.headers or response.type:
+                        status_codes.append(status_code)
+                        res_headers.append(self.response_headers(response))
+                        res_deserialization.append(self.response_deserialization(builder, response))
+
+                is_headers_same = _all_same(res_headers)
+                is_deserialization_same = _all_same(res_deserialization)
+                if is_deserialization_same:
+                    if is_headers_same:
+                        retval.extend(res_headers[0])
+                        retval.extend(res_deserialization[0])
+                        retval.append("")
+                    else:
+                        for status_code, headers in zip(status_codes, res_headers):
+                            if headers:
+                                retval.append(f"if response.status_code == {status_code}:")
+                                retval.extend([f"    {line}" for line in headers])
+                                retval.append("")
+                        retval.extend(res_deserialization[0])
+                        retval.append("")
+                else:
+                    for status_code, headers, deserialization in zip(status_codes, res_headers, res_deserialization):
                         retval.append(f"if response.status_code == {status_code}:")
-                        retval.extend(
-                            [f"    {line}" for line in self.response_headers_and_deserialization(builder, response)]
-                        )
+                        retval.extend([f"    {line}" for line in headers])
+                        retval.extend([f"    {line}" for line in deserialization])
                         retval.append("")
             else:
                 retval.extend(self.response_headers_and_deserialization(builder, builder.responses[0]))

package/generator/pygen/codegen/serializers/parameter_serializer.py

@@ -148,7 +148,7 @@ class ParameterSerializer:
             param.wire_name,
             ParameterSerializer.serialize_parameter(param, serializer_name),
         )
-        if not param.optional:
+        if not param.optional and (param.in_method_signature or param.constant):
             retval = [set_parameter]
         else:
             retval = [

package/generator/pygen/codegen/templates/model_base.py.jinja2

@@ -576,6 +576,7 @@ class Model(_MyMutableMapping):
         """
 
         result = {}
+        readonly_props = []
         if exclude_readonly:
             readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)]
         for k, v in self.items():

package/generator/pygen/codegen/templates/request_builder.py.jinja2

@@ -8,8 +8,8 @@
         {% if request_builder_serializer.pop_kwargs_from_signature(request_builder) %}
     {{ op_tools.serialize(request_builder_serializer.pop_kwargs_from_signature(request_builder)) | indent }}
         {%- endif -%}
-    {% if request_builder_serializer.declare_non_inputtable_constants(request_builder) %}
-    {{ op_tools.serialize(request_builder_serializer.declare_non_inputtable_constants(request_builder)) | indent }}
+    {% if request_builder_serializer.declare_non_inputtable_headers_queries(request_builder) %}
+    {{ op_tools.serialize(request_builder_serializer.declare_non_inputtable_headers_queries(request_builder)) | indent }}
         {% endif %}
     # Construct URL
     {{ request_builder_serializer.construct_url(request_builder) }}

package/generator/pygen/preprocess/__init__.py

@@ -8,7 +8,7 @@
 import copy
 from typing import Callable, Dict, Any, List, Optional
 
-from ..utils import to_snake_case
+from ..utils import to_snake_case, extract_original_name
 from .helpers import (
     add_redefined_builtin_info,
     pad_builtin_namespaces,
@@ -235,7 +235,8 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 property["clientName"] = self.pad_reserved_words(property["clientName"].lower(), PadType.PROPERTY)
                 add_redefined_builtin_info(property["clientName"], property)
             if type.get("name"):
-                name = self.pad_reserved_words(type["name"], PadType.MODEL)
+                pad_type = PadType.MODEL if type["type"] == "model" else PadType.ENUM_CLASS
+                name = self.pad_reserved_words(type["name"], pad_type)
                 type["name"] = name[0].upper() + name[1:]
                 type["description"] = update_description(type.get("description", ""), type["name"])
                 type["snakeCaseName"] = to_snake_case(type["name"])
@@ -243,7 +244,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 # we're enums
                 values_to_add = []
                 for value in type["values"]:
-                    padded_name = self.pad_reserved_words(value["name"].lower(), PadType.ENUM).upper()
+                    padded_name = self.pad_reserved_words(value["name"].lower(), PadType.ENUM_VALUE).upper()
                     if self.version_tolerant:
                         if padded_name[0] in "0123456789":
                             padded_name = "ENUM_" + padded_name
@@ -362,7 +363,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         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"] = self.pad_reserved_words(yaml_data["name"], PadType.METHOD)
+        if yaml_data.get("isLroInitialOperation") is True:
+            yaml_data["name"] = (
+                "_" + self.pad_reserved_words(extract_original_name(yaml_data["name"]), PadType.METHOD) + "_initial"
+            )
+        else:
+            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")

package/generator/pygen/preprocess/python_mappings.py

@@ -53,9 +53,10 @@ basic_latin_chars = {
 
 class PadType(str, Enum):
     MODEL = "Model"
+    ENUM_CLASS = "Enum"
     METHOD = "_method"
     PARAMETER = "_parameter"
-    ENUM = "_enum"
+    ENUM_VALUE = "_enum"
     PROPERTY = "_property"
     OPERATION_GROUP = "Operations"
 
@@ -175,9 +176,10 @@ RESERVED_WORDS = {
         "retry_on_status_codes",
         *_always_reserved,
     ],
-    PadType.MODEL: [*_always_reserved],
+    PadType.MODEL: ["enum", *_always_reserved],
     PadType.PROPERTY: ["self", *_always_reserved],
-    PadType.ENUM: ["mro", *_always_reserved],
+    PadType.ENUM_CLASS: ["enum", *_always_reserved],
+    PadType.ENUM_VALUE: ["mro", *_always_reserved],
     PadType.OPERATION_GROUP: [*_always_reserved],
 }
 

package/generator/pygen/utils.py

@@ -147,3 +147,7 @@ def build_policies(
             "self._config.logging_policy",
         ]
     return [p for p in policies if p]
+
+
+def extract_original_name(name: str) -> str:
+    return name[1 : -len("_initial")]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.15.0",
+  "version": "6.17.0",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@microsoft.azure/autorest.testserver": "^3.3.46",
     "typescript": "~5.1.3",
-    "@azure-tools/typespec-python": "^0.25.0"
+    "@azure-tools/typespec-python": "^0.27.0"
   },
   "files": [
     "autorest/**/*.py",