@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/serializers/client_serializer.py

@@ -4,22 +4,25 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import List
+
 from . import utils
-from ..models import CodeModel
+from ..models import CodeModel, ParameterMethodLocation
+from .parameter_serializer import ParameterSerializer, PopKwargType
 
 
 class ClientSerializer:
     def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
         self.is_python3_file = is_python3_file
+        self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
-        return utils.serialize_method(
+        return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name="__init__",
-            is_in_class=True,
-            method_param_signatures=self.code_model.service_client.parameters.client_method_signature(
-                async_mode or self.is_python3_file
+            need_self_param=True,
+            method_param_signatures=self.code_model.client.parameters.method_signature(
+                async_mode or self.is_python3_file, async_mode
             ),
         )
 
@@ -32,34 +35,43 @@ class ClientSerializer:
         )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.service_client.parameters.kwargs_to_pop(
-            async_mode or self.is_python3_file
-        ))
+        return self.parameter_serializer.pop_kwargs_from_signature(
+            self.code_model.client.parameters.kwargs_to_pop(
+                async_mode or self.is_python3_file,
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=PopKwargType.NO,
+            pop_params_kwarg=PopKwargType.NO,
+        )
 
     def class_definition(self, async_mode) -> str:
-        class_name = self.code_model.class_name
-        has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_empty_operation_group)
+        class_name = self.code_model.client.name
+        has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_mixin)
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
         elif not (async_mode or self.is_python3_file):
             base_class = "object"
-        disable = ""
-        if len(self.code_model.operation_groups) > 6:
-            disable = "    # pylint: disable=too-many-instance-attributes"
+        pylint_disable = self.code_model.client.pylint_disable
         if base_class:
-            return f"class {class_name}({base_class}):{disable}"
-        return f"class {class_name}:{disable}"
+            return f"class {class_name}({base_class}):{pylint_disable}"
+        return f"class {class_name}:{pylint_disable}"
 
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
         operations_folder = ".aio.operations." if async_mode else ".operations."
-        for og in [og for og in self.code_model.operation_groups if not og.is_empty_operation_group]:
-            retval.append(f":ivar {og.name}: {og.class_name} operations")
-            retval.append(f":vartype {og.name}: {self.code_model.namespace}{operations_folder}{og.class_name}")
-        for param in self.code_model.service_client.parameters.client_method:
-            retval.append(f":{param.description_keyword} {param.serialized_name}: {param.description}")
-            retval.append(f":{param.docstring_type_keyword} {param.serialized_name}: {param.docstring_type}")
+        for og in [og for og in self.code_model.operation_groups if not og.is_mixin]:
+            retval.append(f":ivar {og.property_name}: {og.class_name} operations")
+            retval.append(
+                f":vartype {og.property_name}: {self.code_model.namespace}{operations_folder}{og.class_name}"
+            )
+        for param in self.code_model.client.parameters.method:
+            retval.append(
+                f":{param.description_keyword} {param.client_name}: {param.description}"
+            )
+            retval.append(
+                f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
+            )
         if self.code_model.has_lro_operations:
             retval.append(
                 ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
@@ -69,92 +81,130 @@ class ClientSerializer:
         return retval
 
     def initialize_config(self) -> str:
-        config_name = f"{self.code_model.class_name}Configuration"
+        config_name = f"{self.code_model.client.name}Configuration"
         config_call = ", ".join(
             [
-                f"{p.serialized_name}={p.serialized_name}"
-                for p in self.code_model.service_client.parameters.config_method
-                if not p.is_kwarg
-            ] + [
-                "**kwargs"
-            ])
+                f"{p.client_name}={p.client_name}"
+                for p in self.code_model.config.parameters.method
+                if p.method_location != ParameterMethodLocation.KWARG
+            ]
+            + ["**kwargs"]
+        )
         return f"self._config = {config_name}({config_call})"
 
+    @property
+    def host_variable_name(self) -> str:
+        try:
+            return next(
+                p for p in self.code_model.client.parameters if p.is_host
+            ).client_name
+        except StopIteration:
+            return "_endpoint"
+
     def initialize_pipeline_client(self, async_mode: bool) -> str:
