@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/serializers/import_serializer.py

@@ -5,49 +5,69 @@
 # --------------------------------------------------------------------------
 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}")
+        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(
+                set(
+                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name  # type: ignore
+                    for i in imports
+                )
+            )
+        )
         buffer.append(f"from {imports[0].module_name} import {import_str}")
     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 +82,75 @@ 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  # pylint: disable=ungrouped-imports"
+            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 +160,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()

package/autorest/codegen/serializers/metadata_serializer.py

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

package/autorest/codegen/serializers/model_base_serializer.py

@@ -6,25 +6,31 @@
 from abc import abstractmethod
 from typing import cast, List
 from jinja2 import Environment
-from ..models import ObjectSchema, CodeModel, Property
+from ..models import ModelType, CodeModel, Property
 from ..models.imports import FileImport, ImportType
 from .import_serializer import FileImportSerializer
 
+
 def _documentation_string(
     prop: Property, description_keyword: str, docstring_type_keyword: str
 ) -> List[str]:
     retval: List[str] = []
-    sphinx_prefix = f":{description_keyword} {prop.name}:"
+    sphinx_prefix = f":{description_keyword} {prop.client_name}:"
     retval.append(
-        f"{sphinx_prefix} {prop.description}" if prop.description
+        f"{sphinx_prefix} {prop.description(is_operation_file=False)}"
+        if prop.description(is_operation_file=False)
         else sphinx_prefix
     )
-    retval.append(f":{docstring_type_keyword} {prop.name}: {prop.schema.docstring_type}")
+    retval.append(
+        f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}"
+    )
     return retval
 
 
 class ModelBaseSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, is_python3_file: bool) -> None:
+    def __init__(
+        self, code_model: CodeModel, env: Environment, is_python3_file: bool
+    ) -> None:
         self.code_model = code_model
         self.env = env
         self.is_python3_file = is_python3_file
@@ -34,34 +40,44 @@ class ModelBaseSerializer:
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
             code_model=self.code_model,
-            imports=FileImportSerializer(self.imports(), is_python3_file=self.is_python3_file),
+            imports=FileImportSerializer(
+                self.imports(), is_python3_file=self.is_python3_file
+            ),
             str=str,
-            init_line=self.init_line,
-            init_args=self.init_args,
-            input_documentation_string=ModelBaseSerializer.input_documentation_string,
-            variable_documentation_string=ModelBaseSerializer.variable_documentation_string,
+            serializer=self,
         )
 
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.add_import("msrest.serialization", ImportType.AZURECORE)
-        for model in self.code_model.sorted_schemas:
-            file_import.merge(model.imports())
+        for model in self.code_model.model_types:
+            file_import.merge(model.imports(is_operation_file=False))
         return file_import
 
     @staticmethod
-    def get_properties_to_initialize(model: ObjectSchema) -> List[Property]:
-        if model.base_models:
-            properties_to_initialize = list({
-                p.name: p
-                for bm in model.base_models
-                for p in model.properties
-                if p not in cast(ObjectSchema, bm).properties or p.is_discriminator or p.constant
-            }.values())
+    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+        if model.parents:
+            properties_to_initialize = list(
+                {
+                    p.client_name: p
+                    for bm in model.parents
+                    for p in model.properties
+                    if p not in cast(ModelType, bm).properties
+                    or p.is_discriminator
+                    or p.constant
+                }.values()
+            )
         else:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
+    @staticmethod
+    def declare_model(model: ModelType) -> str:
+        basename = "msrest.serialization.Model"
+        if model.parents:
+            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+        return f"class {model.name}({basename}):{model.pylint_disable}"
+
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
         # building the param line of the property doc
