@autorest/python 6.2.0 → 6.2.1

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

@@ -13,7 +13,7 @@ from ..models import (
     PagingOperation,
     TypingSection,
     ImportType,
-    NamespaceModel,
+    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:
@@ -62,18 +80,17 @@ def _mixin_imports(
 
 
 class MetadataSerializer:
-    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
+    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.namespace_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()
@@ -85,7 +102,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.namespace_model.namespace.split(".")[-1]
+            module_version = self.code_model.namespace.split(".")[-1]
             for api_version in total_api_version_list:
                 if "v{}".format(api_version.replace("-", "_")) == module_version:
                     chosen_version = api_version
@@ -102,7 +119,8 @@ class MetadataSerializer:
         mixin_operation_group: Optional[OperationGroup] = next(
             (
                 operation_group
-                for operation_group in self.namespace_model.operation_groups
+                for client in self.code_model.clients
+                for operation_group in client.operation_groups
                 if operation_group.is_mixin
             ),
             None,
@@ -115,11 +133,11 @@ 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.namespace_model.options["package_version"] = "0.1.0"
+        self.code_model.options["package_version"] = "0.1.0"
         template = self.env.get_template("metadata.json.jinja2")
 
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             chosen_version=chosen_version,
             total_api_version_list=total_api_version_list,
             client=self.client,
@@ -138,19 +156,19 @@ class MetadataSerializer:
                 self.client.imports_for_multiapi(async_mode=True).to_dict()
             ),
             sync_config_imports=_json_serialize_imports(
-                self.client.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.client.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,
-                namespace_model=self.client.namespace_model,
+                code_model=self.client.code_model,
                 async_mode=True,
             ),
             get_sync_operation_serializer=functools.partial(
                 get_operation_serializer,
-                namespace_model=self.client.namespace_model,
+                code_model=self.client.code_model,
                 async_mode=False,
             ),
             has_credential=bool(self.client.credential),

package/autorest/codegen/serializers/model_init_serializer.py

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

package/autorest/codegen/serializers/model_serializer.py

@@ -5,10 +5,12 @@
 # --------------------------------------------------------------------------
 from typing import cast, List
 from abc import ABC, abstractmethod
+
 from jinja2 import Environment
-from ..models import ModelType, NamespaceModel, Property
+from ..models import ModelType, CodeModel, Property
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
+from ..models.constant_type import ConstantType
 
 
 def _documentation_string(
@@ -28,8 +30,8 @@ def _documentation_string(
 
 
 class _ModelSerializer(ABC):
-    def __init__(self, namespace_model: NamespaceModel, env: Environment) -> None:
-        self.namespace_model = namespace_model
+    def __init__(self, code_model: CodeModel, env: Environment) -> None:
+        self.code_model = code_model
         self.env = env
 
     @abstractmethod
@@ -40,7 +42,7 @@ class _ModelSerializer(ABC):
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             imports=FileImportSerializer(self.imports()),
             str=str,
             serializer=self,
@@ -93,13 +95,17 @@ class _ModelSerializer(ABC):
             f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
         )
 
-    def init_line(self, model: ModelType) -> List[str]:
-        init_properties_declaration = []
-        init_line_parameters = [
+    @staticmethod
+    def _init_line_parameters(model: ModelType):
+        return [
             p
             for p in model.properties
             if not p.readonly and not p.is_discriminator and not p.constant
         ]
+
+    def init_line(self, model: ModelType) -> List[str]:
+        init_properties_declaration = []
+        init_line_parameters = self._init_line_parameters(model)
         init_line_parameters.sort(key=lambda x: x.optional)
         if init_line_parameters:
             init_properties_declaration.append("*,")
@@ -130,21 +136,19 @@ class MsrestModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.add_msrest_import(
-            self.namespace_model, "..", MsrestImportType.Module, TypingSection.REGULAR
+            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
         )
-        for model in self.namespace_model.model_types:
+        for model in self.code_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
-            ]
-            for param in init_line_parameters:
+            for param in self._init_line_parameters(model):
                 file_import.merge(param.imports())
+
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
         basename = (
             "msrest.serialization.Model"
-            if self.namespace_model.options["client_side_validation"]
+            if self.code_model.options["client_side_validation"]
             else "_serialization.Model"
         )
         if model.parents:
@@ -207,10 +211,10 @@ 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.namespace_model.model_types:
+        for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
-            for param in model.properties:
-                file_import.merge(param.imports())
+            for prop in model.properties:
+                file_import.merge(prop.imports())
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
@@ -222,30 +226,31 @@ class DpgModelSerializer(_ModelSerializer):
         return f"class {model.name}({basename}):{model.pylint_disable}"
 
     @staticmethod
-    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+    def get_properties_to_declare(model: ModelType) -> List[Property]:
         if model.parents:
+            parent_properties = [
+                p for bm in model.parents for p in cast(ModelType, bm).properties
+            ]
             properties_to_declare = [
                 p
-                for bm in model.parents
                 for p in model.properties
-                if p not in cast(ModelType, bm).properties
+                if not any(
+                    p.client_name == pp.client_name
+                    and p.type_annotation() == pp.type_annotation()
+                    for pp in parent_properties
+                )
             ]
-
         else:
             properties_to_declare = model.properties
         if any(p for p in properties_to_declare if p.client_name == "_"):
             raise ValueError("We do not generate anonymous properties")
-        return [
-            p
-            for p in properties_to_declare
-            if (not p.is_discriminator or p.is_polymorphic)
-        ]
+        return properties_to_declare
 
     @staticmethod
     def declare_property(prop: Property) -> List[str]:
         attribute_key = _ModelSerializer.escape_dot(prop.rest_api_name)
         args = []
-        if prop.client_name != attribute_key:
+        if prop.client_name != attribute_key or prop.is_discriminator:
             args.append(f'name="{attribute_key}"')
         if prop.readonly:
             args.append("readonly=True")
@@ -261,3 +266,13 @@ class DpgModelSerializer(_ModelSerializer):
         if comment:
             ret.append(f'"""{comment}"""')
         return ret
+
+    def initialize_properties(self, model: ModelType) -> List[str]:
+        init_args = []
+        for prop in self.get_properties_to_declare(model):
+            if prop.constant or prop.is_discriminator:
+                init_args.append(
+                    f"self.{prop.client_name} = {cast(ConstantType, prop.type).get_declaration()}   "
+                    f"# type: {prop.type_annotation()}"
+                )
+        return init_args

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -8,11 +8,12 @@ import functools
 from jinja2 import Environment
 
 from ..models import (
-    NamespaceModel,
+    CodeModel,
     OperationGroup,
     FileImport,
     RequestBuilder,
     OverloadedRequestBuilder,
+    Client,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import get_operation_serializer, RequestBuilderSerializer
@@ -21,12 +22,14 @@ from .builder_serializer import get_operation_serializer, RequestBuilderSerializ
 class OperationGroupsSerializer:
     def __init__(
         self,
-        namespace_model: NamespaceModel,
+        code_model: CodeModel,
+        clients: List[Client],
         env: Environment,
         async_mode: bool,
         operation_group: Optional[OperationGroup] = None,
     ):
-        self.namespace_model = namespace_model
+        self.clients = clients
+        self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
         self.operation_group = operation_group
@@ -36,7 +39,8 @@ class OperationGroupsSerializer:
     ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
         return [
             r
-            for r in self.namespace_model.request_builders
+            for client in self.clients
+            for r in client.request_builders
             if r.client.name == operation_group.client.name
             and r.group_name == operation_group.property_name
             and not r.is_overload
@@ -47,7 +51,7 @@ class OperationGroupsSerializer:
         operation_groups = (
             [self.operation_group]
             if self.operation_group
-            else self.namespace_model.operation_groups
+            else [og for client in self.clients for og in client.operation_groups]
         )
         imports = FileImport()
         for operation_group in operation_groups:
@@ -61,7 +65,7 @@ class OperationGroupsSerializer:
             "operation_groups_container.py.jinja2"
         )
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
@@ -70,11 +74,11 @@ class OperationGroupsSerializer:
             async_mode=self.async_mode,
             get_operation_serializer=functools.partial(
                 get_operation_serializer,
-                namespace_model=self.namespace_model,
+                code_model=self.code_model,
                 async_mode=self.async_mode,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.namespace_model,
+                self.code_model,
                 async_mode=False,
             ),
             get_request_builders=self._get_request_builders,

package/autorest/codegen/serializers/operations_init_serializer.py

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

package/autorest/codegen/serializers/patch_serializer.py

@@ -5,13 +5,13 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer
-from ..models import NamespaceModel, FileImport, ImportType, TypingSection
+from ..models import CodeModel, FileImport, ImportType, TypingSection
 
 
 class PatchSerializer:
-    def __init__(self, env: Environment, namespace_model: NamespaceModel) -> None:
+    def __init__(self, env: Environment, code_model: CodeModel) -> None:
         self.env = env
-        self.namespace_model = namespace_model
+        self.code_model = code_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(
-            namespace_model=self.namespace_model,
+            code_model=self.code_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 NamespaceModel, RequestBuilderType
+from ..models import CodeModel, RequestBuilderType
 from .builder_serializer import RequestBuilderSerializer
 
 
 class RequestBuildersSerializer:
     def __init__(
         self,
-        namespace_model: NamespaceModel,
+        code_model: CodeModel,
         env: Environment,
         request_builders: List[RequestBuilderType],
     ) -> None:
-        self.namespace_model = namespace_model
+        self.code_model = code_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(
-            namespace_model=self.namespace_model,
+            code_model=self.code_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(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.namespace_model, async_mode=False
+                self.code_model, async_mode=False
             ),
         )

package/autorest/codegen/serializers/sample_serializer.py

@@ -14,7 +14,7 @@ from autorest.codegen.models.imports import FileImport, ImportType
 from autorest.codegen.models.operation import OperationBase
 from autorest.codegen.models.operation_group import OperationGroup
 from autorest.codegen.serializers.import_serializer import FileImportSerializer
-from ..models import NamespaceModel
+from ..models import CodeModel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,7 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 class SampleSerializer:
     def __init__(
         self,
-        namespace_model: NamespaceModel,
+        code_model: CodeModel,
         env: Environment,
         operation_group: OperationGroup,
         operation: OperationBase[Any],
@@ -30,7 +30,7 @@ class SampleSerializer:
         file_name: str,
         sample_origin_name: str,
     ) -> None:
-        self.namespace_model = namespace_model
+        self.code_model = code_model
         self.env = env
         self.operation_group = operation_group
         self.operation = operation
@@ -40,10 +40,10 @@ class SampleSerializer:
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport()
-        namespace = (self.namespace_model.options["package_name"] or "").replace(
+        namespace = (self.code_model.options["package_name"] or "").replace(
             "-", "."
-        ) or self.namespace_model.namespace
-        client = self.namespace_model.clients[0]
+        ) or self.code_model.namespace
+        client = self.code_model.clients[0]
         imports.add_submodule_import(namespace, client.name, ImportType.THIRDPARTY)
         credential_type = getattr(client.credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
@@ -60,9 +60,7 @@ class SampleSerializer:
     def _client_params(self) -> Dict[str, Any]:
         # client params
         special_param = dict()
-        credential_type = getattr(
-            self.namespace_model.clients[0].credential, "type", None
-        )
+        credential_type = getattr(self.code_model.clients[0].credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
             special_param.update({"credential": "DefaultAzureCredential()"})
         elif isinstance(credential_type, AzureKeyCredentialType):
@@ -72,7 +70,7 @@ class SampleSerializer:
 
         params_positional = [
             p
-            for p in self.namespace_model.clients[0].parameters.positional
+            for p in self.code_model.clients[0].parameters.positional
             if not (p.optional or p.client_default_value)
         ]
         cls = lambda x: f'"{x}"'
@@ -97,7 +95,7 @@ class SampleSerializer:
             if not p.client_default_value
         ]
         cls = lambda x: f'"{x}"' if isinstance(x, str) else str(x)
-        failure_info = '"fail to find required param named {%s} in example file {%s}"'
+        failure_info = "fail to find required param named {} in example file {}"
         operation_params = {}
         for param in params_positional:
             name = param.rest_api_name
@@ -134,7 +132,7 @@ class SampleSerializer:
 
     def serialize(self) -> str:
         return self.env.get_template("sample.py.jinja2").render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             file_name=self.file_name,
             operation_result=self._operation_result(),
             operation_params=self._operation_params(),

package/autorest/codegen/templates/client_container.py.jinja2

@@ -2,11 +2,11 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {# actual template starts here #}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% for client in namespace_model.clients %}
+{% for client in clients %}
     {% set serializer = get_serializer(client) %}
 {% include "client.py.jinja2" %}
 {% endfor %}