-        host_variable_name = self.code_model.service_client.parameters.host_variable_name
-        if self.code_model.service_client.has_parameterized_host:
-            host_variable_name = "_" + host_variable_name # we don't want potential conflicts with input params
-        pipeline_client_name = self.code_model.service_client.pipeline_class(async_mode)
-        return f"self._client = {pipeline_client_name}(base_url={host_variable_name}, config=self._config, **kwargs)"
+        pipeline_client_name = self.code_model.client.pipeline_class(async_mode)
+        return (
+            f"self._client = {pipeline_client_name}(base_url={self.host_variable_name}, "
+            "config=self._config, **kwargs)"
+        )
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.code_model.sorted_schemas:
-            client_models_value = "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
+        if self.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]"
         if self.code_model.options["models_mode"]:
             retval.append(f"client_models = {client_models_value}")
-        client_models_str = "client_models" if self.code_model.options["models_mode"] else ""
+        client_models_str = (
+            "client_models" if self.code_model.options["models_mode"] else ""
+        )
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
         if not self.code_model.options["client_side_validation"]:
             retval.append("self._serialize.client_side_validation = False")
-        operation_groups = [og for og in self.code_model.operation_groups if not og.is_empty_operation_group]
-        if operation_groups:
+        operation_groups = [
+            og for og in self.code_model.operation_groups if not og.is_mixin
+        ]
+        for og in operation_groups:
             retval.extend(
                 [
-                    f"self.{og.name} = {og.class_name}(self._client, self._config, self._serialize, self._deserialize)"
-                    for og in operation_groups
+                    f"self.{og.property_name} = {og.class_name}({og.mypy_ignore}{og.pylint_disable}",
+                    "    self._client, self._config, self._serialize, self._deserialize",
+                    ")",
                 ]
             )
         return retval
 
     def _send_request_signature(self, async_mode: bool) -> str:
-        return utils.serialize_method(
+        is_python3_file = async_mode or self.code_model.options["python3_only"]
+        request_signature = [
+            "request: HttpRequest,"
+            if is_python3_file
+            else "request,  # type: HttpRequest"
+        ]
+        send_request_signature = (
+            request_signature
+            + self.code_model.client.parameters.method_signature_kwargs(is_python3_file)
+        )
+        return self.parameter_serializer.serialize_method(
             function_def="def",
-            method_name=self.code_model.send_request_name,
-            is_in_class=True,
-            method_param_signatures=self.code_model.service_client.send_request_signature(
-                async_mode or self.is_python3_file
-            ),
+            method_name=self.code_model.client.send_request_name,
+            need_self_param=True,
+            method_param_signatures=send_request_signature,
         )
 
-    def send_request_signature_and_response_type_annotation(self, async_mode: bool) -> str:
+    def send_request_signature_and_response_type_annotation(
+        self, async_mode: bool
+    ) -> str:
         send_request_signature = self._send_request_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
             is_python3_file=async_mode or self.is_python3_file,
             method_signature=send_request_signature,
-            response_type_annotation="Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse",
+            response_type_annotation="Awaitable[AsyncHttpResponse]"
+            if async_mode
+            else "HttpResponse",
         )
 
     def _example_make_call(self, async_mode: bool) -> List[str]:
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
         retval = [
-            f">>> response = {'await ' if async_mode else ''}client.{self.code_model.send_request_name}(request)"
+            f">>> response = {'await ' if async_mode else ''}client.{self.code_model.client.send_request_name}(request)"
         ]
         retval.append(f"<{http_response}: 200 OK>")
         return retval
 
     def _request_builder_example(self, async_mode: bool) -> List[str]:
         retval = [
-            "We have helper methods to create requests specific to this service in " +
-            f"`{self.code_model.namespace}.{self.code_model.rest_layer_name}`."
+            "We have helper methods to create requests specific to this service in "
+            + f"`{self.code_model.namespace}.{self.code_model.rest_layer_name}`."
         ]
-        retval.append("Use these helper methods to create the request you pass to this method.")
+        retval.append(
+            "Use these helper methods to create the request you pass to this method."
+        )
         retval.append("")
 
-        request_builder = self.code_model.rest.request_builders[0]
+        request_builder = self.code_model.request_builders[0]
         request_builder_signature = ", ".join(request_builder.parameters.call)
-        if request_builder.builder_group_name:
-            rest_imported = request_builder.builder_group_name
-            request_builder_name = f"{request_builder.builder_group_name}.{request_builder.name}"
+        if request_builder.group_name:
+            rest_imported = request_builder.group_name
+            request_builder_name = (
+                f"{request_builder.group_name}.{request_builder.name}"
+            )
         else:
             rest_imported = request_builder.name
             request_builder_name = request_builder.name
