@autorest/python 6.1.11 → 6.2.1

package/autorest/codegen/serializers/client_serializer.py

@@ -6,18 +6,18 @@
 from typing import List
 
 from . import utils
-from ..models import CodeModel, ParameterMethodLocation
+from ..models import Client, ParameterMethodLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
-        self.code_model = code_model
+    def __init__(self, client: Client) -> None:
+        self.client = client
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
         pylint_disable = ""
-        if not self.code_model.client.parameters.credential:
+        if not self.client.parameters.credential:
             pylint_disable = (
                 "  # pylint: disable=missing-client-constructor-parameter-credential"
             )
@@ -25,9 +25,7 @@ class ClientSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.code_model.client.parameters.method_signature(
-                async_mode
-            ),
+            method_param_signatures=self.client.parameters.method_signature(async_mode),
             pylint_disable=pylint_disable,
         )
 
@@ -40,7 +38,7 @@ class ClientSerializer:
 
     def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.client.parameters.kwargs_to_pop,
+            self.client.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
@@ -48,12 +46,12 @@ class ClientSerializer:
 
     @property
     def class_definition(self) -> str:
-        class_name = self.code_model.client.name
-        has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_mixin)
+        class_name = self.client.name
+        has_mixin_og = any(og for og in self.client.operation_groups if og.is_mixin)
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        pylint_disable = self.code_model.client.pylint_disable
+        pylint_disable = self.client.pylint_disable
         if base_class:
             return f"class {class_name}({base_class}):{pylint_disable}"
         return f"class {class_name}:{pylint_disable}"
@@ -61,19 +59,20 @@ 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_mixin]:
+        for og in [og for og in self.client.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}"
+            property_type = (
+                f"{self.client.code_model.namespace}{operations_folder}{og.class_name}"
             )
-        for param in self.code_model.client.parameters.method:
+            retval.append(f":vartype {og.property_name}: {property_type}")
+        for param in self.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:
+        if self.client.has_lro_operations:
             retval.append(
                 ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
                 "if no Retry-After header is present."
@@ -82,11 +81,11 @@ class ClientSerializer:
         return retval
 
     def initialize_config(self) -> str:
-        config_name = f"{self.code_model.client.name}Configuration"
+        config_name = f"{self.client.name}Configuration"
         config_call = ", ".join(
             [
                 f"{p.client_name}={p.client_name}"
-                for p in self.code_model.config.parameters.method
+                for p in self.client.config.parameters.method
                 if p.method_location != ParameterMethodLocation.KWARG
             ]
             + ["**kwargs"]
@@ -96,9 +95,7 @@ class ClientSerializer:
     @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
+            return next(p for p in self.client.parameters if p.is_host).client_name
         except StopIteration:
             return "_endpoint"
 
@@ -106,12 +103,12 @@ class ClientSerializer:
     def should_init_super(self) -> bool:
         return any(
             og
-            for og in self.code_model.operation_groups
+            for og in self.client.operation_groups
             if og.is_mixin and og.has_abstract_operations
         )
 
     def initialize_pipeline_client(self, async_mode: bool) -> str:
-        pipeline_client_name = self.code_model.client.pipeline_class(async_mode)
+        pipeline_client_name = self.client.pipeline_class(async_mode)
         return (
             f"self._client = {pipeline_client_name}(base_url={self.host_variable_name}, "
             "config=self._config, **kwargs)"
@@ -119,22 +116,22 @@ class ClientSerializer:
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.code_model.model_types:
+        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]"
-        is_msrest_model = self.code_model.options["models_mode"] == "msrest"
+        is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
         if is_msrest_model:
             retval.append(f"client_models = {client_models_value}")
         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})")
-        if not self.code_model.options["client_side_validation"]:
+        if not self.client.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_mixin
+            og for og in self.client.operation_groups if not og.is_mixin
         ]
         for og in operation_groups:
             retval.extend(
@@ -149,10 +146,10 @@ class ClientSerializer:
     def _send_request_signature(self) -> str:
         send_request_signature = [
             "request: HttpRequest,"
-        ] + self.code_model.client.parameters.method_signature_kwargs
+        ] + self.client.parameters.method_signature_kwargs
         return self.parameter_serializer.serialize_method(
             function_def="def",
-            method_name=self.code_model.client.send_request_name,
+            method_name=self.client.send_request_name,
             need_self_param=True,
             method_param_signatures=send_request_signature,
         )
