@autorest/python 6.1.10 → 6.2.0

package/autorest/codegen/serializers/general_serializer.py

@@ -3,22 +3,81 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Any
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType
 from ..models import (
     FileImport,
     ImportType,
+    NamespaceModel,
     CodeModel,
+    TokenCredentialType,
 )
 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:
+    """General serializer for SDK root level files"""
+
+    def __init__(self, code_model: CodeModel, env: Environment):
+        self.code_model = code_model
+        self.env = env
+
+    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 nm in self.code_model.namespace_models
+            for c in nm.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.namespace_models[0].clients[0].name,
+            "namespace": self.code_model.namespace_models[0],
+        }
+        params.update(self.code_model.options)
+        params.update(kwargs)
+        return template.render(**params)
+
+
+class GeneralNamespaceSerializer:
+    """General serializer for namespace level files"""
+
     def __init__(
-        self, code_model: CodeModel, env: Environment, async_mode: bool
+        self, namespace_model: NamespaceModel, env: Environment, async_mode: bool
     ) -> None:
-        self.code_model = code_model
+        self.namespace_model = namespace_model
         self.env = env
         self.async_mode = async_mode
 
@@ -28,19 +87,26 @@ class GeneralSerializer:
 
     def serialize_init_file(self) -> str:
         template = self.env.get_template("init.py.jinja2")
-        return template.render(code_model=self.code_model, async_mode=self.async_mode)
+        clients = [c for c in self.namespace_model.clients if c.request_builders]
+        return template.render(
+            namespace_model=self.namespace_model,
+            clients=clients,
+            async_mode=self.async_mode,
+        )
 
     def serialize_service_client_file(self) -> str:
 
-        template = self.env.get_template("client.py.jinja2")
+        template = self.env.get_template("client_container.py.jinja2")
+
+        imports = FileImport()
+        for client in self.namespace_model.clients:
+            imports.merge(client.imports(self.async_mode))
 
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             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:
@@ -48,14 +114,14 @@ class GeneralSerializer:
 
         # configure imports
         file_import = FileImport()
-        if self.code_model.need_request_converter:
+        if self.namespace_model.need_request_converter:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
                 "HttpRequest",
                 ImportType.AZURECORE,
             )
 
-        if self.code_model.need_mixin_abc:
+        if self.namespace_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",
                 "ABC",
@@ -67,20 +133,21 @@ 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,
+                self.namespace_model,
                 ".." if self.async_mode else ".",
                 MsrestImportType.SerializerDeserializer,
                 TypingSection.TYPING,
             )
+            for client in self.namespace_model.clients:
+                file_import.add_submodule_import(
+                    "._configuration",
+                    f"{client.name}Configuration",
+                    ImportType.LOCAL,
+                )
 
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             imports=FileImportSerializer(
                 file_import,
             ),
@@ -88,43 +155,29 @@ class GeneralSerializer:
         )
 
     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")
+        template = self.env.get_template("config_container.py.jinja2")
+        imports = FileImport()
+        for client in self.namespace_model.clients:
+            imports.merge(client.config.imports(self.async_mode))
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_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,
         )
 
     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)
+        return template.render(namespace_model=self.namespace_model)
 
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(namespace_model=self.namespace_model)
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(namespace_model=self.namespace_model)
 
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(namespace_model=self.namespace_model)

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,
+    NamespaceModel,
 )
 from .builder_serializer import get_operation_serializer
 
