@autorest/python 6.1.4 → 6.1.5

package/ChangeLog.md

@@ -1,5 +1,25 @@
 # Release History
 
+### 2022-09-06 - 6.1.5
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.4`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.2`     |
+
+**Bug Fixes**
+
+- Fix `api_version` error when there are multi different `api-version`(not multiapi)   #1429
+- Fix generator raising `KeyError` in corner case when generating an LRO-paging operation  #1425
+
+**Other Changes**
+
+- Default `304` errors to throw `azure.core.exception.ResourceNotFoundError`s  #1415
+
 ### 2022-08-31 - 6.1.4
 
 | Library                                                                 | Min Version |

package/autorest/codegen/models/credential_types.py

@@ -159,18 +159,18 @@ class TokenCredentialType(
     """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             return '"AsyncTokenCredential"'
         return '"TokenCredential"'
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             return "~azure.core.credentials_async.AsyncTokenCredential"
         return "~azure.core.credentials.TokenCredential"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=no-self-use
         file_import = FileImport()
-        if kwargs.pop("async_mode"):
+        if kwargs.get("async_mode"):
             file_import.add_submodule_import(
                 "azure.core.credentials_async",
                 "AsyncTokenCredential",

package/autorest/codegen/models/operation.py

@@ -291,27 +291,22 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(self.parameters.body_parameter.type.imports(**kwargs))
 
         # Exceptions
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "map_error", ImportType.AZURECORE
-        )
+        errors = [
+            "map_error",
+            "HttpResponseError",
+            "ClientAuthenticationError",
+            "ResourceNotFoundError",
+            "ResourceExistsError",
+            "ResourceNotModifiedError",
+        ]
+        for error in errors:
+            file_import.add_submodule_import(
+                "azure.core.exceptions", error, ImportType.AZURECORE
+            )
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions",
-            "ClientAuthenticationError",
-            ImportType.AZURECORE,
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
-        )
 
         if self.has_kwargs_to_pop_with_default(
             self.parameters.kwargs_to_pop, ParameterLocation.HEADER

package/autorest/codegen/models/primitive_types.py

@@ -122,13 +122,13 @@ class BinaryIteratorType(PrimitiveType):
         return "IO"
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return "AsyncIterator[bytes]" if kwargs.pop("async_mode") else "Iterator[bytes]"
+        return "AsyncIterator[bytes]" if kwargs.get("async_mode") else "Iterator[bytes]"
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.docstring_type(**kwargs)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        iterator = "Async iterator" if kwargs.pop("async_mode") else "Iterator"
+        iterator = "Async iterator" if kwargs.get("async_mode") else "Iterator"
         return f"{iterator} of the response bytes"
 
     @property
@@ -137,7 +137,7 @@ class BinaryIteratorType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        iterator = "AsyncIterator" if kwargs.pop("async_mode") else "Iterator"
+        iterator = "AsyncIterator" if kwargs.get("async_mode") else "Iterator"
         file_import.add_submodule_import("typing", iterator, ImportType.STDLIB)
         return file_import
 

package/autorest/codegen/models/response.py

@@ -170,7 +170,7 @@ class PagingResponse(Response):
 
     def _imports_shared(self, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(**kwargs)
-        async_mode = kwargs.pop("async_mode")
+        async_mode = kwargs.get("async_mode", False)
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
@@ -179,7 +179,7 @@ class PagingResponse(Response):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(**kwargs)
-        async_mode = kwargs.pop("async_mode")
+        async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
                 "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
@@ -234,16 +234,14 @@ class LROResponse(Response):
         return self.get_base_polling_method_path(async_mode).split(".")[-1]
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return f"{self.get_poller(kwargs.pop('async_mode'))}[{super().type_annotation(**kwargs)}]"
+        return f"{self.get_poller(kwargs.get('async_mode', False))}[{super().type_annotation(**kwargs)}]"
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{super().docstring_type(**kwargs)}]"
+        return f"~{self.get_poller_path(kwargs.get('async_mode', False))}[{super().docstring_type(**kwargs)}]"
 
     def docstring_text(self, **kwargs) -> str:
         super_text = super().docstring_text(**kwargs)
-        base_description = (
-            f"An instance of {self.get_poller(kwargs.pop('async_mode'))} that returns "
-        )
+        base_description = f"An instance of {self.get_poller(kwargs.get('async_mode', False))} that returns "
         if not self.code_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + super_text
@@ -297,11 +295,11 @@ class LROResponse(Response):
 class LROPagingResponse(LROResponse, PagingResponse):
     def type_annotation(self, **kwargs: Any) -> str:
         paging_type_annotation = PagingResponse.type_annotation(self, **kwargs)
-        return f"{self.get_poller(kwargs.pop('async_mode'))}[{paging_type_annotation}]"
+        return f"{self.get_poller(kwargs.get('async_mode', False))}[{paging_type_annotation}]"
 
     def docstring_type(self, **kwargs: Any) -> str:
         paging_docstring_type = PagingResponse.docstring_type(self, **kwargs)
-        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{paging_docstring_type}]"
+        return f"~{self.get_poller_path(kwargs.get('async_mode', False))}[{paging_docstring_type}]"
 
     def docstring_text(self, **kwargs) -> str:
         base_description = (

package/autorest/codegen/serializers/builder_serializer.py

@@ -1043,6 +1043,8 @@ class _OperationSerializer(
                 retval.append("    404: ResourceNotFoundError,")
             if not 409 in builder.non_default_error_status_codes:
                 retval.append("    409: ResourceExistsError,")
+            if not 304 in builder.non_default_error_status_codes:
+                retval.append("    304: ResourceNotModifiedError,")
             for excep in builder.non_default_errors:
                 error_model_str = ""
                 if (
@@ -1071,6 +1073,11 @@ class _OperationSerializer(
                             "    409: lambda response: ResourceExistsError(response=response"
                             f"{error_model_str}{error_format_str}),"
                         )
+                    elif status_code == 304:
+                        retval.append(
+                            "    304: lambda response: ResourceNotModifiedError(response=response"
+                            f"{error_model_str}{error_format_str}),"
+                        )
                     elif not error_model_str and not error_format_str:
                         retval.append(f"    {status_code}: HttpResponseError,")
                     else:
@@ -1080,7 +1087,8 @@ class _OperationSerializer(
                         )
         else:
             retval.append(
-                "    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError"
+                "    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError, "
+                "304: ResourceNotModifiedError"
             )
         retval.append("}")
         retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")

package/autorest/m4reformatter/__init__.py

@@ -426,6 +426,10 @@ class M4Reformatter(
 ):  # pylint: disable=too-many-public-methods
     """Add Python naming information."""
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.check_client_input: bool = False
+
     @property
     def azure_arm(self) -> bool:
         return bool(self._autorestapi.get_boolean_value("azure-arm"))
@@ -802,7 +806,7 @@ class M4Reformatter(
                 param["inDocstring"] = False
                 if self.legacy:
                     param["implementation"] = "Method"
-                    param["checkClientInput"] = True
+                    param["checkClientInput"] = self.check_client_input
             if has_flattened_body and param.get("targetProperty"):
                 retval.append(self.update_flattened_parameter(param, body_parameter))
                 continue
@@ -935,6 +939,8 @@ class M4Reformatter(
 
                 client_name = "base_url" if self.legacy else "endpoint"
                 global_parameter["language"]["default"]["description"] = "Service URL."
+            elif name == "api_version":
+                self.check_client_input = True
             global_params.append(
                 self.update_parameter(
                     global_parameter, override_client_name=client_name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.1.4",
+  "version": "6.1.5",
   "description": "The Python extension for generators in AutoRest.",
   "scripts": {
     "prepare": "node run-python3.js prepare.py",