@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/serializers/client_serializer.py

@@ -6,22 +6,23 @@
 from typing import List
 
 from . import utils
-from ..models import CodeModel
-from ..models.parameter import ParameterMethodLocation
+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
             ),
         )
 
@@ -34,50 +35,42 @@ 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(
+        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=utils.PopKwargType.NO,
-            pop_params_kwarg=utils.PopKwargType.NO,
+            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")
+        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.name}: {self.code_model.namespace}{operations_folder}{og.class_name}"
+                f":vartype {og.property_name}: {self.code_model.namespace}{operations_folder}{og.class_name}"
             )
-        for param in self.code_model.service_client.parameters.client_method:
+        for param in self.code_model.client.parameters.method:
             retval.append(
-                f":{param.description_keyword} {param.serialized_name}: {param.description}"
+                f":{param.description_keyword} {param.client_name}: {param.description}"
             )
             retval.append(
-                f":{param.docstring_type_keyword} {param.serialized_name}: {param.docstring_type}"
+                f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
             )
         if self.code_model.has_lro_operations:
             retval.append(
@@ -88,32 +81,36 @@ 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.method_location
-                in (ParameterMethodLocation.KWARG, ParameterMethodLocation.HIDDEN_KWARG)
+                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
+        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)"
         )
-        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)"
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.code_model.sorted_schemas:
+        if self.code_model.model_types:
             client_models_value = (
                 "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
             )
@@ -129,19 +126,12 @@ class ClientSerializer:
         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
+            og for og in self.code_model.operation_groups if not og.is_mixin
         ]
         for og in operation_groups:
-            disable_check = (
-                "  # type: ignore # pylint: disable=abstract-class-instantiated"
-                if og.has_abstract_operations
-                else ""
-            )
             retval.extend(
                 [
-                    f"self.{og.name} = {og.class_name}({disable_check}",
+                    f"self.{og.property_name} = {og.class_name}({og.mypy_ignore}{og.pylint_disable}",
                     "    self._client, self._config, self._serialize, self._deserialize",
                     ")",
                 ]
@@ -149,13 +139,21 @@ class ClientSerializer:
         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(
@@ -173,7 +171,7 @@ class ClientSerializer:
     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
@@ -189,13 +187,11 @@ class ClientSerializer:
         retval.append("")
 
         request_builder = self.code_model.request_builders[0]
-        request_builder_signature = ", ".join(
-            request_builder.parameters.call(async_mode)
-        )
-        if request_builder.builder_group_name:
-            rest_imported = request_builder.builder_group_name
+        request_builder_signature = ", ".join(request_builder.parameters.call)
+        if request_builder.group_name:
+            rest_imported = request_builder.group_name
             request_builder_name = (
-                f"{request_builder.builder_group_name}.{request_builder.name}"
+                f"{request_builder.group_name}.{request_builder.name}"
             )
         else:
             rest_imported = request_builder.name
@@ -245,23 +241,24 @@ class ClientSerializer:
         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:
     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
             ),
         )
 
@@ -274,38 +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(
+        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=utils.PopKwargType.NO,
-            pop_params_kwarg=utils.PopKwargType.NO,
+            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}"
-            )
+        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.serialized_name}: {p.docstring_type}"
+                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

@@ -9,46 +9,10 @@ from ..models import (
     FileImport,
     ImportType,
     CodeModel,
-    TokenCredentialSchema,
-    ParameterList,
 )
 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
@@ -65,23 +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_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(
@@ -89,7 +39,7 @@ 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),
+                self.code_model.client.imports(self.async_mode),
                 is_python3_file=self.async_mode or python3_only,
             ),
         )
@@ -120,7 +70,7 @@ class GeneralSerializer:
             )
             file_import.add_submodule_import(
                 "._configuration",
-                f"{self.code_model.class_name}Configuration",
+                f"{self.code_model.client.name}Configuration",
                 ImportType.LOCAL,
             )
             file_import.add_submodule_import(
@@ -145,24 +95,15 @@ class GeneralSerializer:
         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()
+            package_name if package_name else self.code_model.client.name.lower()
         )
-
-        if self.code_model.options["credential"] and isinstance(
-            self.code_model.credential_model.credential_schema_policy.credential,
-            TokenCredentialSchema,
-        ):
-            self._correct_credential_parameter()
-
         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
-                ),
+                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),

package/autorest/codegen/serializers/import_serializer.py

@@ -23,9 +23,10 @@ def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
     else:
         import_str = ", ".join(
             sorted(
-                [
-                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports  # type: ignore
-                ]
+                set(
+                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name  # type: ignore
+                    for i in imports
+                )
             )
         )
         buffer.append(f"from {imports[0].module_name} import {import_str}")
@@ -130,7 +131,9 @@ class FileImportSerializer:
                             )
                         )
                         if i > 0:
-                            ret[-1] += "  # type: ignore"
+                            ret[
+                                -1
+                            ] += "  # type: ignore  # pylint: disable=ungrouped-imports"
             ret.append("{}{} = {}".format(spacing, type_name, definition_value))
             return ret
 

package/autorest/codegen/serializers/metadata_serializer.py

@@ -4,45 +4,28 @@
 # license information.
 # --------------------------------------------------------------------------
 import functools
-import copy
 import json
 from typing import List, Optional, Set, Tuple, Dict, Union
 from jinja2 import Environment
-from .general_serializer import config_imports
 from ..models import (
     CodeModel,
-    FileImport,
     OperationGroup,
     LROOperation,
     PagingOperation,
-    TokenCredentialSchema,
-    ParameterList,
     TypingSection,
     ImportType,
-    GlobalParameterList,
 )
 from .builder_serializer import get_operation_serializer
 
 
