@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/serializers/client_serializer.py

@@ -4,8 +4,10 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import List
+
 from . import utils
 from ..models import CodeModel
+from ..models.parameter import ParameterMethodLocation
 
 
 class ClientSerializer:
@@ -43,7 +45,9 @@ class ClientSerializer:
 
     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)
+        has_mixin_og = any(
+            og for og in self.code_model.operation_groups if og.is_empty_operation_group
+        )
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
@@ -59,12 +63,22 @@ class ClientSerializer:
     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]:
+        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}")
+            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}")
+            retval.append(
+                f":{param.description_keyword} {param.serialized_name}: {param.description}"
+            )
+            retval.append(
+                f":{param.docstring_type_keyword} {param.serialized_name}: {param.docstring_type}"
+            )
         if self.code_model.has_lro_operations:
             retval.append(
                 ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
@@ -79,38 +93,57 @@ class ClientSerializer:
             [
                 f"{p.serialized_name}={p.serialized_name}"
                 for p in self.code_model.service_client.parameters.config_method
-                if not p.is_kwarg
-            ] + [
-                "**kwargs"
-            ])
+                if not p.method_location
+                in (ParameterMethodLocation.KWARG, ParameterMethodLocation.HIDDEN_KWARG)
+            ]
+            + ["**kwargs"]
+        )
         return f"self._config = {config_name}({config_call})"
 
     def initialize_pipeline_client(self, async_mode: bool) -> str:
-        host_variable_name = self.code_model.service_client.parameters.host_variable_name
+        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
+            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:
-            client_models_value = "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
+            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_empty_operation_group
+        ]
+        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}(self._client, self._config, self._serialize, self._deserialize)"
-                    for og in operation_groups
+                    f"self.{og.name} = {og.class_name}({disable_check}",
+                    "    self._client, self._config, self._serialize, self._deserialize",
+                    ")",
                 ]
             )
         return retval
@@ -125,12 +158,16 @@ class ClientSerializer:
             ),
         )
 
-    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]:
@@ -143,23 +180,35 @@ class ClientSerializer:
 
     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_signature = ", ".join(request_builder.parameters.call)
+        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_name = f"{request_builder.builder_group_name}.{request_builder.name}"
+            request_builder_name = (
+                f"{request_builder.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
 
@@ -178,22 +227,30 @@ 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 utils.serialize_path(
+            self.code_model.global_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.is_python3_file = is_python3_file
@@ -235,8 +292,8 @@ class ConfigSerializer:
 
     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.")'
+            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
         ]
@@ -244,7 +301,11 @@ class ConfigSerializer:
     def property_descriptions(self) -> 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}")
+            retval.append(
+                f":{p.description_keyword} {p.serialized_name}: {p.description}"
+            )
+            retval.append(
+                f":{p.docstring_type_keyword} {p.serialized_name}: {p.docstring_type}"
+            )
         retval.append('"""')
         return retval

package/autorest/codegen/serializers/general_serializer.py

@@ -5,27 +5,54 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
-from ..models import FileImport, ImportType, CodeModel, TokenCredentialSchema, ParameterList
+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:
+
+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)
+    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)
+        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)
+        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
@@ -40,7 +67,9 @@ class GeneralSerializer:
 
     def _correct_credential_parameter(self):
         credential_param = [
-            gp for gp in self.code_model.global_parameters.parameters if isinstance(gp.schema, TokenCredentialSchema)
+            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)
 
@@ -48,9 +77,9 @@ class GeneralSerializer:
 
         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)
+        if self.code_model.options["credential"] and isinstance(
+            self.code_model.credential_model.credential_schema_policy.credential,
+            TokenCredentialSchema,
         ):
             self._correct_credential_parameter()
 
@@ -61,7 +90,7 @@ class GeneralSerializer:
             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
+                is_python3_file=self.async_mode or python3_only,
             ),
         )
 
@@ -92,10 +121,14 @@ class GeneralSerializer:
             file_import.add_submodule_import(
                 "._configuration",
                 f"{self.code_model.class_name}Configuration",
-                ImportType.LOCAL
+                ImportType.LOCAL,
+            )
+            file_import.add_submodule_import(
+                "msrest", "Serializer", ImportType.THIRDPARTY, TypingSection.TYPING
+            )
+            file_import.add_submodule_import(
+                "msrest", "Deserializer", ImportType.THIRDPARTY, TypingSection.TYPING
             )
-            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,
@@ -106,17 +139,18 @@ class GeneralSerializer:
             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()
+            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_model.credential_schema_policy.credential, TokenCredentialSchema)
+        if self.code_model.options["credential"] and isinstance(
+            self.code_model.credential_model.credential_schema_policy.credential,
+            TokenCredentialSchema,
         ):
             self._correct_credential_parameter()
 
@@ -128,7 +162,8 @@ class GeneralSerializer:
             imports=FileImportSerializer(
                 config_imports(
                     self.code_model, self.code_model.global_parameters, self.async_mode
-                ), is_python3_file=self.async_mode or python3_only
+                ),
+                is_python3_file=self.async_mode or python3_only,
             ),
             serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
             sdk_moniker=sdk_moniker,

package/autorest/codegen/serializers/import_serializer.py

@@ -5,49 +5,68 @@
 # --------------------------------------------------------------------------
 from copy import deepcopy
 from typing import List
