@autorest/python 6.2.12 → 6.2.16

package/autorest/codegen/serializers/builder_serializer.py

@@ -31,6 +31,8 @@ from ..models import (
     MultipartBodyParameter,
     Property,
     RequestBuilderType,
+    JSONModelType,
+    CombinedType,
 )
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from . import utils
@@ -146,6 +148,25 @@ def _serialize_flattened_body(body_parameter: BodyParameter) -> List[str]:
     return retval
 
 
+def _serialize_json_model_body(body_parameter: BodyParameter) -> List[str]:
+    retval: List[str] = []
+    if not body_parameter.property_to_parameter_name:
+        raise ValueError(
+            "This method can't be called if the operation doesn't need parameter flattening"
+        )
+
+    retval.append(f"if {body_parameter.client_name} is None:")
+    parameter_string = ", \n".join(
+        f'"{property_name}": {parameter_name}'
+        for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
+    )
+    model_type = cast(ModelType, body_parameter.type)
+    if isinstance(model_type, CombinedType):
+        model_type = next(t for t in model_type.types if isinstance(t, JSONModelType))
+    retval.append(f"    {body_parameter.client_name} = {{{parameter_string}}}")
+    return retval
+
+
 def _serialize_multipart_body(builder: BuilderType) -> List[str]:
     retval: List[str] = []
     body_param = cast(MultipartBodyParameter, builder.parameters.body_parameter)
@@ -184,7 +205,7 @@ def _api_version_validation(builder: OperationType) -> str:
         retval.append(f"    params_added_on={dict(params_added_on)},")
     if retval:
         retval_str = "\n".join(retval)
-        return f"@api_version_validation(\n{retval_str}\n)"
+        return f"@api_version_validation(\n{retval_str}\n){builder.pylint_disable}"
     return ""
 
 
@@ -203,23 +224,20 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
     @abstractmethod
     def _function_def(self) -> str:
         """The def keyword for the builder we're serializing, i.e. 'def' or 'async def'"""
-        ...
 
     @property
     @abstractmethod
     def _call_method(self) -> str:
         """How to call network calls. Await if we have to await network calls"""
-        ...
 
     @property
     @abstractmethod
     def serializer_name(self) -> str:
-        ...
+        """Name of serializer"""
 
     @abstractmethod
     def response_docstring(self, builder: BuilderType) -> List[str]:
         """Response portion of the docstring"""
-        ...
 
     def decorators(self, builder: BuilderType) -> List[str]:
         """Decorators for the method"""
@@ -258,9 +276,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             )
         )
 