@@ -171,7 +168,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.client.send_request_name}(request)"
+            f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"
         ]
         retval.append(f"<{http_response}: 200 OK>")
         return retval
@@ -179,14 +176,14 @@ 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}`."
+            + f"`{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}`."
         ]
         retval.append(
             "Use these helper methods to create the request you pass to this method."
         )
         retval.append("")
 
-        request_builder = self.code_model.request_builders[0]
+        request_builder = self.client.request_builders[0]
         request_builder_signature = ", ".join(request_builder.parameters.call)
         if request_builder.group_name:
             rest_imported = request_builder.group_name
@@ -196,9 +193,8 @@ class ClientSerializer:
         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}"
-        )
+        full_path = f"{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}"
+        retval.append(f">>> from {full_path} import {rest_imported}")
         retval.append(
             f">>> request = {request_builder_name}({request_builder_signature})"
         )
@@ -218,7 +214,7 @@ class ClientSerializer:
     def send_request_description(self, async_mode: bool) -> List[str]:
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
-        if self.code_model.options["builders_visibility"] != "embedded":
+        if self.client.code_model.options["builders_visibility"] != "embedded":
             retval.extend(self._request_builder_example(async_mode))
         else:
             retval.extend(self._rest_request_example(async_mode))
@@ -242,13 +238,13 @@ class ClientSerializer:
 
     def serialize_path(self) -> List[str]:
         return self.parameter_serializer.serialize_path(
-            self.code_model.client.parameters.path, "self._serialize"
+            self.client.parameters.path, "self._serialize"
         )
 
 
 class ConfigSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
-        self.code_model = code_model
+    def __init__(self, client: Client) -> None:
+        self.client = client
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
@@ -256,7 +252,7 @@ class ConfigSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.code_model.config.parameters.method_signature(
+            method_param_signatures=self.client.config.parameters.method_signature(
                 async_mode
             ),
         )
@@ -270,7 +266,7 @@ class ConfigSerializer:
 
     def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.config.parameters.kwargs_to_pop,
+            self.client.config.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
@@ -279,21 +275,21 @@ class ConfigSerializer:
     def set_constants(self) -> List[str]:
         return [
             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
+            for p in self.client.config.parameters.constant
+            if p not in self.client.config.parameters.method
         ]
 
     def check_required_parameters(self) -> List[str]:
         return [
             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
+            for p in self.client.config.parameters.method
             if not (p.optional or p.constant)
         ]
 
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
-        for p in self.code_model.config.parameters.method:
+        for p in self.client.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)}"

package/autorest/codegen/serializers/general_serializer.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Any, List
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType
@@ -10,37 +11,91 @@ from ..models import (
     FileImport,
     ImportType,
     CodeModel,
+    TokenCredentialType,
+    Client,
 )
 from .client_serializer import ClientSerializer, ConfigSerializer
 
+_PACKAGE_MODE_FILES = [
+    "CHANGELOG.md.jinja2",
+    "dev_requirements.txt.jinja2",
+    "LICENSE.jinja2",
+    "MANIFEST.in.jinja2",
+    "README.md.jinja2",
+]
+
 
 class GeneralSerializer:
-    def __init__(
-        self, code_model: CodeModel, env: Environment, async_mode: bool
-    ) -> None:
+    """General serializer for SDK root level files"""
+
+    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool):
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
 
+    def serialize_setup_file(self) -> str:
+        template = self.env.get_template("packaging_templates/setup.py.jinja2")
+        params = {}
+        params.update(self.code_model.options)
+        return template.render(code_model=self.code_model, **params)
+
+    def serialize_package_file(self, template_name: str, **kwargs: Any) -> str:
+        template = self.env.get_template(template_name)
+        package_parts = (self.code_model.options["package_name"] or "").split("-")[:-1]
+        token_credential = any(
+            c
+            for c in self.code_model.clients
+            if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
+        )
+        version = self.code_model.options["package_version"]
+        if any(x in version for x in ["a", "b", "rc"]) or version[0] == "0":
+            dev_status = "4 - Beta"
+        else:
+            dev_status = "5 - Production/Stable"
+        params = {
+            "code_model": self.code_model,
+            "dev_status": dev_status,
+            "token_credential": token_credential,
+            "pkgutil_names": [
+                ".".join(package_parts[: i + 1]) for i in range(len(package_parts))
+            ],
+            "init_names": [
+                "/".join(package_parts[: i + 1]) + "/__init__.py"
+                for i in range(len(package_parts))
+            ],
+            "client_name": self.code_model.clients[0].name,
+            "namespace": self.code_model.namespace,
+        }
+        params.update(self.code_model.options)
+        params.update(kwargs)
+        return template.render(**params)
+
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
         return template.render()
 
-    def serialize_init_file(self) -> str:
+    def serialize_init_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("init.py.jinja2")
-        return template.render(code_model=self.code_model, async_mode=self.async_mode)
+        return template.render(
+            code_model=self.code_model,
+            clients=clients,
+            async_mode=self.async_mode,
+        )
 
-    def serialize_service_client_file(self) -> str:
+    def serialize_service_client_file(self, clients: List[Client]) -> str:
 
-        template = self.env.get_template("client.py.jinja2")
+        template = self.env.get_template("client_container.py.jinja2")
+
+        imports = FileImport()
+        for client in clients:
+            imports.merge(client.imports(self.async_mode))
 
         return template.render(
             code_model=self.code_model,
+            clients=clients,
             async_mode=self.async_mode,
-            serializer=ClientSerializer(self.code_model),
-            imports=FileImportSerializer(
-                self.code_model.client.imports(self.async_mode),
-            ),
+            get_serializer=ClientSerializer,
+            imports=FileImportSerializer(imports),
         )
 
     def serialize_vendor_file(self) -> str:
@@ -67,17 +122,18 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
                 TypingSection.TYPING,
             )
-            file_import.add_submodule_import(
-                "._configuration",
-                f"{self.code_model.client.name}Configuration",
-                ImportType.LOCAL,
-            )
             file_import.add_msrest_import(
                 self.code_model,
                 ".." if self.async_mode else ".",
                 MsrestImportType.SerializerDeserializer,
                 TypingSection.TYPING,
             )
+            for client in self.code_model.clients:
+                file_import.add_submodule_import(
+                    "._configuration",
+                    f"{client.name}Configuration",
+                    ImportType.LOCAL,
+                )
 
         return template.render(
             code_model=self.code_model,
@@ -87,36 +143,23 @@ class GeneralSerializer:
             async_mode=self.async_mode,
         )
 
-    def serialize_config_file(self) -> str:
-
-        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.client.name.lower()
-        )
-        template = self.env.get_template("config.py.jinja2")
+    def serialize_config_file(self, clients: List[Client]) -> str:
+        template = self.env.get_template("config_container.py.jinja2")
+        imports = FileImport()
+        for client in self.code_model.clients:
+            imports.merge(client.config.imports(self.async_mode))
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
-            imports=FileImportSerializer(
-                self.code_model.config.imports(self.async_mode),
-            ),
-            serializer=ConfigSerializer(self.code_model),
-            sdk_moniker=sdk_moniker,
+            imports=FileImportSerializer(imports),
+            get_serializer=ConfigSerializer,
+            clients=clients,
         )
 
     def serialize_version_file(self) -> str:
         template = self.env.get_template("version.py.jinja2")
         return template.render(code_model=self.code_model)
 
-    def serialize_setup_file(self) -> str:
-        template = self.env.get_template("setup.py.jinja2")
-        params = {}
-        params.update(self.code_model.options)
-        params.update(self.code_model.package_dependency)
-        return template.render(code_model=self.code_model, **params)
-
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
         return template.render(code_model=self.code_model)

package/autorest/codegen/serializers/import_serializer.py

@@ -33,16 +33,40 @@ def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
     return delimiter.join(buffer)
 
 
+def _serialize_versioned_package(i: ImportModel, delimiter: str) -> str:
+    if not i.version_modules:
+        return ""
+    buffer = []
+    for n, (version, module_name, comment) in enumerate(i.version_modules):
+        buffer.append(
+            "{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version)
+        )
+        buffer.append(
+            f"    from {module_name} import {i.submodule_name}{f' as {i.alias}' if i.alias else ''}"
+            f"{f' # {comment}' if comment else ''}"
+        )
+    buffer.append("else:")
+    buffer.append(
+        f"    from {i.module_name} import {i.submodule_name}{f' as {i.alias}' if i.alias else ''}"
+        "  # type: ignore  # pylint: disable=ungrouped-imports"
+    )
+    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
-            )
-        )
+        normal_imports = [
+            i for i in imports if i.module_name == module_name and not i.version_modules
+        ]
+        versioned_imports = [
+            i for i in imports if i.module_name == module_name and i.version_modules
+        ]
+        if normal_imports:
+            import_list.append(_serialize_package(normal_imports, delimiter))
+        for i in versioned_imports:
+            import_list.append(_serialize_versioned_package(i, delimiter))
     return delimiter.join(import_list)
 
 
@@ -94,36 +118,6 @@ class FileImportSerializer:
                 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(
-                                "if" if i == 0 else "elif", version
-                            )
-                        )
-                    elif i > 0:
-                        ret.append("else:")
-                    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 "",
-                                import_clause,
-                            )
-                        )
-                        if i > 0:
-                            ret[
-                                -1
-                            ] += "  # type: ignore  # pylint: disable=ungrouped-imports"
             ret.append("{} = {}".format(type_name, definition_value))
             return ret
 

package/autorest/codegen/serializers/metadata_serializer.py

@@ -8,12 +8,12 @@ import json
 from typing import List, Optional, Set, Tuple, Dict, Union
 from jinja2 import Environment
 from ..models import (
-    CodeModel,
     OperationGroup,
     LROOperation,
     PagingOperation,
     TypingSection,
     ImportType,
+    CodeModel,
 )
 from .builder_serializer import get_operation_serializer
 
@@ -21,7 +21,25 @@ from .builder_serializer import get_operation_serializer
 def _json_serialize_imports(
     imports: Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[str, str],
+                            Tuple[
+                                str,
+                                Optional[str],
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]
 ) -> str:
     if not imports:
@@ -64,13 +82,15 @@ def _mixin_imports(
 class MetadataSerializer:
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         self.code_model = code_model
+        self.client = self.code_model.clients[0]  # we only do one client for multiapi
         self.env = env
 
     def _choose_api_version(self) -> Tuple[str, List[str]]:
         chosen_version = ""
         total_api_version_set: Set[str] = set()
-        for operation_group in self.code_model.operation_groups:
-            total_api_version_set.update(operation_group.api_versions)
+        for client in self.code_model.clients:
+            for operation_group in client.operation_groups:
+                total_api_version_set.update(operation_group.api_versions)
 
         total_api_version_list = list(total_api_version_set)
         total_api_version_list.sort()
@@ -99,7 +119,8 @@ class MetadataSerializer:
         mixin_operation_group: Optional[OperationGroup] = next(
             (
                 operation_group
-                for operation_group in self.code_model.operation_groups
+                for client in self.code_model.clients
+                for operation_group in client.operation_groups
                 if operation_group.is_mixin
             ),
             None,
@@ -116,10 +137,11 @@ class MetadataSerializer:
         template = self.env.get_template("metadata.json.jinja2")
 
         return template.render(
+            code_model=self.code_model,
             chosen_version=chosen_version,
             total_api_version_list=total_api_version_list,
-            code_model=self.code_model,
-            global_parameters=self.code_model.client.parameters,
+            client=self.client,
+            global_parameters=self.client.parameters,
             mixin_operations=mixin_operations,
             any=any,
             is_lro=_is_lro,
@@ -128,26 +150,26 @@ class MetadataSerializer:
             sync_mixin_imports=sync_mixin_imports,
             async_mixin_imports=async_mixin_imports,
             sync_client_imports=_json_serialize_imports(
-                self.code_model.client.imports_for_multiapi(async_mode=False).to_dict()
+                self.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()
+                self.client.imports_for_multiapi(async_mode=True).to_dict()
             ),
             sync_config_imports=_json_serialize_imports(
-                self.code_model.config.imports(async_mode=False).to_dict()
+                self.client.config.imports_for_multiapi(async_mode=False).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                self.code_model.config.imports(async_mode=True).to_dict()
+                self.client.config.imports_for_multiapi(async_mode=True).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer,
-                code_model=self.code_model,
+                code_model=self.client.code_model,
                 async_mode=True,
             ),
             get_sync_operation_serializer=functools.partial(
                 get_operation_serializer,
-                code_model=self.code_model,
+                code_model=self.client.code_model,
                 async_mode=False,
             ),
-            has_credential=bool(self.code_model.credential),
+            has_credential=bool(self.client.credential),
         )