-def _correct_credential_parameter(
-    global_parameters: ParameterList, async_mode: bool
-) -> None:
-    credential_param = [
-        gp
-        for gp in global_parameters.parameters
-        if isinstance(gp.schema, TokenCredentialSchema)
-    ][0]
-    credential_param.schema = TokenCredentialSchema(async_mode=async_mode)
-
-
 def _json_serialize_imports(
     imports: Dict[
         TypingSection,
         Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
     ]
-):
+) -> str:
     if not imports:
-        return None
+        return ""
 
     json_serialize_imports = {}
     # need to make name_import set -> list to make the dictionary json serializable
@@ -106,51 +89,6 @@ class MetadataSerializer:
 
         return chosen_version, total_api_version_list
 
-    def _make_async_copy_of_global_parameters(self) -> GlobalParameterList:
-        global_parameters = copy.deepcopy(self.code_model.global_parameters)
-        _correct_credential_parameter(global_parameters, True)
-        return global_parameters
-
-    def _service_client_imports(
-        self,
-        global_parameters: ParameterList,
-        mixin_operation_group: Optional[OperationGroup],
-        async_mode: bool,
-    ) -> str:
-        file_import = FileImport()
-        for gp in global_parameters:
-            file_import.merge(gp.imports())
-        file_import.add_submodule_import(
-            "azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE
-        )
-        file_import.add_submodule_import(
-            "azure.profiles.multiapiclient",
-            "MultiApiClientMixin",
-            import_type=ImportType.AZURECORE,
-        )
-        file_import.add_submodule_import(
-            "._configuration",
-            f"{self.code_model.class_name}Configuration",
-            ImportType.LOCAL,
-        )
-        # api_version and potentially endpoint require Optional typing
-        file_import.add_submodule_import(
-            "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
-        if mixin_operation_group:
-            file_import.add_submodule_import(
-                "._operations_mixin",
-                f"{self.code_model.class_name}OperationsMixin",
-                ImportType.LOCAL,
-            )
-        file_import.merge(
-            self.code_model.service_client.imports_for_multiapi(async_mode=async_mode)
-        )
-        return _json_serialize_imports(file_import.to_dict())
-
     def serialize(self) -> str:
         def _is_lro(operation):
             return isinstance(operation, LROOperation)
@@ -162,7 +100,7 @@ class MetadataSerializer:
             (
                 operation_group
                 for operation_group in self.code_model.operation_groups
-                if operation_group.is_empty_operation_group
+                if operation_group.is_mixin
             ),
             None,
         )
@@ -173,43 +111,15 @@ class MetadataSerializer:
 
         chosen_version, total_api_version_list = self._choose_api_version()
 
-        # we separate out async and sync for the case of credentials.
-        # In this case, we need two copies of the credential global parameter
-        # for typing purposes.
-        async_global_parameters = self.code_model.global_parameters
-        if self.code_model.options["credential"] and isinstance(
-            self.code_model.credential_model.credential_schema_policy.credential,
-            TokenCredentialSchema,
-        ):
-            # this ensures that the TokenCredentialSchema showing up in the list of code model's global parameters
-            # is sync. This way we only have to make a copy for an async_credential
-            _correct_credential_parameter(self.code_model.global_parameters, False)
-            async_global_parameters = self._make_async_copy_of_global_parameters()
-
-        sync_client_imports = self._service_client_imports(
-            self.code_model.global_parameters, mixin_operation_group, async_mode=False
-        )
-        async_client_imports = self._service_client_imports(
-            async_global_parameters, mixin_operation_group, async_mode=True
-        )
-
-        template = self.env.get_template("metadata.json.jinja2")
-
         # setting to true, because for multiapi we always generate with a version file with version 0.1.0
         self.code_model.options["package_version"] = "0.1.0"
-        if (
-            self.code_model.options["azure_arm"]
-            and not self.code_model.service_client.parameters.host
-        ):
-            self.code_model.service_client.parameters.add_host(
-                "https://management.azure.com"
-            )
+        template = self.env.get_template("metadata.json.jinja2")
+
         return template.render(
             chosen_version=chosen_version,
             total_api_version_list=total_api_version_list,
             code_model=self.code_model,
-            sync_global_parameters=self.code_model.global_parameters,
-            async_global_parameters=async_global_parameters,
+            global_parameters=self.code_model.client.parameters,
             mixin_operations=mixin_operations,
             any=any,
             is_lro=_is_lro,
@@ -217,17 +127,17 @@ class MetadataSerializer:
             str=str,
             sync_mixin_imports=sync_mixin_imports,
             async_mixin_imports=async_mixin_imports,
-            sync_client_imports=sync_client_imports,
-            async_client_imports=async_client_imports,
+            sync_client_imports=_json_serialize_imports(
+                self.code_model.client.imports_for_multiapi(async_mode=False).to_dict()
+            ),
+            async_client_imports=_json_serialize_imports(
+                self.code_model.client.imports_for_multiapi(async_mode=True).to_dict()
+            ),
             sync_config_imports=_json_serialize_imports(
-                config_imports(
-                    self.code_model, self.code_model.global_parameters, async_mode=False
-                ).to_dict()
+                self.code_model.config.imports(async_mode=False).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                config_imports(
-                    self.code_model, async_global_parameters, async_mode=True
-                ).to_dict()
+                self.code_model.config.imports(async_mode=True).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer,
@@ -241,4 +151,5 @@ class MetadataSerializer:
                 async_mode=False,
                 is_python3_file=False,
             ),
+            has_credential=bool(self.code_model.credential),
         )