@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/serializers/metadata_serializer.py

@@ -24,13 +24,22 @@ from ..models import (
 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]
+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]]]]]],
+    ]
 ):
     if not imports:
         return None
@@ -55,14 +64,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 +93,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:
@@ -97,26 +112,43 @@ class MetadataSerializer:
         return global_parameters
 
     def _service_client_imports(
-        self, global_parameters: ParameterList, mixin_operation_group: Optional[OperationGroup], async_mode: bool
+        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
+            "azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE
         )
         file_import.add_submodule_import(
-            "._configuration", f"{self.code_model.class_name}Configuration", ImportType.LOCAL
+            "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)
+        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
+                "._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))
+        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:
@@ -134,7 +166,9 @@ class MetadataSerializer:
             ),
             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()
@@ -143,9 +177,9 @@ class MetadataSerializer:
         # 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)
+        if self.code_model.options["credential"] and isinstance(
+            self.code_model.credential_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
@@ -163,8 +197,13 @@ class MetadataSerializer:
 
         # 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")
+        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"
+            )
         return template.render(
             chosen_version=chosen_version,
             total_api_version_list=total_api_version_list,
@@ -181,15 +220,25 @@ class MetadataSerializer:
             sync_client_imports=sync_client_imports,
             async_client_imports=async_client_imports,
             sync_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, self.code_model.global_parameters, async_mode=False).to_dict()
+                config_imports(
+                    self.code_model, self.code_model.global_parameters, async_mode=False
+                ).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, async_global_parameters, async_mode=True).to_dict()
+                config_imports(
+                    self.code_model, async_global_parameters, 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,
             ),
         )

package/autorest/codegen/serializers/model_base_serializer.py

@@ -10,21 +10,25 @@ from ..models import ObjectSchema, 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}:"
     retval.append(
-        f"{sphinx_prefix} {prop.description}" if prop.description
-        else sphinx_prefix
+        f"{sphinx_prefix} {prop.description}" if prop.description else sphinx_prefix
+    )
+    retval.append(
+        f":{docstring_type_keyword} {prop.name}: {prop.schema.docstring_type}"
     )
-    retval.append(f":{docstring_type_keyword} {prop.name}: {prop.schema.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,12 +38,15 @@ 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,
+            declare_model=ModelBaseSerializer.declare_model,
         )
 
     def imports(self) -> FileImport:
@@ -52,16 +59,29 @@ class ModelBaseSerializer:
     @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())
+            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()
+            )
         else:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
+    @staticmethod
+    def declare_model(model: ObjectSchema) -> str:
+        basename = "msrest.serialization.Model"
+        if model.base_models:
+            basename = ", ".join(
+                [cast(ObjectSchema, m).name for m in model.base_models]
+            )
+        return f"class {model.name}({basename}):"
+
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
         # building the param line of the property doc
@@ -74,15 +94,23 @@ class ModelBaseSerializer:
     def init_args(self, model: ObjectSchema) -> 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})")
+        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.name} = {discriminator_value}  # type: {typing}"
+                )
             elif prop.readonly:
                 init_args.append(f"self.{prop.name} = None")
             elif not prop.constant:

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -10,11 +10,8 @@ from ..models import ObjectSchema, 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]:
         return []

package/autorest/codegen/serializers/model_init_serializer.py

@@ -15,7 +15,11 @@ class ModelInitSerializer:
     def serialize(self) -> str:
         schemas = [s.name for s in self.code_model.sorted_schemas]
         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.values()]
+            if self.code_model.enums
+            else None
+        )
 
         if enums:
             enums.sort()

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -11,16 +11,15 @@ from ..models.imports import FileImport
 
 
 class ModelPython3Serializer(ModelBaseSerializer):
-
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        super(ModelPython3Serializer, self).__init__(
-            code_model=code_model, env=env, is_python3_file=True
-        )
+        super().__init__(code_model=code_model, env=env, is_python3_file=True)
 
     def init_line(self, model: ObjectSchema) -> List[str]:
         init_properties_declaration = []
         init_line_parameters = [
-            p for p in model.properties if not p.readonly and not p.is_discriminator and not p.constant
+            p
+            for p in model.properties
+            if not p.readonly and not p.is_discriminator and not p.constant
         ]
         init_line_parameters.sort(key=lambda x: x.required, reverse=True)
         if init_line_parameters:
