@autorest/python 6.7.0 → 6.7.2

package/autorest/black/__init__.py

@@ -52,6 +52,9 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
             )
         except NothingChanged:
             pass
+        except:  # pylint: disable=bare-except
+            _LOGGER.error("Error: failed to format %s", file)
+            raise
         self.write_file(file, file_content)
 
 

package/autorest/codegen/models/__init__.py

@@ -28,6 +28,7 @@ from .primitive_types import (
     BooleanType,
     AnyObjectType,
     UnixTimeType,
+    AzureCoreType,
 )
 from .enum_type import EnumType
 from .base import BaseType
@@ -144,6 +145,7 @@ TYPE_TO_OBJECT = {
     "any-object": AnyObjectType,
     "unixtime": UnixTimeType,
     "credential": StringType,
+    "azurecore": AzureCoreType,
 }
 _LOGGER = logging.getLogger(__name__)
 

package/autorest/codegen/models/client.py

@@ -76,6 +76,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 for op_group in self.yaml_data.get("operationGroups", [])
             ]
             self.link_lro_initial_operations()
+        self.request_id_header_name = self.yaml_data.get("requestIdHeaderName", None)
+        self.has_etag: bool = yaml_data.get("hasEtag", False)
 
     def _build_request_builders(
         self,

package/autorest/codegen/models/code_model.py

@@ -15,10 +15,10 @@ from .constant_type import ConstantType
 
 
 def _is_legacy(options) -> bool:
-    return not (options["version_tolerant"] or options["low_level_client"])
+    return not (options.get("version_tolerant") or options.get("low_level_client"))
 
 
-class CodeModel:  # pylint: disable=too-many-public-methods
+class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-instance-attributes
     """Top level code model
 
     :param options: Options of the code model. I.e., whether this is for management generation
@@ -77,6 +77,10 @@ class CodeModel:  # pylint: disable=too-many-public-methods
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
 
+    @property
+    def has_etag(self) -> bool:
+        return any(client.has_etag for client in self.clients)
+
     @property
     def has_operations(self) -> bool:
         if any(c for c in self.clients if c.has_operations):

package/autorest/codegen/models/dictionary_type.py

@@ -30,6 +30,10 @@ class DictionaryType(BaseType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
 
+    @property
+    def format(self) -> Optional[str]:
+        return self.element_type.format if hasattr(self.element_type, "format") else None  # type: ignore
+
     @property
     def serialization_type(self) -> str:
         """Returns the serialization value for msrest.

package/autorest/codegen/models/list_type.py

@@ -25,6 +25,10 @@ class ListType(BaseType):
         self.min_items: Optional[int] = yaml_data.get("minItems")
         self.unique_items: bool = yaml_data.get("uniqueItems", False)
 
+    @property
+    def format(self) -> Optional[str]:
+        return self.element_type.format if hasattr(self.element_type, "format") else None  # type: ignore
+
     @property
     def serialization_type(self) -> str:
         return f"[{self.element_type.serialization_type}]"

package/autorest/codegen/models/operation.py

@@ -90,6 +90,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         self.internal: bool = self.yaml_data.get("internal", False)
         if self.internal:
             self.name = "_" + self.name
+        self.has_etag: bool = self.yaml_data.get("hasEtag", False)
 
     @property
     def expose_stream_keyword(self) -> bool:
@@ -331,7 +332,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         return file_import
 
-    def imports(  # pylint: disable=too-many-branches
+    def imports(  # pylint: disable=too-many-branches, disable=too-many-statements
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
         if self.abstract:
@@ -394,11 +395,22 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
+        relative_path = "..." if async_mode else ".."
         if self.code_model.need_request_converter:
-            relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
+        if self.has_etag:
+            file_import.add_submodule_import(
+                "azure.core.exceptions", "ResourceModifiedError", ImportType.AZURECORE
+            )
+            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(

package/autorest/codegen/models/parameter.py

@@ -52,9 +52,6 @@ class ParameterDelimeter(str, Enum):
     COMMA = "comma"
 
 
-SPECIAL_HANDLE_HEADERS = ["repeatability-request-id", "repeatability-first-sent"]
-
-
 class _ParameterBase(
     BaseModel, abc.ABC
 ):  # pylint: disable=too-many-instance-attributes
@@ -93,10 +90,7 @@ class _ParameterBase(
         self.default_to_unset_sentinel: bool = self.yaml_data.get(
             "defaultToUnsetSentinel", False
         )
-        self.is_special_handle_header: bool = (
-            self.location == ParameterLocation.HEADER
-            and self.wire_name.lower() in SPECIAL_HANDLE_HEADERS
-        )
+        self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
 
     @property
     def constant(self) -> bool:

package/autorest/codegen/models/parameter_list.py

@@ -215,7 +215,7 @@ class _ParameterListBase(
             for p in self.parameters
             if p.in_method_signature
             and p.implementation == self.implementation
-            and not p.is_special_handle_header
+            and (self.code_model.is_legacy or not p.hide_in_method)
         ]
         if self._body_parameter:
             if self._body_parameter.in_method_signature:

package/autorest/codegen/models/primitive_types.py

@@ -4,7 +4,6 @@
 # license information.
 # --------------------------------------------------------------------------
 import datetime
-from enum import Enum
 from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base import BaseType
@@ -356,17 +355,17 @@ class StringType(PrimitiveType):
 class DatetimeType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.format = self.Formats(yaml_data.get("format", "date-time"))
-
-    class Formats(str, Enum):
-        datetime = "date-time"
-        rfc1123 = "date-time-rfc1123"
+        self.format = (
+            "rfc3339"
+            if yaml_data.get("format", "date-time") == "date-time"
+            else "rfc7231"
+        )
 
     @property
     def serialization_type(self) -> str:
         formats_to_attribute_type = {
-            self.Formats.datetime: "iso-8601",
-            self.Formats.rfc1123: "rfc-1123",
+            "rfc3339": "iso-8601",
+            "rfc7231": "rfc-1123",
         }
         return formats_to_attribute_type[self.format]
 
@@ -454,6 +453,10 @@ class TimeType(PrimitiveType):
 
 
 class UnixTimeType(PrimitiveType):
+    @property
+    def format(self) -> str:
+        return "unix-timestamp"
+
     @property
     def serialization_type(self) -> str:
         return "unix-time"
@@ -588,7 +591,7 @@ class DurationType(PrimitiveType):
 class ByteArraySchema(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.format = yaml_data.get("format", "bytes")
+        self.format = yaml_data.get("format", "base64")
 
     @property
     def serialization_type(self) -> str:
@@ -605,3 +608,28 @@ class ByteArraySchema(PrimitiveType):
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, bytes)"
+
+
+class AzureCoreType(PrimitiveType):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name = yaml_data.get("name", "")
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return "~azure.core." + self.type_annotation(**kwargs)
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.name
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        file_import.add_submodule_import("azure.core", self.name, ImportType.AZURECORE)
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return f"isinstance({{}}, {self.name})"
+
+    @property
+    def serialization_type(self) -> str:
+        return self.name

package/autorest/codegen/serializers/__init__.py

@@ -52,6 +52,7 @@ _PACKAGE_FILES = [
 
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
 
+
 # extract sub folders. For example, source_file_path is like:
 # "xxx/resource-manager/Microsoft.XX/stable/2023-04-01/examples/Compute/createOrUpdate/AKSCompute.json",
 # and we want to extract the sub folders after "examples/", which is "compute/create_or_update"

package/autorest/codegen/serializers/builder_serializer.py

@@ -18,7 +18,6 @@ from ..models import (
     ModelType,
     DictionaryType,
     ListType,
-    Parameter,
     RequestBuilder,
     ParameterLocation,
     Response,
@@ -422,36 +421,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         )
         return template
 
-    def _serialize_parameter(self, param: Parameter, kwarg_name: str) -> List[str]:
-        set_parameter = "_{}['{}'] = {}".format(
-            kwarg_name,
-            param.wire_name,
-            self.parameter_serializer.serialize_parameter(param, self.serializer_name),
-        )
-        if not param.optional:
-            retval = [set_parameter]
-        else:
-            retval = [
-                f"if {param.full_client_name} is not None:",
-                f"    {set_parameter}",
-            ]
-        return retval
-
-    @staticmethod
-    def _serialize_special_handle_header(param: Parameter) -> List[str]:
-        if param.wire_name.lower() == "repeatability-request-id":
-            return [
-                """if "Repeatability-Request-ID" not in _headers:""",
-                """    _headers["Repeatability-Request-ID"] = str(uuid.uuid4())""",
-            ]
-        if param.wire_name.lower() == "repeatability-first-sent":
-            return [
-                """if "Repeatability-First-Sent" not in _headers:""",
-                """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(datetime.datetime.now(),
-                "rfc-1123")""",
-            ]
-        raise ValueError(f"Unsupported special header: {param}")
-
     def serialize_path(self, builder: BuilderType) -> List[str]:
         return self.parameter_serializer.serialize_path(
             builder.parameters.path, self.serializer_name
@@ -563,24 +532,25 @@ class RequestBuilderSerializer(
     def serialize_headers(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct headers"]
         for parameter in builder.parameters.headers:
-            if parameter.is_special_handle_header:
-                retval.extend(self._serialize_special_handle_header(parameter))
-            else:
-                retval.extend(
-                    self._serialize_parameter(
-                        parameter,
-                        kwarg_name="headers",
-                    )
+            retval.extend(
+                self.parameter_serializer.serialize_query_header(
+                    parameter,
+                    "headers",
+                    self.serializer_name,
+                    self.code_model.is_legacy,
                 )
+            )
         return retval
 
     def serialize_query(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct parameters"]
         for parameter in builder.parameters.query:
             retval.extend(
-                self._serialize_parameter(
+                self.parameter_serializer.serialize_query_header(
                     parameter,
-                    kwarg_name="params",
+                    "params",
+                    self.serializer_name,
+                    self.code_model.is_legacy,
                 )
             )
         return retval
@@ -1119,9 +1089,17 @@ class _OperationSerializer(
         return retval
 
     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",
+                ]
+            )
         retval.append(
             "    map_error(status_code=response.status_code, response=response, error_map=error_map)"
         )
@@ -1283,6 +1261,17 @@ class _OperationSerializer(
                 "304: ResourceNotModifiedError"
             )
         retval.append("}")
+        if builder.has_etag:
+            retval.extend(
+                [
+                    "if match_condition == MatchConditions.IfNotModified:",
+                    "    error_map[412] = ResourceModifiedError",
+                    "elif match_condition == MatchConditions.IfPresent:",
+                    "    error_map[412] = ResourceNotFoundError",
+                    "elif match_condition == MatchConditions.IfMissing:",
+                    "    error_map[412] = ResourceExistsError",
+                ]
+            )
         retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")
         return retval
 

package/autorest/codegen/serializers/client_serializer.py

@@ -109,9 +109,15 @@ class ClientSerializer:
 
     def initialize_pipeline_client(self, async_mode: bool) -> str:
         pipeline_client_name = self.client.pipeline_class(async_mode)
+        params = {
+            "base_url": self.host_variable_name,
+            "config": "self._config",
+        }
+        if not self.client.code_model.is_legacy and self.client.request_id_header_name:
+            params["request_id_header_name"] = f'"{self.client.request_id_header_name}"'
         return (
-            f"self._client: {pipeline_client_name} = {pipeline_client_name}(base_url={self.host_variable_name}, "
-            "config=self._config, **kwargs)"
+            f"self._client: {pipeline_client_name} = {pipeline_client_name}("
+            f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)"
         )
 
     def serializers_and_operation_groups_properties(self) -> List[str]:

package/autorest/codegen/serializers/general_serializer.py

@@ -133,6 +133,13 @@ class GeneralSerializer:
                     f"{client.name}Configuration",
                     ImportType.LOCAL,
                 )
+        if self.code_model.has_etag:
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+            file_import.add_submodule_import(
+                "azure.core",
+                "MatchConditions",
+                ImportType.AZURECORE,
+            )
 
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/model_serializer.py

@@ -255,13 +255,13 @@ class DpgModelSerializer(_ModelSerializer):
         args = []
         if prop.client_name != prop.wire_name or prop.is_discriminator:
             args.append(f'name="{prop.wire_name}"')
-        if prop.readonly:
-            args.append("readonly=True")
         if prop.visibility:
             v_list = ", ".join(f'"{x}"' for x in prop.visibility)
             args.append(f"visibility=[{v_list}]")
         if prop.client_default_value is not None:
             args.append(f"default={prop.client_default_value_declaration}")
+        if hasattr(prop.type, "format") and prop.type.format:  # type: ignore
+            args.append(f'format="{prop.type.format}"')  # type: ignore
 
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
         type_ignore = (

package/autorest/codegen/serializers/parameter_serializer.py

@@ -3,10 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Sequence, Union, Optional
+from typing import List, Sequence, Union, Optional, Dict
 from enum import Enum, auto
 
-
 from ..models import (
     Parameter,
     ParameterLocation,
@@ -26,6 +25,32 @@ class PopKwargType(Enum):
     CASE_INSENSITIVE = auto()
 
 
+SPECIAL_HEADER_SERIALIZATION: Dict[str, List[str]] = {
+    "repeatability-request-id": [
+        """if "Repeatability-Request-ID" not in _headers:""",
+        """    _headers["Repeatability-Request-ID"] = str(uuid.uuid4())""",
+    ],
+    "repeatability-first-sent": [
+        """if "Repeatability-First-Sent" not in _headers:""",
+        """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(datetime.datetime.now(),
+        "rfc-1123")""",
+    ],
+    "client-request-id": [],
+    "x-ms-client-request-id": [],
+    "return-client-request-id": [],
+    "etag": [
+        """if_match = prep_if_match(etag, match_condition)""",
+        """if if_match is not None:""",
+        """    _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str")""",
+    ],
+    "match-condition": [
+        """if_none_match = prep_if_none_match(etag, match_condition)""",
+        """if if_none_match is not None:""",
+        """    _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")""",
+    ],
+}
+
+
 class ParameterSerializer:
     @staticmethod
     def serialize_parameter(parameter: ParameterType, serializer_name: str) -> str:
@@ -81,8 +106,8 @@ class ParameterSerializer:
             return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
         return serialize_line
 
+    @staticmethod
     def serialize_path(
-        self,
         parameters: Union[
             List[Parameter],
             List[RequestBuilderParameter],
@@ -96,7 +121,9 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    self.serialize_parameter(path_parameter, serializer_name),
+                    ParameterSerializer.serialize_parameter(
+                        path_parameter, serializer_name
+                    ),
                 )
                 for path_parameter in parameters
             ]
@@ -104,6 +131,34 @@ class ParameterSerializer:
         retval.append("}")
         return retval
 
+    @staticmethod
+    def serialize_query_header(
+        param: Parameter,
+        kwarg_name: str,
+        serializer_name: str,
+        is_legacy: bool,
+    ) -> List[str]:
+        if (
+            not is_legacy
+            and param.location == ParameterLocation.HEADER
+            and param.wire_name.lower() in SPECIAL_HEADER_SERIALIZATION
+        ):
+            return SPECIAL_HEADER_SERIALIZATION[param.wire_name.lower()]
+
+        set_parameter = "_{}['{}'] = {}".format(
+            kwarg_name,
+            param.wire_name,
+            ParameterSerializer.serialize_parameter(param, serializer_name),
+        )
+        if not param.optional:
+            retval = [set_parameter]
+        else:
+            retval = [
+                f"if {param.full_client_name} is not None:",
+                f"    {set_parameter}",
+            ]
+        return retval
+
     @staticmethod
     def pop_kwargs_from_signature(
         parameters: Sequence[_ParameterBase],