@@ -71,35 +87,55 @@ class ModelBaseSerializer:
     def variable_documentation_string(prop: Property) -> List[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    def init_args(self, model: ObjectSchema) -> List[str]:
+    @abstractmethod
+    def super_call_template(self, model: ModelType) -> str:
+        ...
+
+    def super_call(self, model: ModelType):
+        return self.super_call_template(model).format(
+            self.properties_to_pass_to_super(model)
+        )
+
+    def initialize_properties(self, model: ModelType) -> List[str]:
         init_args = []
-        properties_to_pass_to_super = self.properties_to_pass_to_super(model)
-        init_args.append(f"super({model.name}, self).__init__({properties_to_pass_to_super})")
         for prop in ModelBaseSerializer.get_properties_to_initialize(model):
             if prop.is_discriminator:
-                discriminator_value = f"'{model.discriminator_value}'" if model.discriminator_value else None
+                discriminator_value = (
+                    f"'{model.discriminator_value}'"
+                    if model.discriminator_value
+                    else None
+                )
                 if not discriminator_value:
                     typing = "Optional[str]"
                 else:
                     typing = "str"
-                init_args.append(f"self.{prop.name} = {discriminator_value}  # type: {typing}")
+                init_args.append(
+                    f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
+                )
             elif prop.readonly:
-                init_args.append(f"self.{prop.name} = None")
+                init_args.append(f"self.{prop.client_name} = None")
             elif not prop.constant:
                 init_args.append(self.initialize_standard_arg(prop))
         return init_args
 
     def initialize_standard_property(self, prop: Property):
-        if prop.required and not prop.default_value:
+        if not (prop.optional or prop.client_default_value is not None):
             return self.required_property_no_default_init(prop)
         return self.optional_property_init(prop)
 
+    @staticmethod
+    def discriminator_docstring(model: ModelType) -> str:
+        return (
+            "You probably want to use the sub-classes and not this class directly. "
+            f"Known sub-classes are: {', '.join(model.discriminated_subtypes.values())}"
+        )
+
     @abstractmethod
-    def init_line(self, model: ObjectSchema) -> List[str]:
+    def init_line(self, model: ModelType) -> List[str]:
         ...
 
     @abstractmethod
-    def properties_to_pass_to_super(self, model: ObjectSchema) -> str:
+    def properties_to_pass_to_super(self, model: ModelType) -> str:
         ...
 
     @abstractmethod

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -6,28 +6,27 @@
 from typing import List
 from jinja2 import Environment
 from .model_base_serializer import ModelBaseSerializer
-from ..models import ObjectSchema, CodeModel, Property
+from ..models import ModelType, CodeModel, Property
 
 
 class ModelGenericSerializer(ModelBaseSerializer):
-
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        super(ModelGenericSerializer, self).__init__(
-            code_model=code_model, env=env, is_python3_file=False
-        )
+        super().__init__(code_model=code_model, env=env, is_python3_file=False)
 
-    def init_line(self, model: ObjectSchema) -> List[str]:
+    def init_line(self, model: ModelType) -> List[str]:
         return []
 
-    def properties_to_pass_to_super(self, model: ObjectSchema) -> str:
+    def properties_to_pass_to_super(self, model: ModelType) -> str:
         return "**kwargs"
 
     def required_property_no_default_init(self, prop: Property) -> str:
-        return f"self.{prop.name} = kwargs['{prop.name}']"
+        return f"self.{prop.client_name} = kwargs['{prop.client_name}']"
 
     def optional_property_init(self, prop: Property) -> str:
-        default = prop.default_value_declaration
-        return f"self.{prop.name} = kwargs.get('{prop.name}', {default})"
+        return f"self.{prop.client_name} = kwargs.get('{prop.client_name}', {prop.client_default_value_declaration})"
 
     def initialize_standard_arg(self, prop: Property) -> str:
         return self.initialize_standard_property(prop)
+
+    def super_call_template(self, model: ModelType) -> str:
+        return "super(" + model.name + ", self).__init__({})"

package/autorest/codegen/serializers/model_init_serializer.py

@@ -13,9 +13,11 @@ class ModelInitSerializer:
         self.env = env
 
     def serialize(self) -> str:
-        schemas = [s.name for s in self.code_model.sorted_schemas]
+        schemas = [s.name for s in self.code_model.public_model_types]
         schemas.sort()
-        enums = [e.name for e in self.code_model.enums.values()] if self.code_model.enums else None
+        enums = (
+            [e.name for e in self.code_model.enums] if self.code_model.enums else None
+        )
 
         if enums:
             enums.sort()