-from ..models.imports import ImportType, FileImport, ImportModel, TypingSection
+from ..models.imports import (
+    ImportType,
+    FileImport,
+    ImportModel,
+    TypingSection,
+    TypeDefinition,
+)
 
-def _serialize_package(
-    imports: List[ImportModel], delimiter: str
-) -> str:
+
+def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
     buffer = []
     if any(i for i in imports if i.submodule_name is None):
-        buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
+        buffer.append(
+            f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}"
+        )
     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
-        ]))
+        import_str = ", ".join(
+            sorted(
+                [
+                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports  # type: ignore
+                ]
+            )
+        )
         buffer.append(f"from {imports[0].module_name} import {import_str}")
     return delimiter.join(buffer)
 
+
 def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
     """Serialize a given import type."""
     import_list = []
     for module_name in sorted(set(i.module_name for i in imports)):
 
-        import_list.append(_serialize_package([
-            i for i in imports if i.module_name == module_name
-        ], delimiter))
+        import_list.append(
+            _serialize_package(
+                [i for i in imports if i.module_name == module_name], delimiter
+            )
+        )
     return delimiter.join(import_list)
 
-def _get_import_clauses(
-    imports: List[ImportModel], delimiter: str
-) -> List[str]:
+
+def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]:
     import_clause = []
     for import_type in ImportType:
         imports_with_import_type = [i for i in imports if i.import_type == import_type]
         if imports_with_import_type:
-            import_clause.append(_serialize_import_type(imports_with_import_type, delimiter))
+            import_clause.append(
+                _serialize_import_type(imports_with_import_type, delimiter)
+            )
     return import_clause
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False) -> None:
+    def __init__(
+        self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False
+    ) -> None:
         self.file_import = file_import
         self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
-    def _get_imports_list(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
+    def _get_imports_list(
+        self, baseline_typing_section: TypingSection, add_conditional_typing: bool
+    ):
         # If this is a python 3 file, our regular imports include the CONDITIONAL category
         # If this is not a python 3 file, our typing imports include the CONDITIONAL category
         file_import_copy = deepcopy(self.file_import)
@@ -62,33 +81,73 @@ class FileImportSerializer:
         return file_import_copy.get_imports_from_section(baseline_typing_section)
 
     def _add_type_checking_import(self):
-        any_typing = any(self.file_import.get_imports_from_section(TypingSection.TYPING))
+        any_typing = any(
+            self.file_import.get_imports_from_section(TypingSection.TYPING)
+        )
         conditional_and_not_py3 = not self.is_python3_file and any(
             self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
         )
         if any_typing or conditional_and_not_py3:
-            self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+            self.file_import.add_submodule_import(
+                "typing", "TYPE_CHECKING", ImportType.STDLIB
+            )
 
     def _get_typing_definitions(self) -> str:
+        def declare_defintion(
+            spacing: str, type_name: str, type_definition: TypeDefinition
+        ) -> List[str]:
+            ret: List[str] = []
+            definition_value = (
+                type_definition.async_definition
+                if self.async_mode
+                else type_definition.sync_definition
+            )
+            if type_definition.version_imports is not None:
+                versions = type_definition.version_imports.keys()
+                for i, version in enumerate(
+                    sorted(
+                        versions, key=lambda x: x if x is not None else (), reverse=True
+                    )
+                ):
+                    if version is not None:
+                        ret.append(
+                            "{}{} sys.version_info >= {}:".format(
+                                spacing, "if" if i == 0 else "elif", version
+                            )
+                        )
+                    elif i > 0:
+                        ret.append("{}else:".format(spacing))
+                    for import_clause in _get_import_clauses(
+                        [type_definition.version_imports[version]], "\n"
+                    ):
+                        ret.append(
+                            "{}{}{}".format(
+                                "    "
+                                if len(versions) > 1 or version is not None
+                                else "",
+                                spacing,
+                                import_clause,
+                            )
+                        )
+                        if i > 0:
+                            ret[-1] += "  # type: ignore"
+            ret.append("{}{} = {}".format(spacing, type_name, definition_value))
+            return ret
+
         if not self.file_import.type_definitions:
             return ""
         spacing = "" if self.is_python3_file else "    "
-        declarations: List[str] = [f"\n{spacing}T = TypeVar('T')"]
-        declarations.extend([
-            "{}{} = {}".format(
-                spacing,
-                type_name,
-                values[1] if self.async_mode else values[0]
-            )
-            for type_name, values in self.file_import.type_definitions.items()
-        ])
+        declarations: List[str] = [""]
+        for type_name, value in self.file_import.type_definitions.items():
+            declarations.extend(declare_defintion(spacing, type_name, value))
         return "\n".join(declarations)
 
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
         regular_imports_list = self._get_imports_list(
-            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
+            baseline_typing_section=TypingSection.REGULAR,
+            add_conditional_typing=self.is_python3_file,
         )
 
         if regular_imports_list:
@@ -98,9 +157,12 @@ class FileImportSerializer:
 
         typing_imports = ""
         typing_imports_list = self._get_imports_list(
-            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
+            baseline_typing_section=TypingSection.TYPING,
+            add_conditional_typing=not self.is_python3_file,
         )
         if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_list, "\n    "))
+            typing_imports += "\n\n    ".join(
+                _get_import_clauses(typing_imports_list, "\n    ")
+            )
         return regular_imports + typing_imports + self._get_typing_definitions()