-        retval.append(f">>> from {self.code_model.namespace}.{self.code_model.rest_layer_name} import {rest_imported}")
-        retval.append(f">>> request = {request_builder_name}({request_builder_signature})")
-        retval.append(f"<HttpRequest [{request_builder.method}], url: '{request_builder.url}'>")
+        retval.append(
+            f">>> from {self.code_model.namespace}.{self.code_model.rest_layer_name} import {rest_imported}"
+        )
+        retval.append(
+            f">>> request = {request_builder_name}({request_builder_signature})"
+        )
+        retval.append(
+            f"<HttpRequest [{request_builder.method}], url: '{request_builder.url}'>"
+        )
         retval.extend(self._example_make_call(async_mode))
         return retval
 
@@ -173,33 +223,42 @@ class ClientSerializer:
         else:
             retval.extend(self._rest_request_example(async_mode))
         retval.append("")
-        retval.append("For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart")
+        retval.append(
+            "For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart"
+        )
         retval.append(f"")
         retval.append(":param request: The network request you want to make. Required.")
         retval.append(f":type request: ~azure.core.rest.HttpRequest")
-        retval.append(":keyword bool stream: Whether the response payload will be streamed. Defaults to False.")
-        retval.append(":return: The response of your network call. Does not do error handling on your response.")
+        retval.append(
+            ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
+        )
+        retval.append(
+            ":return: The response of your network call. Does not do error handling on your response."
+        )
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
         retval.append(f":rtype: ~azure.core.rest.{http_response}")
         retval.append('"""')
         return retval
 
     def serialize_path(self) -> List[str]:
-        return utils.serialize_path(self.code_model.global_parameters.path, "self._serialize")
+        return self.parameter_serializer.serialize_path(
+            self.code_model.client.parameters.path, "self._serialize"
+        )
 
-class ConfigSerializer:
 
+class ConfigSerializer:
     def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
+        self.parameter_serializer = ParameterSerializer()
         self.is_python3_file = is_python3_file
 
     def _init_signature(self, async_mode: bool) -> str:
-        return utils.serialize_method(
+        return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name="__init__",
-            is_in_class=True,
-            method_param_signatures=self.code_model.global_parameters.config_method_signature(
-                async_mode or self.is_python3_file
+            need_self_param=True,
+            method_param_signatures=self.code_model.config.parameters.method_signature(
+                async_mode or self.is_python3_file, async_mode
             ),
         )
 
@@ -212,29 +271,36 @@ class ConfigSerializer:
         )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.global_parameters.config_kwargs_to_pop(
-            async_mode or self.is_python3_file
-        ))
+        return self.parameter_serializer.pop_kwargs_from_signature(
+            self.code_model.config.parameters.kwargs_to_pop(
+                async_mode or self.is_python3_file
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=PopKwargType.NO,
+            pop_params_kwarg=PopKwargType.NO,
+        )
 
     def set_constants(self) -> List[str]:
         return [
-            f"self.{p.serialized_name} = {p.constant_declaration}"
-            for p in self.code_model.global_parameters.constant
-            if p not in self.code_model.global_parameters.method
+            f"self.{p.client_name} = {p.client_default_value_declaration}"
+            for p in self.code_model.config.parameters.constant
+            if p not in self.code_model.config.parameters.method
         ]
 
     def check_required_parameters(self) -> List[str]:
         return [
-            f'if {p.serialized_name} is None:\n'
-            f'    raise ValueError("Parameter \'{p.serialized_name}\' must not be None.")'
-            for p in self.code_model.global_parameters.config_method
-            if p.required and not p.constant
+            f"if {p.client_name} is None:\n"
+            f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
+            for p in self.code_model.config.parameters.method
+            if not (p.optional or p.constant)
         ]
 
-    def property_descriptions(self) -> List[str]:
+    def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
-        for p in self.code_model.global_parameters.config_method:
-            retval.append(f":{p.description_keyword} {p.serialized_name}: {p.description}")
-            retval.append(f":{p.docstring_type_keyword} {p.serialized_name}: {p.docstring_type}")
+        for p in self.code_model.config.parameters.method:
+            retval.append(f":{p.description_keyword} {p.client_name}: {p.description}")
+            retval.append(
+                f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}"
+            )
         retval.append('"""')
         return retval

