@autorest/python 6.5.1 → 6.7.0

package/autorest/codegen/models/client.py

@@ -236,11 +236,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         """Do we want a mixin ABC class for typing purposes?"""
         return any(o for o in self.operation_groups if o.is_mixin)
 
-    @property
-    def need_format_url(self) -> bool:
-        """Whether we need to format urls. If so, we need to vendor core."""
-        return any(rq for rq in self.request_builders if rq.parameters.path)
-
     @property
     def has_lro_operations(self) -> bool:
         """Are there any LRO operations in this SDK?"""
@@ -269,8 +264,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def need_request_converter(self) -> bool:
         """
-        Whether we need to convert our created azure.core.rest.HttpRequests to
-        azure.core.pipeline.transport.HttpRequests
+        Whether we need to convert our created azure.core.rest.HttpRequest to
+        azure.core.pipeline.transport.HttpRequest
         """
         return (
             self.code_model.options["show_operations"]

package/autorest/codegen/models/code_model.py

@@ -129,18 +129,12 @@ class CodeModel:  # pylint: disable=too-many-public-methods
             return True
         if async_mode:
             return self.need_mixin_abc
-        return (
-            self.need_request_converter or self.need_format_url or self.need_mixin_abc
-        )
+        return self.need_request_converter or self.need_mixin_abc
 
     @property
     def need_request_converter(self) -> bool:
         return any(c for c in self.clients if c.need_request_converter)
 
-    @property
-    def need_format_url(self) -> bool:
-        return any(c for c in self.clients if c.need_format_url)
-
     @property
     def need_mixin_abc(self) -> bool:
         return any(c for c in self.clients if c.has_mixin)

package/autorest/codegen/models/lro_operation.py

@@ -128,6 +128,18 @@ class LROOperationBase(OperationBase[LROResponseType]):
                 "distributed_trace_async",
                 ImportType.AZURECORE,
             )