@@ -46,11 +45,11 @@ class ModelPython3Serializer(ModelBaseSerializer):
         return ", ".join(properties_to_pass_to_super)
 
     def required_property_no_default_init(self, prop: Property) -> str:
-        return f"{prop.name}: {prop.type_annotation}"
+        return f"{prop.name}: {prop.type_annotation()}"
 
     def optional_property_init(self, prop: Property) -> str:
         default = prop.default_value_declaration
-        return f"{prop.name}: {prop.type_annotation} = {default}"
+        return f"{prop.name}: {prop.type_annotation()} = {default}"
 
     def initialize_standard_arg(self, prop: Property) -> str:
         return f"self.{prop.name} = {prop.name}"
@@ -58,7 +57,9 @@ class ModelPython3Serializer(ModelBaseSerializer):
     def imports(self) -> FileImport:
         file_import = super(ModelPython3Serializer, self).imports()
         for model in self.code_model.sorted_schemas:
-            init_line_parameters = [p for p in model.properties if not p.readonly and not p.is_discriminator]
+            init_line_parameters = [
+                p for p in model.properties if not p.readonly and not p.is_discriminator
+            ]
             for param in init_line_parameters:
                 file_import.merge(param.model_file_imports())
 

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -12,11 +12,12 @@ from ..models import (
     OperationGroup,
     FileImport,
     LROOperation,
-    PagingOperation
+    PagingOperation,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import get_operation_serializer, get_request_builder_serializer
 
+
 class OperationGroupsSerializer:
     def __init__(
         self,
@@ -38,21 +39,31 @@ class OperationGroupsSerializer:
 
         def _is_paging(operation):
             return isinstance(operation, PagingOperation)
-        operation_groups = [self.operation_group] if self.operation_group else self.code_model.operation_groups
+
+        operation_groups = (
+            [self.operation_group]
+            if self.operation_group
+            else self.code_model.operation_groups
+        )
         imports = FileImport()
         for operation_group in operation_groups:
-            imports.merge(operation_group.imports(
-                async_mode=self.async_mode,
-            ))
+            imports.merge(
+                operation_group.imports(
+                    async_mode=self.async_mode,
+                    is_python3_file=self.is_python3_file,
+                )
+            )
 
-        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
+        template = self.env.get_or_select_template(
+            "operation_groups_container.py.jinja2"
+        )
         return template.render(
             code_model=self.code_model,
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
                 is_python3_file=self.is_python3_file,
-                async_mode=self.async_mode
+                async_mode=self.async_mode,
             ),
             async_mode=self.async_mode,
             is_python3_file=self.is_python3_file,
@@ -65,6 +76,7 @@ class OperationGroupsSerializer:
                 is_python3_file=self.is_python3_file,
             ),
             request_builder_serializer=get_request_builder_serializer(
-                self.code_model, self.is_python3_file,
+                self.code_model,
+                self.is_python3_file,
             ),
         )

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -11,15 +11,22 @@ from ..models import CodeModel
 
 
 class OperationsInitSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool) -> None:
+    def __init__(
+        self, code_model: CodeModel, env: Environment, async_mode: bool
+    ) -> None:
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
 
     def _operation_group_imports_helper(self, filename_suffix: str = "") -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            prefix = "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
+            prefix = (
+                "_operations"
+                if self.code_model.options["combine_operation_files"]
+                else operation_group.filename
+            )
             return prefix + filename_suffix