-    def description_and_summary(  # pylint: disable=no-self-use
-        self, builder: BuilderType
-    ) -> List[str]:
+    def description_and_summary(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         description_list.append(
             f"{ builder.summary.strip() if builder.summary else builder.description.strip() }"
@@ -280,9 +296,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             template += self._json_input_example_template(builder)
         return template
 
-    def param_description(  # pylint: disable=no-self-use
-        self, builder: BuilderType
-    ) -> List[str]:
+    def param_description(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         for param in builder.parameters.method:
             if not param.in_docstring:
@@ -446,11 +460,11 @@ class RequestBuilderSerializer(
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
         response_str = (
-            f":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            ":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
-        rtype_str = f":rtype: ~azure.core.rest.HttpRequest"
+        rtype_str = ":rtype: ~azure.core.rest.HttpRequest"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -618,9 +632,7 @@ class _OperationSerializer(
             retval.append(_api_version_validation(builder))
         return retval
 
-    def param_description(
-        self, builder: OperationType
-    ) -> List[str]:  # pylint: disable=no-self-use
+    def param_description(self, builder: OperationType) -> List[str]:
         description_list = super().param_description(builder)
         if not self.code_model.options["version_tolerant"]:
             description_list.append(
@@ -689,7 +701,10 @@ class _OperationSerializer(
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
         elif self.code_model.options["models_mode"] == "dpg":
-            create_body_call = f"_{body_kwarg_name} = json.dumps({body_param.client_name}, cls=AzureJSONEncoder)"
+            create_body_call = (
+                f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
+                "cls=AzureJSONEncoder)  # type: ignore"
+            )
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         if body_param.optional:
@@ -891,7 +906,7 @@ class _OperationSerializer(
             retval.append(f"    template_url={template_url},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
-        retval.append(f")")
+        retval.append(")")
         return retval
 
     def _postprocess_http_request(
@@ -934,6 +949,12 @@ class _OperationSerializer(
         if builder.parameters.has_body and builder.parameters.body_parameter.flattened:
             # unflatten before passing to request builder as well
             retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
+        if (
+            builder.parameters.has_body
+            and builder.parameters.body_parameter.has_json_model_type
+            and any(p.in_flattened_body for p in builder.parameters.parameters)
+        ):
+            retval.extend(_serialize_json_model_body(builder.parameters.body_parameter))
         if builder.overloads:
             # we are only dealing with two overloads. If there are three, we generate an abstract operation
             retval.extend(self._initialize_overloads(builder, is_paging=is_paging))
@@ -993,10 +1014,10 @@ class _OperationSerializer(
                     if response.type.is_xml
                     else "response.json()"
                 )
-                retval.append(f"if response.content:")
+                retval.append("if response.content:")
                 retval.append(f"    deserialized = {deserialized_value}")
                 retval.append("else:")
-                retval.append(f"    deserialized = None")
+                retval.append("    deserialized = None")
         return retval
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
@@ -1304,11 +1325,20 @@ class _PagingOperationSerializer(
                 deserialize_type = f'"{response.serialization_type}"'
                 pylint_disable = ""
             deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
+            retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
-            deserialized = (
-                f"_deserialize({response.serialization_type}, pipeline_response)"
+            pylint_disable = (
+                "  # pylint: disable=protected-access\n"
+                if isinstance(response.type, ModelType) and not response.type.is_public
+                else ""
             )
-        retval.append(f"    deserialized = {deserialized}")
+            deserialized = f"_deserialize({response.serialization_type}{pylint_disable}, pipeline_response)"
+            retval.append(
+                f"    deserialized: {response.serialization_type} = ({pylint_disable}"
+            )
+            retval.append(f"        {deserialized})")
+        else:
+            retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
         list_of_elem = (
             f".{item_name}"
@@ -1453,7 +1483,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 f"        {lro_options_str}",
                 f"        {path_format_arguments_str}",
                 "        **kwargs",
-                f"))",
+                "))",
             ]
         )
         retval.append(
@@ -1510,7 +1540,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 " # type: ignore"
                 if builder.lro_response
                 and builder.lro_response.type
-                and not self.code_model.options["models_mode"]
+                and self.code_model.options["models_mode"] != "msrest"
                 else "",
             )
         )

package/autorest/codegen/serializers/client_serializer.py

@@ -137,7 +137,9 @@ class ClientSerializer:
                 f" = {_get_client_models_value(model_dict_name)}"
             )
             if add_private_models and self.client.code_model.model_types:
-                update_dict = f"{{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}}"
+                update_dict = (
+                    "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
+                )
                 retval.append(f"client_models.update({update_dict})")
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
@@ -221,7 +223,7 @@ class ClientSerializer:
     def _rest_request_example(self, async_mode: bool) -> List[str]:
         retval = [">>> from azure.core.rest import HttpRequest"]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
-        retval.append(f"<HttpRequest [GET], url: 'https://www.example.org/'>")
+        retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
         return retval
 
@@ -236,9 +238,9 @@ class ClientSerializer:
         retval.append(
             "For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request"
         )
-        retval.append(f"")
+        retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(f":type request: ~azure.core.rest.HttpRequest")
+        retval.append(":type request: ~azure.core.rest.HttpRequest")
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )

package/autorest/codegen/serializers/general_serializer.py

@@ -98,7 +98,7 @@ class GeneralSerializer:
             imports=FileImportSerializer(imports),
         )
 
-    def serialize_vendor_file(self) -> str:
+    def serialize_vendor_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("vendor.py.jinja2")
 
         # configure imports
@@ -110,6 +110,10 @@ 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",
@@ -128,7 +132,7 @@ class GeneralSerializer:
                 MsrestImportType.SerializerDeserializer,
                 TypingSection.TYPING,
             )
-            for client in self.code_model.clients:
+            for client in clients:
                 file_import.add_submodule_import(
                     "._configuration",
                     f"{client.name}Configuration",
@@ -141,6 +145,7 @@ class GeneralSerializer:
                 file_import,
             ),
             async_mode=self.async_mode,
+            clients=clients,
         )
 
     def serialize_config_file(self, clients: List[Client]) -> str:

package/autorest/codegen/serializers/model_serializer.py

@@ -208,14 +208,19 @@ class DpgModelSerializer(_ModelSerializer):
             ImportType.LOCAL,
             TypingSection.REGULAR,
         )
-        file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
-        file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
             for prop in model.properties:
                 file_import.merge(prop.imports())
+            if model.is_polymorphic:
+                file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
+            if model.is_public and self.init_line(model):
+                file_import.add_submodule_import(
+                    "typing", "overload", ImportType.STDLIB
+                )
+                file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
+                file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
@@ -256,9 +261,14 @@ class DpgModelSerializer(_ModelSerializer):
             args.append(f"default={prop.client_default_value_declaration}")
 
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
+        type_ignore = (
+            prop.is_discriminator
+            and prop.is_discriminator
+            and cast(ConstantType, prop.type).value
+        )
         ret = [
             f"{prop.client_name}: {prop.type_annotation()} ="
-            f' {field}({", ".join(args)})'
+            f' {field}({", ".join(args)}){"  # type: ignore" if type_ignore else ""}'
         ]
         comment = prop.description(is_operation_file=False).replace('"', '\\"')
         if comment:

package/autorest/codegen/serializers/sample_serializer.py

@@ -65,7 +65,7 @@ class SampleSerializer:
 
     def _client_params(self) -> Dict[str, Any]:
         # client params
-        special_param = dict()
+        special_param = {}
         credential_type = getattr(self.code_model.clients[0].credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
             special_param.update({"credential": "DefaultAzureCredential()"})
@@ -79,14 +79,10 @@ class SampleSerializer:
             for p in self.code_model.clients[0].parameters.positional
             if not (p.optional or p.client_default_value)
         ]
-        cls = lambda x: f'"{x}"'
         client_params = {
             p.client_name: special_param.get(
                 p.client_name,
-                cls(
-                    self.sample["parameters"].get(p.rest_api_name)
-                    or p.client_name.upper()
-                ),
+                f'"{self.sample["parameters"].get(p.rest_api_name) or p.client_name.upper()}"',
             )
             for p in params_positional
         }

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

@@ -22,12 +22,27 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if client.credential and client.credential.type.policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ client.credential.type.policy.credential_scopes }})
+{% if client.credential %}
+    {% set cred_scopes = client.credential.type if client.credential.type.policy is defined and client.credential.type.policy.credential_scopes is defined %}
+    {% if not cred_scopes %}
+        {% set cred_scopes = client.credential.type.types | selectattr("policy.credential_scopes") | first if client.credential.type.types is defined %}
+    {% endif %}
+    {% if cred_scopes %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ cred_scopes.policy.credential_scopes }})
+    {% endif %}
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
 
+{% if client.credential and client.credential.type.types is defined %}
+    def _infer_policy(self, **kwargs):
+    {% for cred_type in client.credential.type.types %}
+        if {{ cred_type.instance_check_template.format("self.credential") }}:
+            return {{ cred_type.policy.call(async_mode) }}
+    {% endfor %}
+        raise TypeError(f"Unsupported credential: {self.credential}")
+{% endif %}
+
     def _configure(
         self,
         **kwargs: Any
@@ -41,12 +56,16 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
         self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)
         self.authentication_policy = kwargs.get('authentication_policy')
-        {% if client.credential %}
-        {# only adding this if credential_scopes is not passed during code generation #}
-        {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.policy.credential_scopes | length == 0 %}
+        {% if client.credential and client.credential.type.policy is defined %}
+            {# only adding this if credential_scopes is not passed during code generation #}
+            {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.policy.credential_scopes | length == 0 %}
         if not self.credential_scopes and not self.authentication_policy:
             raise ValueError("You must provide either credential_scopes or authentication_policy as kwargs")
-        {% endif %}
+            {% endif %}
         if self.credential and not self.authentication_policy:
             self.authentication_policy = {{ client.credential.type.policy.call(async_mode) }}
         {% endif %}
+        {% if client.credential and client.credential.type.types is defined %}
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = self._infer_policy(**kwargs)
+        {% endif %}

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

@@ -6,8 +6,8 @@ class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False
     {% endif %}
 
     {% for value in enum.values %}
+    {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
     {% if value.description %}
-    #: {{ value.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}
+    """{{ value.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}"""
     {% endif %}
-    {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
     {% endfor %}

package/autorest/codegen/templates/metadata.json.jinja2

@@ -1,5 +1,7 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {% import 'keywords.jinja2' as keywords %}
+{% set only_path = client.code_model.options["only_path_and_body_params_positional"] %}
+{% set method_location = "keywordOnly" if only_path else "positional" %}
 {
     "chosen_version": {{ chosen_version | tojson }},
     "total_api_version_list": {{ total_api_version_list | tojson }},
@@ -22,7 +24,8 @@
                 "signature": {{ gp.method_signature(async_mode=False) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=False) | tojson }},
-                "required": {{ (not gp.optional) | tojson }}
+                "required": {{ (not gp.optional) | tojson }},
+                "method_location": {{ gp.method_location | tojson }}
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         },
@@ -48,21 +51,24 @@
                     "signature": "api_version: Optional[str]=None,",
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% if not client.has_parameterized_host %}
-                "base_url": {
+                "{{ "endpoint" if only_path else "base_url" }}": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% endif %}
                 "profile": {
                     "signature": "profile: KnownProfiles=KnownProfiles.default,",
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 }
             },
             "async": {
@@ -70,21 +76,24 @@
                     "signature": "api_version: Optional[str] = None,",
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% if not client.has_parameterized_host %}
-                "base_url": {
+                "{{ "endpoint" if only_path else "base_url" }}": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% endif %}
                 "profile": {
                     "signature": "profile: KnownProfiles = KnownProfiles.default,",
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 }
             }
         }