+        if (
+            self.code_model.options["models_mode"] == "dpg"
+            and self.lro_response
+            and self.lro_response.type
+            and self.lro_response.type.type == "model"
+        ):
+            # used in the case if initial operation returns none
+            # but final call returns a model
+            relative_path = "..." if async_mode else ".."
+            file_import.add_submodule_import(
+                f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL
+            )
         file_import.add_submodule_import(
             "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/model_type.py

@@ -207,7 +207,10 @@ class ModelType(  # pylint: disable=abstract-method
 
     @property
     def has_readonly_or_constant_property(self) -> bool:
-        return any(x.readonly or x.constant for x in self.properties)
+        return any(
+            x.readonly or x.constant or x.visibility == ["read"]
+            for x in self.properties
+        )
 
     @property
     def discriminator(self) -> Optional[Property]:

package/autorest/codegen/models/operation.py

@@ -331,7 +331,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         return file_import
 
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def imports(  # pylint: disable=too-many-branches
+        self, async_mode: bool, **kwargs: Any
+    ) -> FileImport:
         if self.abstract:
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
@@ -356,6 +358,12 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(
                 self.parameters.body_parameter.type.imports(operation=self, **kwargs)
             )
+        if not async_mode:
+            for param in self.parameters.headers:
+                if param.wire_name.lower() == "repeatability-request-id":
+                    file_import.add_import("uuid", ImportType.STDLIB)
+                elif param.wire_name.lower() == "repeatability-first-sent":
+                    file_import.add_import("datetime", ImportType.STDLIB)
 
         # Exceptions
         errors = [
@@ -391,16 +399,30 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
-        if async_mode:
-            file_import.add_submodule_import(
-                "azure.core.pipeline.transport",
-                "AsyncHttpResponse",
-                ImportType.AZURECORE,
-            )
+        if self.code_model.need_request_converter:
+            if async_mode:
+                file_import.add_submodule_import(
+                    "azure.core.pipeline.transport",
+                    "AsyncHttpResponse",
+                    ImportType.AZURECORE,
+                )
+            else:
+                file_import.add_submodule_import(
+                    "azure.core.pipeline.transport",
+                    "HttpResponse",
+                    ImportType.AZURECORE,
+                )
         else:
-            file_import.add_submodule_import(
-                "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE
-            )
+            if async_mode:
+                file_import.add_submodule_import(
+                    "azure.core.rest",
+                    "AsyncHttpResponse",
+                    ImportType.AZURECORE,
+                )
+            else:
+                file_import.add_submodule_import(
+                    "azure.core.rest", "HttpResponse", ImportType.AZURECORE
+                )
         if (
             self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode

package/autorest/codegen/models/parameter.py

@@ -52,6 +52,9 @@ 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
@@ -90,6 +93,10 @@ 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
+        )
 
     @property
     def constant(self) -> bool:

package/autorest/codegen/models/parameter_list.py

@@ -213,7 +213,9 @@ class _ParameterListBase(
         method_params: List[Union[ParameterType, BodyParameterType]] = [
             p
             for p in self.parameters
-            if p.in_method_signature and p.implementation == self.implementation
+            if p.in_method_signature
+            and p.implementation == self.implementation
+            and not p.is_special_handle_header
         ]
         if self._body_parameter:
             if self._body_parameter.in_method_signature:

package/autorest/codegen/models/property.py

@@ -29,6 +29,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.type = type
         self.optional: bool = self.yaml_data["optional"]
         self.readonly: bool = self.yaml_data.get("readonly", False)
+        self.visibility: List[str] = self.yaml_data.get("visibility", [])
         self.is_polymorphic: bool = self.yaml_data.get("isPolymorphic", False)
         self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
         self.client_default_value = yaml_data.get("clientDefaultValue", None)

package/autorest/codegen/models/request_builder.py

@@ -92,10 +92,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             ImportType.AZURECORE,
         )
 
-        if self.parameters.path:
-            file_import.add_submodule_import(
-                f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
-            )
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/serializers/builder_serializer.py

@@ -437,6 +437,21 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             ]
         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
@@ -548,12 +563,15 @@ class RequestBuilderSerializer(
     def serialize_headers(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct headers"]
         for parameter in builder.parameters.headers:
-            retval.extend(
-                self._serialize_parameter(
-                    parameter,
-                    kwarg_name="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",
+                    )
                 )
-            )
         return retval
 
     def serialize_query(self, builder: RequestBuilderType) -> List[str]:
@@ -710,6 +728,7 @@ class _OperationSerializer(
             )
             else PopKwargType.SIMPLE,
             check_client_input=not self.code_model.options["multiapi"],
+            operation_name=f"('{builder.name}')" if builder.group_name == "" else "",
         )
         cls_annotation = builder.cls_type_annotation(async_mode=self.async_mode)
         pylint_disable = ""
@@ -1524,7 +1543,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("if cont_token is None:")
         retval.append(
             f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
-            f"{'' if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
+            f"{'' if any(rsp.type for rsp in builder.initial_operation.responses) else '  # type: ignore'}"
         )
         retval.extend(
             [

package/autorest/codegen/serializers/client_serializer.py

@@ -150,10 +150,16 @@ class ClientSerializer:
             og for og in self.client.operation_groups if not og.is_mixin
         ]
         for og in operation_groups:
+            if og.code_model.options["multiapi"]:
+                api_version = (
+                    f", '{og.api_versions[0]}'" if og.api_versions else ", None"
+                )
+            else:
+                api_version = ""
             retval.extend(
                 [
                     f"self.{og.property_name} = {og.class_name}({og.pylint_disable}",
-                    "    self._client, self._config, self._serialize, self._deserialize",
+                    f"    self._client, self._config, self._serialize, self._deserialize{api_version}",
                     ")",
                 ]
             )

package/autorest/codegen/serializers/general_serializer.py

@@ -109,10 +109,6 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
-        if self.code_model.need_format_url and not self.async_mode:
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",

package/autorest/codegen/serializers/model_serializer.py

@@ -257,6 +257,9 @@ class DpgModelSerializer(_ModelSerializer):
             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}")
 
@@ -280,3 +283,11 @@ class DpgModelSerializer(_ModelSerializer):
                     f"{cast(ConstantType, prop.type).get_declaration()}"
                 )
         return init_args
+
+    @staticmethod
+    def _init_line_parameters(model: ModelType):
+        return [
+            p
+            for p in model.properties
+            if not p.is_discriminator and not p.constant and p.visibility != ["read"]
+        ]

package/autorest/codegen/serializers/parameter_serializer.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Sequence, Union
+from typing import List, Sequence, Union, Optional
 from enum import Enum, auto
 
 
@@ -111,6 +111,7 @@ class ParameterSerializer:
         pop_headers_kwarg: PopKwargType,
         pop_params_kwarg: PopKwargType,
         check_client_input: bool = False,
+        operation_name: Optional[str] = None,
     ) -> List[str]:
         retval = []
 
@@ -142,9 +143,18 @@ class ParameterSerializer:
                         if kwarg.location == ParameterLocation.HEADER
                         else "params"
                     )
+                    if (
+                        kwarg.client_name == "api_version"
+                        and kwarg.code_model.options["multiapi"]
+                        and operation_name is not None
+                    ):
+                        default_value = (
+                            f"self._api_version{operation_name} or {default_value}"
+                        )
                     default_value = (
                         f"_{kwarg_dict}.pop('{kwarg.wire_name}', {default_value})"
                     )
+
                 retval.append(
                     f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}', "
                     + f"{default_value})"

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

@@ -136,7 +136,7 @@ def _serialize_datetime(o):
 
 def _is_readonly(p):
     try:
-        return p._readonly  # pylint: disable=protected-access
+        return p._visibility == ["read"]  # pylint: disable=protected-access
     except AttributeError:
         return False
 