@@ -62,14 +62,17 @@ def _mixin_imports(
 
 
 class MetadataSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
+    def __init__(self, namespace_model: NamespaceModel, env: Environment) -> None:
+        self.namespace_model = namespace_model
+        self.client = self.namespace_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:
+        for operation_group in self.namespace_model.operation_groups:
             total_api_version_set.update(operation_group.api_versions)
 
         total_api_version_list = list(total_api_version_set)
@@ -82,7 +85,7 @@ class MetadataSerializer:
         if len(total_api_version_list) == 1:
             chosen_version = total_api_version_list[0]
         elif len(total_api_version_list) > 1:
-            module_version = self.code_model.namespace.split(".")[-1]
+            module_version = self.namespace_model.namespace.split(".")[-1]
             for api_version in total_api_version_list:
                 if "v{}".format(api_version.replace("-", "_")) == module_version:
                     chosen_version = api_version
@@ -99,7 +102,7 @@ class MetadataSerializer:
         mixin_operation_group: Optional[OperationGroup] = next(
             (
                 operation_group
-                for operation_group in self.code_model.operation_groups
+                for operation_group in self.namespace_model.operation_groups
                 if operation_group.is_mixin
             ),
             None,
@@ -112,14 +115,15 @@ class MetadataSerializer:
         chosen_version, total_api_version_list = self._choose_api_version()
 
         # 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"
+        self.namespace_model.options["package_version"] = "0.1.0"
         template = self.env.get_template("metadata.json.jinja2")
 
         return template.render(
+            namespace_model=self.namespace_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 +132,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(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(async_mode=True).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer,
-                code_model=self.code_model,
+                namespace_model=self.client.namespace_model,
                 async_mode=True,
             ),
             get_sync_operation_serializer=functools.partial(
                 get_operation_serializer,
-                code_model=self.code_model,
+                namespace_model=self.client.namespace_model,
                 async_mode=False,
             ),
-            has_credential=bool(self.code_model.credential),
+            has_credential=bool(self.client.credential),
         )

package/autorest/codegen/serializers/model_init_serializer.py

@@ -4,19 +4,21 @@
 # license information.
 # --------------------------------------------------------------------------
 from jinja2 import Environment
-from ..models import CodeModel
+from ..models import NamespaceModel
 
 
 class ModelInitSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
+    def __init__(self, namespace_model: NamespaceModel, env: Environment) -> None:
+        self.namespace_model = namespace_model
         self.env = env
 
     def serialize(self) -> str:
-        schemas = [s.name for s in self.code_model.public_model_types]
+        schemas = [s.name for s in self.namespace_model.public_model_types]
         schemas.sort()
         enums = (
-            [e.name for e in self.code_model.enums] if self.code_model.enums else None
+            [e.name for e in self.namespace_model.enums]
+            if self.namespace_model.enums
+            else None
         )
 
         if enums:
@@ -32,4 +34,6 @@ class ModelInitSerializer:
                 )
 
         template = self.env.get_template("model_init.py.jinja2")
-        return template.render(code_model=self.code_model, schemas=schemas, enums=enums)
+        return template.render(
+            namespace_model=self.namespace_model, schemas=schemas, enums=enums
+        )

package/autorest/codegen/serializers/model_serializer.py

@@ -6,7 +6,7 @@
 from typing import cast, List
 from abc import ABC, abstractmethod
 from jinja2 import Environment
-from ..models import ModelType, CodeModel, Property
+from ..models import ModelType, NamespaceModel, Property
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
 
@@ -28,8 +28,8 @@ def _documentation_string(
 
 
 class _ModelSerializer(ABC):
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
+    def __init__(self, namespace_model: NamespaceModel, env: Environment) -> None:
+        self.namespace_model = namespace_model
         self.env = env
 
     @abstractmethod
@@ -40,7 +40,7 @@ class _ModelSerializer(ABC):
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             imports=FileImportSerializer(self.imports()),
             str=str,
             serializer=self,
@@ -130,9 +130,9 @@ class MsrestModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.add_msrest_import(
-            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
+            self.namespace_model, "..", MsrestImportType.Module, TypingSection.REGULAR
         )
-        for model in self.code_model.model_types:
+        for model in self.namespace_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
             init_line_parameters = [
                 p for p in model.properties if not p.readonly and not p.is_discriminator
@@ -144,7 +144,7 @@ class MsrestModelSerializer(_ModelSerializer):
     def declare_model(self, model: ModelType) -> str:
         basename = (
             "msrest.serialization.Model"
-            if self.code_model.options["client_side_validation"]
+            if self.namespace_model.options["client_side_validation"]
             else "_serialization.Model"
         )
         if model.parents:
@@ -207,7 +207,7 @@ class DpgModelSerializer(_ModelSerializer):
         file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
-        for model in self.code_model.model_types:
+        for model in self.namespace_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
             for param in model.properties:
                 file_import.merge(param.imports())

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -3,14 +3,16 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional
+from typing import Optional, List, Union
 import functools
 from jinja2 import Environment
 
 from ..models import (
-    CodeModel,
+    NamespaceModel,
     OperationGroup,
     FileImport,
+    RequestBuilder,
+    OverloadedRequestBuilder,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import get_operation_serializer, RequestBuilderSerializer
@@ -19,21 +21,33 @@ from .builder_serializer import get_operation_serializer, RequestBuilderSerializ
 class OperationGroupsSerializer:
     def __init__(
         self,
-        code_model: CodeModel,
+        namespace_model: NamespaceModel,
         env: Environment,
         async_mode: bool,
         operation_group: Optional[OperationGroup] = None,
-    ) -> None:
-        self.code_model = code_model
+    ):
+        self.namespace_model = namespace_model
         self.env = env
         self.async_mode = async_mode
         self.operation_group = operation_group
 
+    def _get_request_builders(
+        self, operation_group: OperationGroup
+    ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
+        return [
+            r
+            for r in self.namespace_model.request_builders
+            if r.client.name == operation_group.client.name
+            and r.group_name == operation_group.property_name
+            and not r.is_overload
+            and not r.abstract
+        ]
+
     def serialize(self) -> str:
         operation_groups = (
             [self.operation_group]
             if self.operation_group
-            else self.code_model.operation_groups
+            else self.namespace_model.operation_groups
         )
         imports = FileImport()
         for operation_group in operation_groups:
@@ -47,7 +61,7 @@ class OperationGroupsSerializer:
             "operation_groups_container.py.jinja2"
         )
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
@@ -56,14 +70,12 @@ class OperationGroupsSerializer:
             async_mode=self.async_mode,
             get_operation_serializer=functools.partial(
                 get_operation_serializer,
-                code_model=self.code_model,
+                namespace_model=self.namespace_model,
                 async_mode=self.async_mode,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.code_model,
+                self.namespace_model,
                 async_mode=False,
             ),
-            request_builders=[
-                rb for rb in self.code_model.request_builders if not rb.abstract
-            ],
+            get_request_builders=self._get_request_builders,
         )

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -7,14 +7,14 @@ from typing import List
 from jinja2 import Environment
 
 from autorest.codegen.models.operation_group import OperationGroup
-from ..models import CodeModel
+from ..models import NamespaceModel
 
 
 class OperationsInitSerializer:
     def __init__(
-        self, code_model: CodeModel, env: Environment, async_mode: bool
+        self, namespace_model: NamespaceModel, env: Environment, async_mode: bool
     ) -> None:
-        self.code_model = code_model
+        self.namespace_model = namespace_model
         self.env = env
         self.async_mode = async_mode
 
@@ -22,13 +22,13 @@ class OperationsInitSerializer:
         def _get_filename(operation_group: OperationGroup) -> str:
             return (
                 "_operations"
-                if self.code_model.options["combine_operation_files"]
+                if self.namespace_model.options["combine_operation_files"]
                 else operation_group.filename
             )
 
         return [
             f"from .{_get_filename(og)} import {og.class_name}"
-            for og in self.code_model.operation_groups
+            for og in self.namespace_model.operation_groups
         ]
 
     def serialize(self) -> str:
@@ -37,8 +37,7 @@ class OperationsInitSerializer:
         )
 
         return operation_group_init_template.render(
-            code_model=self.code_model,
-            operation_groups=self.code_model.operation_groups,
+            namespace_model=self.namespace_model,
             async_mode=self.async_mode,
             operation_group_imports=self.operation_group_imports,
         )

package/autorest/codegen/serializers/patch_serializer.py

@@ -5,13 +5,13 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer
-from ..models import CodeModel, FileImport, ImportType, TypingSection
+from ..models import NamespaceModel, FileImport, ImportType, TypingSection
 
 
 class PatchSerializer:
-    def __init__(self, env: Environment, code_model: CodeModel) -> None:
+    def __init__(self, env: Environment, namespace_model: NamespaceModel) -> None:
         self.env = env
-        self.code_model = code_model
+        self.namespace_model = namespace_model
 
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
@@ -20,6 +20,6 @@ class PatchSerializer:
             "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             imports=FileImportSerializer(imports),
         )

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -8,18 +8,18 @@ from jinja2 import Environment
 
 from ..models import FileImport
 from .import_serializer import FileImportSerializer
-from ..models import CodeModel, RequestBuilderType
+from ..models import NamespaceModel, RequestBuilderType
 from .builder_serializer import RequestBuilderSerializer
 
 
 class RequestBuildersSerializer:
     def __init__(
         self,
-        code_model: CodeModel,
+        namespace_model: NamespaceModel,
         env: Environment,
         request_builders: List[RequestBuilderType],
     ) -> None:
-        self.code_model = code_model
+        self.namespace_model = namespace_model
         self.env = env
         self.request_builders = request_builders
         self.group_name = request_builders[0].group_name
@@ -35,7 +35,7 @@ class RequestBuildersSerializer:
     def serialize_init(self) -> str:
         template = self.env.get_template("rest_init.py.jinja2")
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             request_builders=[r for r in self.request_builders if not r.is_overload],
         )
 
@@ -43,12 +43,12 @@ class RequestBuildersSerializer:
         template = self.env.get_template("request_builders.py.jinja2")
 
         return template.render(
-            code_model=self.code_model,
+            namespace_model=self.namespace_model,
             request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.code_model, async_mode=False
+                self.namespace_model, async_mode=False
             ),
         )