@autorest/python 6.2.4 → 6.2.7

package/autorest/codegen/serializers/builder_serializer.py

@@ -9,7 +9,6 @@ from abc import abstractmethod
 from collections import defaultdict
 from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cast
 
-
 from ..models import (
     Operation,
     PagingOperation,
@@ -584,8 +583,10 @@ class _OperationSerializer(
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
+        type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         return [
-            f"pipeline_response = {self._call_method}self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access",
+            f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
+            + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    request,",
             f"    stream={builder.has_stream_response},",
             "    **kwargs",
@@ -628,24 +629,22 @@ class _OperationSerializer(
             check_kwarg_dict=True,
             pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.HEADER
+                kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
             )
             else PopKwargType.SIMPLE,
             pop_params_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.QUERY
+                kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
             )
             else PopKwargType.SIMPLE,
             check_client_input=not self.code_model.options["multiapi"],
         )
-        kwargs.append(
-            f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"
-        )
+        cls_annotation = builder.cls_type_annotation(async_mode=self.async_mode)
+        kwargs.append(f"cls: {cls_annotation} = kwargs.pop('cls', None)")
+        if any(x.startswith("_") for x in cls_annotation.split(".")):
+            kwargs[-1] += " # pylint: disable=protected-access"
         return kwargs
 
-    def cls_type_annotation(self, builder: OperationType) -> str:
-        return f"# type: {builder.cls_type_annotation(async_mode=self.async_mode)}"
-
     def response_docstring(self, builder: OperationType) -> List[str]:
         response_str = (
             f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
@@ -848,8 +847,18 @@ class _OperationSerializer(
                 # in paging operations with a single swagger operation defintion,
                 # we skip passing query params when building the next request
                 continue
+            type_ignore = (
+                parameter.grouped_by
+                and parameter.client_default_value is not None
+                and next(
+                    p
+                    for p in builder.parameters
+                    if p.grouper and p.client_name == parameter.grouped_by
+                ).optional
+            )
             retval.append(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
+                f"{'  # type: ignore' if type_ignore else ''}"
             )
         if request_builder.overloads:
             seen_body_params = set()
@@ -897,7 +906,7 @@ class _OperationSerializer(
         if self.code_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url({}{})  # type: ignore".format(
+            "request.url = self._client.format_url({}{})".format(
                 url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else "",
             )
@@ -967,11 +976,10 @@ class _OperationSerializer(
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
-            elif self.code_model.options["models_mode"] == "dpg" and isinstance(
-                response.type, ModelType
-            ):
+            elif self.code_model.options["models_mode"] == "dpg":
                 retval.append(
-                    f"deserialized = _deserialize({response.serialization_type}, response.json())"
+                    f"deserialized = _deserialize({response.type.type_annotation(is_operation_file=True)}"
+                    ", response.json())"
                 )
             else:
                 deserialized_value = (
@@ -1046,20 +1054,41 @@ class _OperationSerializer(
                     self.response_headers_and_deserialization(builder.responses[0])
                 )
                 retval.append("")
+        type_ignore = (
+            builder.has_response_body
+            and not builder.has_optional_return_type
+            and not (
+                self.code_model.options["models_mode"] == "msrest"
+                and any(not resp.is_stream_response for resp in builder.responses)
+            )
+        )
         if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
+            type_ignore = False
+        if (
+            not builder.has_optional_return_type
+            and len(builder.responses) > 1
+            and any(resp.is_stream_response or resp.type for resp in builder.responses)
+        ):
+            type_ignore = True
         retval.append("if cls:")
         retval.append(
-            "    return cls(pipeline_response, {}, {})".format(
+            "    return cls(pipeline_response, {}, {}){}".format(
                 deserialized if builder.has_response_body else "None",
                 "response_headers" if builder.any_response_has_headers else "{}",
+                " # type: ignore" if type_ignore else "",
             )
         )
-        if builder.has_response_body:
+        if builder.has_response_body and any(
+            response.is_stream_response or response.type
+            for response in builder.responses
+        ):
             retval.append("")
-            retval.append(f"return {deserialized}")
+            retval.append(
+                f"return {deserialized}{' # type: ignore' if type_ignore else ''}"
+            )
         if (
             builder.request_builder.method == "HEAD"
             and self.code_model.options["head_as_boolean"]
@@ -1133,7 +1162,7 @@ class _OperationSerializer(
     @staticmethod
     def get_metadata_url(builder: OperationType) -> str:
         url = _escape_str(builder.request_builder.url)
-        return f"{builder.name}.metadata = {{'url': { url }}}  # type: ignore"
+        return f"{builder.name}.metadata = {{'url': { url }}}"
 
     @property
     def _call_method(self) -> str:
@@ -1282,7 +1311,7 @@ class _PagingOperationSerializer(
         )
         retval.append(f"    list_of_elem = deserialized{list_of_elem}")
         retval.append("    if cls:")
-        retval.append("        list_of_elem = cls(list_of_elem)")
+        retval.append("        list_of_elem = cls(list_of_elem) # type: ignore")
 
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
@@ -1290,7 +1319,9 @@ class _PagingOperationSerializer(
         elif self.code_model.options["models_mode"]:
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
-            cont_token_property = f'deserialized.get("{continuation_token_name}", None)'
+            cont_token_property = (
+                f'deserialized.get("{continuation_token_name}") or None'
+            )
         list_type = "AsyncList" if self.async_mode else "iter"
         retval.append(f"    return {cont_token_property}, {list_type}(list_of_elem)")
         return retval
@@ -1364,19 +1395,19 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
 
     def initial_call(self, builder: LROOperationType) -> List[str]:
         retval = [
-            "polling = kwargs.pop('polling', True)  # type: Union[bool, "
-            f"{builder.get_base_polling_method(self.async_mode)}]"
+            f"polling: Union[bool, {builder.get_base_polling_method(self.async_mode)}] = kwargs.pop('polling', True)",
         ]
         retval.append("lro_delay = kwargs.pop(")
         retval.append("    'polling_interval',")
         retval.append("    self._config.polling_interval")
         retval.append(")")
         retval.append(
-            "cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]"
+            "cont_token: Optional[str] = kwargs.pop('continuation_token', None)"
         )
         retval.append("if cont_token is None:")
         retval.append(
-            f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(  # type: ignore"
+            f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
+            f"{''  if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
         )
         retval.extend(
             [
@@ -1409,13 +1440,14 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.extend(
             [
                 "if polling is True:",
-                f"    polling_method = cast({builder.get_base_polling_method(self.async_mode)}, "
+                f"    polling_method: {builder.get_base_polling_method(self.async_mode)} "
+                + f"= cast({builder.get_base_polling_method(self.async_mode)}, "
                 f"{builder.get_polling_method(self.async_mode)}(",
                 "        lro_delay,",
                 f"        {lro_options_str}",
                 f"        {path_format_arguments_str}",
                 "        **kwargs",
-                f"))  # type: {builder.get_base_polling_method(self.async_mode)}",
+                f"))",
             ]
         )
         retval.append(
@@ -1434,7 +1466,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("    )")
         retval.append(
             f"return {builder.get_poller(self.async_mode)}"
-            "(self._client, raw_result, get_long_running_output, polling_method)"
+            "(self._client, raw_result, get_long_running_output, polling_method)  # type: ignore"
         )
         return retval
 
@@ -1462,13 +1494,18 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             )
         retval.append("    if cls:")
         retval.append(
-            "        return cls(pipeline_response, {}, {})".format(
+            "        return cls(pipeline_response, {}, {}){}".format(
                 "deserialized"
                 if builder.lro_response and builder.lro_response.type
                 else "None",
                 "response_headers"
                 if builder.lro_response and builder.lro_response.headers
                 else "{}",
+                " # type: ignore"
+                if builder.lro_response
+                and builder.lro_response.type
+                and not self.code_model.options["models_mode"]
+                else "",
             )
         )
         if builder.lro_response and builder.lro_response.type:
@@ -1507,7 +1544,7 @@ class LROPagingOperationSerializer(
         retval.append("    )")
         return retval
 
-    def decorators(self, builder: LROPagingOperation) -> List[str]:  # type: ignore
+    def decorators(self, builder: LROPagingOperation) -> List[str]:
         """Decorators for the method"""
         return _LROOperationSerializer.decorators(self, builder)  # type: ignore
 

package/autorest/codegen/serializers/client_serializer.py

@@ -116,15 +116,29 @@ class ClientSerializer:
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.client.code_model.model_types:
-            client_models_value = (
-                "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
-            )
-        else:
-            client_models_value = "{}  # type: Dict[str, Any]"
+
+        def _get_client_models_value(models_dict_name: str) -> str:
+            if self.client.code_model.model_types:
+                return f"{{k: v for k, v in {models_dict_name}.__dict__.items() if isinstance(v, type)}}"
+            return "{}"
+
         is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
         if is_msrest_model:
-            retval.append(f"client_models = {client_models_value}")
+            add_private_models = len(self.client.code_model.model_types) != len(
+                self.client.code_model.public_model_types
+            )
+            model_dict_name = (
+                f"_models.{self.client.code_model.models_filename}"
+                if add_private_models
+                else "_models"
+            )
+            retval.append(
+                f"client_models{': Dict[str, Any]' if not self.client.code_model.model_types else ''}"
+                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)}}"
+                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})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
@@ -136,7 +150,7 @@ class ClientSerializer:
         for og in operation_groups:
             retval.extend(
                 [
-                    f"self.{og.property_name} = {og.class_name}({og.mypy_ignore}{og.pylint_disable}",
+                    f"self.{og.property_name} = {og.class_name}({og.pylint_disable}",
                     "    self._client, self._config, self._serialize, self._deserialize",
                     ")",
                 ]

package/autorest/codegen/serializers/metadata_serializer.py

@@ -58,7 +58,13 @@ def _json_serialize_imports(
                 name_import_ordered_list = []
                 if name_imports:
                     name_import_ordered_list = list(name_imports)
-                    name_import_ordered_list.sort()
+                    name_import_ordered_list.sort(
+                        key=lambda e: "".join(e)  # type: ignore
+                        if isinstance(e, (list, tuple))
+                        else e
+                        if isinstance(e, str)
+                        else ""
+                    )
                 json_package_name_dictionary[package_name] = name_import_ordered_list
             json_import_type_dictionary[import_type_key] = json_package_name_dictionary
         json_serialize_imports[typing_section_key] = json_import_type_dictionary

package/autorest/codegen/serializers/model_serializer.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, List
+from typing import List, cast
 from abc import ABC, abstractmethod
 
 from jinja2 import Environment
@@ -77,7 +77,7 @@ class _ModelSerializer(ABC):
             typing = "Optional[str]"
         else:
             typing = "str"
-        return f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
+        return f"self.{prop.client_name}: {typing}  = {discriminator_value}"
 
     @staticmethod
     def initialize_standard_property(prop: Property):
@@ -152,7 +152,7 @@ class MsrestModelSerializer(_ModelSerializer):
             else "_serialization.Model"
         )
         if model.parents:
-            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+            basename = ", ".join([m.name for m in model.parents])
         return f"class {model.name}({basename}):{model.pylint_disable}"
 
     @staticmethod
@@ -163,9 +163,7 @@ class MsrestModelSerializer(_ModelSerializer):
                     p.client_name: p
                     for bm in model.parents
                     for p in model.properties
-                    if p not in cast(ModelType, bm).properties
-                    or p.is_discriminator
-                    or p.constant
+                    if p not in bm.properties or p.is_discriminator or p.constant
                 }.values()
             )
         else:
@@ -195,7 +193,10 @@ class MsrestModelSerializer(_ModelSerializer):
             xml_metadata = f", 'xml': {{{prop.type.xml_serialization_ctxt}}}"
         else:
             xml_metadata = ""
-        return f'"{prop.client_name}": {{"key": "{attribute_key}", "type": "{prop.serialization_type}"{xml_metadata}}},'
+        return (
+            f'"{prop.client_name}": {{"key": "{attribute_key}",'
+            f' "type": "{prop.msrest_deserialization_key}"{xml_metadata}}},'
+        )
 
 
 class DpgModelSerializer(_ModelSerializer):
@@ -220,7 +221,7 @@ class DpgModelSerializer(_ModelSerializer):
     def declare_model(self, model: ModelType) -> str:
         basename = "_model_base.Model"
         if model.parents:
-            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+            basename = ", ".join([m.name for m in model.parents])
         if model.discriminator_value:
             basename += f", discriminator='{model.discriminator_value}'"
         return f"class {model.name}({basename}):{model.pylint_disable}"
@@ -228,9 +229,7 @@ class DpgModelSerializer(_ModelSerializer):
     @staticmethod
     def get_properties_to_declare(model: ModelType) -> List[Property]:
         if model.parents:
-            parent_properties = [
-                p for bm in model.parents for p in cast(ModelType, bm).properties
-            ]
+            parent_properties = [p for bm in model.parents for p in bm.properties]
             properties_to_declare = [
                 p
                 for p in model.properties
@@ -271,7 +270,7 @@ class DpgModelSerializer(_ModelSerializer):
         for prop in self.get_properties_to_declare(model):
             if prop.constant or prop.is_discriminator:
                 init_args.append(
-                    f"self.{prop.client_name} = {cast(ConstantType, prop.type).get_declaration()}   "
-                    f"# type: {prop.type_annotation()}"
+                    f"self.{prop.client_name}: {prop.type_annotation()} = "
+                    f"{cast(ConstantType, prop.type).get_declaration()}"
                 )
         return init_args

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -64,6 +64,7 @@ class OperationGroupsSerializer:
         template = self.env.get_or_select_template(
             "operation_groups_container.py.jinja2"
         )
+
         return template.render(
             code_model=self.code_model,
             operation_groups=operation_groups,

package/autorest/codegen/serializers/parameter_serializer.py

@@ -145,13 +145,13 @@ class ParameterSerializer:
                         f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
                     )
                 retval.append(
-                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}', "
-                    + f"{default_value})  # type: {kwarg.type_annotation()}"
+                    f"{kwarg.client_name}: {kwarg.type_annotation()} = kwargs.pop('{kwarg.client_name}', "
+                    + f"{default_value})"
                 )
             else:
                 type_annot = kwarg.type_annotation()
                 retval.append(
-                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}')  # type: {type_annot}"
+                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')"
                 )
         return retval
 

package/autorest/codegen/serializers/patch_serializer.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer
-from ..models import CodeModel, FileImport, ImportType, TypingSection
+from ..models import CodeModel, FileImport, ImportType
 
 
 class PatchSerializer:
@@ -16,9 +16,7 @@ class PatchSerializer:
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
         imports = FileImport()
-        imports.add_submodule_import(
-            "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
+        imports.add_submodule_import("typing", "List", ImportType.STDLIB)
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(imports),

package/autorest/codegen/serializers/sample_serializer.py

@@ -5,7 +5,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any
+from typing import Dict, Any, Union
 from jinja2 import Environment
 
 from autorest.codegen.models.credential_types import AzureKeyCredentialType
@@ -13,6 +13,7 @@ from autorest.codegen.models.credential_types import TokenCredentialType
 from autorest.codegen.models.imports import FileImport, ImportType
 from autorest.codegen.models.operation import OperationBase
 from autorest.codegen.models.operation_group import OperationGroup
+from autorest.codegen.models.parameter import Parameter, BodyParameter
 from autorest.codegen.serializers.import_serializer import FileImportSerializer
 from ..models import CodeModel
 
@@ -28,7 +29,6 @@ class SampleSerializer:
         operation: OperationBase[Any],
         sample: Dict[str, Any],
         file_name: str,
-        sample_origin_name: str,
     ) -> None:
         self.code_model = code_model
         self.env = env
@@ -36,7 +36,6 @@ class SampleSerializer:
         self.operation = operation
         self.sample = sample
         self.file_name = file_name
-        self.sample_origin_name = sample_origin_name
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport()
@@ -55,6 +54,13 @@ class SampleSerializer:
             imports.add_submodule_import(
                 "azure.core.credentials", "AzureKeyCredential", ImportType.THIRDPARTY
             )
+        for param in self.operation.parameters.positional:
+            if (
+                not param.client_default_value
+                and not param.optional
+                and param.rest_api_name in self.sample["parameters"]
+            ):
+                imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
     def _client_params(self) -> Dict[str, Any]:
@@ -88,13 +94,12 @@ class SampleSerializer:
         return client_params
 
     @staticmethod
-    def handle_param(param: Any) -> str:
-        if isinstance(param, str):
-            if any(i in param for i in '\r\n"'):
-                return f'"""{param}"""'
-            return f'"{param}"'
+    def handle_param(param: Union[Parameter, BodyParameter], param_value: Any) -> str:
+        if isinstance(param_value, str):
+            if any(i in param_value for i in '\r\n"'):
+                return f'"""{param_value}"""'
 
-        return str(param)
+        return param.type.serialize_sample_value(param_value)
 
     # prepare operation parameters
     def _operation_params(self) -> Dict[str, Any]:
@@ -103,15 +108,17 @@ class SampleSerializer:
             for p in self.operation.parameters.positional
             if not p.client_default_value
         ]
-        failure_info = "fail to find required param named {} in example file {}"
+        failure_info = "fail to find required param named {}"
         operation_params = {}
         for param in params_positional:
             name = param.rest_api_name
             param_value = self.sample["parameters"].get(name)
             if not param.optional:
                 if not param_value:
-                    raise Exception(failure_info.format(name, self.sample_origin_name))
-                operation_params[param.client_name] = self.handle_param(param_value)
+                    raise Exception(failure_info.format(name))
+                operation_params[param.client_name] = self.handle_param(
+                    param, param_value
+                )
         return operation_params
 
     def _operation_group_name(self) -> str:
@@ -135,8 +142,10 @@ class SampleSerializer:
         return f".{self.operation.name}"
 
     def _origin_file(self) -> str:
-        name = self.sample.get("x-ms-original-file", "").split("specification")[-1]
-        return "specification" + name if name else name
+        name = self.sample.get("x-ms-original-file", "")
+        if "specification" in name:
+            return "specification" + name.split("specification")[-1]
+        return ""
 
     def serialize(self) -> str:
         return self.env.get_template("sample.py.jinja2").render(

package/autorest/codegen/serializers/utils.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from pathlib import Path
 
 
 def method_signature_and_response_type_annotation_template(
@@ -11,3 +12,8 @@ def method_signature_and_response_type_annotation_template(
     response_type_annotation: str,
 ) -> str:
     return f"{method_signature} -> {response_type_annotation}:"
+
+
+def extract_sample_name(file_path: str) -> str:
+    file = file_path.split("specification")[-1]
+    return Path(file).parts[-1].replace(".json", "")

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

@@ -26,21 +26,12 @@
         {% endif %}
         return self._client.send_request(request_copy, **kwargs)
 
-    {{ keywords.def }} close(self){{ " -> None" if async_mode else "" }}:
-        {% if not async_mode %}
-        # type: () -> None
-        {% endif %}
+    {{ keywords.def }} close(self) -> None:
         {{ keywords.await }}self._client.close()
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + client.name + "\"") if async_mode else "" }}:
-        {% if not async_mode %}
-        # type: () -> {{ client.name }}
-        {% endif %}
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ " -> \"" + client.name + "\"" }}:
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}exit__(self, *exc_details){{ " -> None" if async_mode else "" }}:
-        {% if not async_mode %}
-        # type: (Any) -> None
-        {% endif %}
+    {{ keywords.def }} __{{ keywords.async_prefix }}exit__(self, *exc_details) -> None:
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}exit__(*exc_details)

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

@@ -30,11 +30,8 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
 
     def _configure(
         self,
-        **kwargs{{": Any" if async_mode else "  # type: Any"}}
-    ){{ " -> None" if async_mode else "" }}:
-        {% if not async_mode %}
-        # type: (...) -> None
-        {% endif %}
+        **kwargs: Any
+    ) -> None:
         self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
         self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
         self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)

package/autorest/codegen/templates/keywords.jinja2

@@ -3,7 +3,7 @@
 {% set await = "await " if async_mode else "" %}
 {% set async_class = "Async" if async_mode else "" %}
 {% macro escape_str(s) %}'{{ s|replace("'", "\\'") }}'{% endmacro %}
-{% set kwargs_declaration = "**kwargs: Any" if async_mode else "**kwargs  # type: Any" %}
+{% set kwargs_declaration = "**kwargs: Any" %}
 {% set extend_all = "__all__.extend([p for p in _patch_all if p not in __all__])" %}
 {% macro patch_imports(try_except=False) %}
 {% set indentation = "    " if try_except else "" %}
@@ -11,7 +11,7 @@
 try:
 {% endif %}
 {{ indentation }}from ._patch import __all__ as _patch_all
-{{ indentation }}from ._patch import *  # type: ignore # pylint: disable=unused-wildcard-import
+{{ indentation }}from ._patch import *  # pylint: disable=unused-wildcard-import
 {% if try_except %}
 except ImportError:
     _patch_all = []

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

@@ -45,7 +45,7 @@
         "service_client_specific": {
             "sync": {
                 "api_version": {
-                    "signature": "api_version=None, # type: Optional[str]",
+                    "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
@@ -59,7 +59,7 @@
                 },
                 {% endif %}
                 "profile": {
-                    "signature": "profile=KnownProfiles.default, # type: KnownProfiles",
+                    "signature": "profile: KnownProfiles=KnownProfiles.default,",
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
                     "required": false