@@ -634,14 +634,14 @@ class _RestField:
         name: typing.Optional[str] = None,
         type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
         is_discriminator: bool = False,
-        readonly: bool = False,
+        visibility: typing.Optional[typing.List[str]] = None,
         default: typing.Any = _UNSET,
     ):
         self._type = type
         self._rest_name_input = name
         self._module: typing.Optional[str] = None
         self._is_discriminator = is_discriminator
-        self._readonly = readonly
+        self._visibility = visibility
         self._is_model = False
         self._default = default
 
@@ -681,10 +681,10 @@ def rest_field(
     *,
     name: typing.Optional[str] = None,
     type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
-    readonly: bool = False,
+    visibility: typing.Optional[typing.List[str]] = None,
     default: typing.Any = _UNSET,
 ) -> typing.Any:
-    return _RestField(name=name, type=type, readonly=readonly, default=default)
+    return _RestField(name=name, type=type, visibility=visibility, default=default)
 
 
 def rest_discriminator(

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

@@ -30,12 +30,22 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         self._config = input_args.pop(0) if input_args else kwargs.pop("config")
         self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
         self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+        {% if code_model.options["multiapi"] %}
+        self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version")
+        {% endif %}
 {{ check_abstract_methods() }}
 {% elif operation_group.has_abstract_operations %}
 
     def __init__(self){{ return_none_type_annotation }}:
 {{ check_abstract_methods() }}
 {% endif %}
+{% if operation_group.is_mixin and code_model.options["multiapi"] %}
+    def _api_version(self, op_name: str) -> str:  # pylint: disable=unused-argument
+        try:
+            return self._config.api_version
+        except:  # pylint: disable=bare-except
+            return ""
+{% endif %}
 {% for operation in operation_group.operations if not operation.abstract %}
 
 {% set request_builder = operation.request_builder %}

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

@@ -15,7 +15,7 @@
     {{ request_builder_serializer.construct_url(request_builder) }}
     {% if request_builder.parameters.path %}
     {{ op_tools.serialize(request_builder_serializer.serialize_path(request_builder)) | indent }}
-    _url: str = _format_url_section(_url, **path_format_arguments)  # type: ignore
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
         {% endif %}
 
         {% if request_builder.parameters.query %}

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

@@ -664,8 +664,9 @@ class Serializer(object):
                                 _serialized.update(_new_attr)  # type: ignore
                             _new_attr = _new_attr[k]  # type: ignore
                             _serialized = _serialized[k]
-                except ValueError:
-                    continue
+                except ValueError as err:
+                    if isinstance(err, SerializationError):
+                        raise
 
         except (AttributeError, KeyError, TypeError) as err:
             msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
@@ -905,7 +906,9 @@ class Serializer(object):
         for d in data:
             try:
                 serialized.append(self.serialize_data(d, iter_type, **kwargs))
-            except ValueError:
+            except ValueError as err:
+                if isinstance(err, SerializationError):
+                    raise
                 serialized.append(None)
 
         if div:
@@ -952,7 +955,9 @@ class Serializer(object):
         for key, value in attr.items():
             try:
                 serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs)
-            except ValueError:
+            except ValueError as err:
+                if isinstance(err, SerializationError):
+                    raise
                 serialized[self.serialize_unicode(key)] = None
 
         if "xml" in serialization_ctxt:

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

@@ -11,21 +11,6 @@ def _convert_request(request, files=None):
         request.set_formdata_body(files)
     return request
 {% endif %}
-{% if code_model.need_format_url and not async_mode %}
-
-def _format_url_section(template, **kwargs):
-    components = template.split("/")
-    while components:
-        try:
-            return template.format(**kwargs)
-        except KeyError as key:
-            # Need the cast, as for some reasons "split" is typed as list[str | Any]
-            formatted_components = cast(List[str], template.split("/"))
-            components = [
-                c for c in formatted_components if "{{{}}}".format(key.args[0]) not in c
-            ]
-            template = "/".join(components)
-{% endif %}
 {% if code_model.need_mixin_abc %}
     {% for client in clients | selectattr("has_mixin") %}
 

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -87,6 +87,8 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
         else:
             raise ValueError("API version {} is not available".format(api_version))
         {% endif %}
+        if api_version:
+            kwargs.setdefault('api_version', api_version)
         self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
         self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ code_model.host_variable_name }}, config=self._config, **kwargs)
         super({{ code_model.client.name }}, self).__init__(
@@ -132,7 +134,7 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
         else:
             raise ValueError("API version {} does not have operation group '{{ operation_group.name }}'".format(api_version))
         self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
     {% endfor %}
 
     {{ def }} close(self):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.5.1",
+  "version": "6.7.0",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {
@@ -23,7 +23,7 @@
   },
   "devDependencies": {
     "@microsoft.azure/autorest.testserver": "^3.3.46",
-    "typescript": "^5.0.4"
+    "typescript": "~5.1.3"
   },
   "files": [
     "autorest/**/*.py",