+
         return [
             f"from .{_get_filename(og)} import {og.class_name}"
             for og in self.code_model.operation_groups
@@ -30,20 +37,25 @@ class OperationsInitSerializer:
         py3_only = self.code_model.options["python3_only"]
         if typed_py3_files and not py3_only and not self.async_mode:
             retval: List[str] = ["try:"]
-            retval.extend([
-                f"    {line}"
-                for line in self._operation_group_imports_helper(filename_suffix="_py3")
-            ])
+            retval.extend(
+                [
+                    f"    {line}"
+                    for line in self._operation_group_imports_helper(
+                        filename_suffix="_py3"
+                    )
+                ]
+            )
             retval.append("except (SyntaxError, ImportError):")
-            retval.extend([
-                f"    {line}"
-                for line in self._operation_group_imports_helper()
-            ])
+            retval.extend(
+                [f"    {line}" for line in self._operation_group_imports_helper()]
+            )
             return retval
         return self._operation_group_imports_helper()
 
     def serialize(self) -> str:
-        operation_group_init_template = self.env.get_template("operations_folder_init.py.jinja2")
+        operation_group_init_template = self.env.get_template(
+            "operations_folder_init.py.jinja2"
+        )
 
         return operation_group_init_template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,12 +4,24 @@
 # license information.
 # --------------------------------------------------------------------------
 from jinja2 import Environment
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, FileImport, ImportType, TypingSection
 
 
 class PatchSerializer:
-    def __init__(self, env: Environment) -> None:
+    def __init__(self, env: Environment, code_model: CodeModel) -> None:
         self.env = env
+        self.code_model = code_model
 
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        return template.render()
+        imports = FileImport()
+        imports.add_submodule_import(
+            "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        is_python3_file = self.code_model.options["python3_only"]
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(imports, is_python3_file=is_python3_file),
+            is_python3_file=is_python3_file,
+        )

package/autorest/codegen/serializers/{rest_serializer.py → request_builders_serializer.py}

@@ -6,7 +6,7 @@
 from typing import List
 from jinja2 import Environment
 
-from ..models import RequestBuilder
+from ..models import RequestBuilder, FileImport
 from .import_serializer import FileImportSerializer
 from ..models import CodeModel
 from .builder_serializer import (
@@ -15,43 +15,60 @@ from .builder_serializer import (
 )
 
 
-class RestSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, request_builders: List[RequestBuilder]) -> None:
+class RequestBuildersSerializer:
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        request_builders: List[RequestBuilder],
+    ) -> None:
         self.code_model = code_model
         self.env = env
         self.request_builders = request_builders
         self.builder_group_name = request_builders[0].builder_group_name
 
+    @property
+    def imports(self) -> FileImport:
+        file_import = FileImport()
+        for request_builder in self.request_builders:
+            if request_builder.builder_group_name == self.builder_group_name:
+                file_import.merge(request_builder.imports())
+        return file_import
+
     def serialize_init(self) -> str:
         template = self.env.get_template("rest_init.py.jinja2")
-        return template.render(code_model=self.code_model, request_builders=self.request_builders)
+        return template.render(
+            code_model=self.code_model, request_builders=self.request_builders
+        )
 
 
-class RestPython3Serializer(RestSerializer):
+class RequestBuildersPython3Serializer(RequestBuildersSerializer):
     def serialize_request_builders(self) -> str:
         template = self.env.get_template("request_builders.py.jinja2")
 
         return template.render(
             code_model=self.code_model,
             request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(
-                self.builder_group_name
-            ), is_python3_file=True),
+            imports=FileImportSerializer(
+                self.imports,
+                is_python3_file=True,
+            ),
             is_python3_file=True,
             request_builder_serializer=RequestBuilderPython3Serializer(self.code_model),
         )
 
 
-class RestGenericSerializer(RestSerializer):
+class RequestBuildersGenericSerializer(RequestBuildersSerializer):
     def serialize_request_builders(self) -> str:
         template = self.env.get_template("request_builders.py.jinja2")
 
         return template.render(
             code_model=self.code_model,
             request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(
-                self.builder_group_name
-            ), is_python3_file=False),
+            imports=FileImportSerializer(
+                self.imports,
+                is_python3_file=False,
+            ),
             is_python3_file=False,
             request_builder_serializer=RequestBuilderGenericSerializer(self.code_model),
         )