package/autorest/codegen/serializers/general_serializer.py

@@ -5,27 +5,18 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
-from ..models import FileImport, ImportType, CodeModel, TokenCredentialSchema, ParameterList
+from ..models import (
+    FileImport,
+    ImportType,
+    CodeModel,
+)
 from .client_serializer import ClientSerializer, ConfigSerializer
 
-def config_imports(code_model, global_parameters: ParameterList, async_mode: bool) -> FileImport:
-    file_import = FileImport()
-    file_import.add_submodule_import("azure.core.configuration", "Configuration", ImportType.AZURECORE)
-    file_import.add_submodule_import("azure.core.pipeline", "policies", ImportType.AZURECORE)
-    file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-    if code_model.options["package_version"]:
-        file_import.add_submodule_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
-    for gp in global_parameters:
-        file_import.merge(gp.imports())
-    if code_model.options["azure_arm"]:
-        policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
-        file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE)
-        file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.AZURECORE)
-    return file_import
-
 
 class GeneralSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool) -> None:
+    def __init__(
+        self, code_model: CodeModel, env: Environment, async_mode: bool
+    ) -> None:
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
@@ -38,21 +29,9 @@ class GeneralSerializer:
         template = self.env.get_template("init.py.jinja2")
         return template.render(code_model=self.code_model, async_mode=self.async_mode)
 
-    def _correct_credential_parameter(self):
-        credential_param = [
-            gp for gp in self.code_model.global_parameters.parameters if isinstance(gp.schema, TokenCredentialSchema)
-        ][0]
-        credential_param.schema = TokenCredentialSchema(async_mode=self.async_mode)
-
     def serialize_service_client_file(self) -> str:
 
-        template = self.env.get_template("service_client.py.jinja2")
-
-        if (
-            self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
-        ):
-            self._correct_credential_parameter()
+        template = self.env.get_template("client.py.jinja2")
 
         python3_only = self.code_model.options["python3_only"]
         return template.render(
@@ -60,8 +39,8 @@ class GeneralSerializer:
             async_mode=self.async_mode,
             serializer=ClientSerializer(self.code_model, is_python3_file=python3_only),
             imports=FileImportSerializer(
-                self.code_model.service_client.imports(self.async_mode),
-                is_python3_file=self.async_mode or python3_only
+                self.code_model.client.imports(self.async_mode),
+                is_python3_file=self.async_mode or python3_only,
             ),
         )
 
@@ -77,37 +56,55 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
+        if self.code_model.need_mixin_abc:
+            file_import.add_submodule_import(
+                "abc",
+                "ABC",
+                ImportType.STDLIB,
+            )
+            file_import.add_submodule_import(
+                "azure.core",
+                f"{'Async' if self.async_mode else ''}PipelineClient",
+                ImportType.AZURECORE,
+                TypingSection.TYPING,
+            )
+            file_import.add_submodule_import(
+                "._configuration",
+                f"{self.code_model.client.name}Configuration",
+                ImportType.LOCAL,
+            )
+            file_import.add_submodule_import(
+                "msrest", "Serializer", ImportType.THIRDPARTY, TypingSection.TYPING
+            )
+            file_import.add_submodule_import(
+                "msrest", "Deserializer", ImportType.THIRDPARTY, TypingSection.TYPING
+            )
+
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
                 is_python3_file=self.async_mode,
-            )
+            ),
+            async_mode=self.async_mode,
         )
 
-
     def serialize_config_file(self) -> str:
 
-        package_name = self.code_model.options['package_name']
+        package_name = self.code_model.options["package_name"]
         if package_name and package_name.startswith("azure-"):
-            package_name = package_name[len("azure-"):]
-        sdk_moniker = package_name if package_name else self.code_model.class_name.lower()
-
-        if (
-            self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
-        ):
-            self._correct_credential_parameter()
-
+            package_name = package_name[len("azure-") :]
+        sdk_moniker = (
+            package_name if package_name else self.code_model.client.name.lower()
+        )
         template = self.env.get_template("config.py.jinja2")
         python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(
-                config_imports(
-                    self.code_model, self.code_model.global_parameters, self.async_mode
-                ), is_python3_file=self.async_mode or python3_only
+                self.code_model.config.imports(self.async_mode),
+                is_python3_file=self.async_mode or python3_only,
             ),
             serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
             sdk_moniker=sdk_moniker,