@autorest/python 5.15.0 → 5.16.0

package/autorest/multiapi/models/client.py

@@ -9,54 +9,64 @@ from typing import Any, Dict, List
 from pathlib import Path
 from .imports import FileImport
 
+
 def _extract_version(metadata_json: Dict[str, Any], version_path: Path) -> str:
-    version = metadata_json['chosen_version']
-    total_api_version_list = metadata_json['total_api_version_list']
+    version = metadata_json["chosen_version"]
+    total_api_version_list = metadata_json["total_api_version_list"]
     if not version:
         if total_api_version_list:
             sys.exit(
                 f"Unable to match {total_api_version_list} to label {version_path.stem}"
             )
         else:
-            sys.exit(
-                f"Unable to extract api version of {version_path.stem}"
-            )
+            sys.exit(f"Unable to extract api version of {version_path.stem}")
     return version
 
+
 class Client:
     def __init__(
         self,
         azure_arm: bool,
         default_version_metadata: Dict[str, Any],
-        version_path_to_metadata: Dict[Path, Dict[str, Any]]
+        version_path_to_metadata: Dict[Path, Dict[str, Any]],
     ):
         self.name = default_version_metadata["client"]["name"]
         self.pipeline_client = "ARMPipelineClient" if azure_arm else "PipelineClient"
         self.filename = default_version_metadata["client"]["filename"]
         self.host_value = default_version_metadata["client"]["host_value"]
         self.description = default_version_metadata["client"]["description"]
-        self.client_side_validation = default_version_metadata["client"]["client_side_validation"]
+        self.client_side_validation = default_version_metadata["client"][
+            "client_side_validation"
+        ]
         self.default_version_metadata = default_version_metadata
         self.version_path_to_metadata = version_path_to_metadata
 
     def imports(self, async_mode: bool) -> FileImport:
         imports_to_load = "async_imports" if async_mode else "sync_imports"
-        return FileImport(json.loads(self.default_version_metadata['client'][imports_to_load]))
+        return FileImport(
+            json.loads(self.default_version_metadata["client"][imports_to_load])
+        )
 
     @property
     def parameterized_host_template_to_api_version(self) -> Dict[str, List[str]]:
         parameterized_host_template_to_api_version: Dict[str, List[str]] = {}
         for version_path, metadata_json in self.version_path_to_metadata.items():
-            parameterized_host_template = metadata_json["client"]["parameterized_host_template"]
+            parameterized_host_template = metadata_json["client"][
+                "parameterized_host_template"
+            ]
             version = _extract_version(metadata_json, version_path)
-            parameterized_host_template_to_api_version.setdefault(parameterized_host_template, []).append(version)
+            parameterized_host_template_to_api_version.setdefault(
+                parameterized_host_template, []
+            ).append(version)
         return parameterized_host_template_to_api_version
 
     @property
     def has_lro_operations(self) -> bool:
         has_lro_operations = False
         for _, metadata_json in self.version_path_to_metadata.items():
-            current_client_has_lro_operations = metadata_json["client"]["has_lro_operations"]
+            current_client_has_lro_operations = metadata_json["client"][
+                "has_lro_operations"
+            ]
             if current_client_has_lro_operations:
                 has_lro_operations = True
         return has_lro_operations

package/autorest/multiapi/models/code_model.py

@@ -13,6 +13,7 @@ from .operation_mixin_group import OperationMixinGroup
 from .global_parameters import GlobalParameters
 from ..utils import _get_default_api_version_from_list
 
+
 class CodeModel:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
@@ -23,7 +24,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
         default_version_metadata: Dict[str, Any],
         mod_to_api_version: Dict[str, str],
         version_path_to_metadata: Dict[Path, Dict[str, Any]],
-        user_specified_default_api: Optional[str] = None
+        user_specified_default_api: Optional[str] = None,
     ):
         self.module_name = module_name
         self.package_name = package_name
@@ -33,9 +34,13 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
         self.azure_arm = default_version_metadata["client"]["azure_arm"]
         self.default_version_metadata = default_version_metadata
         self.version_path_to_metadata = version_path_to_metadata
-        self.service_client = Client(self.azure_arm, default_version_metadata, version_path_to_metadata)
+        self.service_client = Client(
+            self.azure_arm, default_version_metadata, version_path_to_metadata
+        )
         self.config = Config(default_version_metadata)
-        self.operation_mixin_group = OperationMixinGroup(version_path_to_metadata, default_api_version)
+        self.operation_mixin_group = OperationMixinGroup(
+            version_path_to_metadata, default_api_version
+        )
         self.global_parameters = GlobalParameters(
             default_version_metadata["global_parameters"]
         )
@@ -45,17 +50,24 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
     def operation_groups(self) -> List[OperationGroup]:
         operation_groups: List[OperationGroup] = []
         for version_path, metadata_json in self.version_path_to_metadata.items():
-            if not metadata_json.get('operation_groups'):
+            if not metadata_json.get("operation_groups"):
                 continue
-            operation_groups_metadata = metadata_json['operation_groups']
-            for operation_group_name, operation_group_class_name in operation_groups_metadata.items():
+            operation_groups_metadata = metadata_json["operation_groups"]
+            for (
+                operation_group_name,
+                operation_group_class_name,
+            ) in operation_groups_metadata.items():
                 try:
-                    operation_group = [og for og in operation_groups if og.name == operation_group_name][0]
+                    operation_group = [
+                        og for og in operation_groups if og.name == operation_group_name
+                    ][0]
                 except IndexError:
                     operation_group = OperationGroup(operation_group_name)
                     operation_groups.append(operation_group)
                 operation_group.append_available_api(version_path.name)
-                operation_group.append_api_class_name_pair(version_path.name, operation_group_class_name)
+                operation_group.append_api_class_name_pair(
+                    version_path.name, operation_group_class_name
+                )
         operation_groups.sort(key=lambda x: x.name)
         return operation_groups
 
@@ -110,7 +122,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
                 self.mod_to_api_version,
                 api_versions_list,
                 self.preview_mode,
-                self.user_specified_default_api
+                self.user_specified_default_api,
             )
             if local_default_api_version == self.default_api_version:
                 continue
@@ -129,5 +141,6 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
     @property
     def default_models(self):
         return sorted(
-            {self.default_api_version} | {versions for _, versions in self.last_rt_list.items()}
+            {self.default_api_version}
+            | {versions for _, versions in self.last_rt_list.items()}
         )

package/autorest/multiapi/models/config.py

@@ -7,6 +7,7 @@ import json
 from typing import Any, Dict
 from .imports import FileImport
 
+
 class Config:
     def __init__(self, default_version_metadata: Dict[str, Any]):
         self.credential = default_version_metadata["config"]["credential"]
@@ -15,7 +16,9 @@ class Config:
 
     def imports(self, async_mode: bool) -> FileImport:
         imports_to_load = "async_imports" if async_mode else "sync_imports"
-        return FileImport(json.loads(self.default_version_metadata['config'][imports_to_load]))
+        return FileImport(
+            json.loads(self.default_version_metadata["config"][imports_to_load])
+        )
 
     def credential_call(self, async_mode: bool) -> str:
         if async_mode:

package/autorest/multiapi/models/constant_global_parameter.py

@@ -4,6 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 
+
 class ConstantGlobalParameter:
     def __init__(self, name: str, value: str):
         self.name = name

package/autorest/multiapi/models/global_parameter.py

@@ -5,12 +5,13 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict
 
+
 class GlobalParameter:
     def __init__(
         self,
         name: str,
         global_parameter_metadata_sync: Dict[str, Any],
-        global_parameter_metadata_async: Dict[str, Any]
+        global_parameter_metadata_async: Dict[str, Any],
     ):
         self.name = name
         self.global_parameter_metadata_sync = global_parameter_metadata_sync

package/autorest/multiapi/models/global_parameters.py

@@ -7,17 +7,19 @@ from typing import Any, Dict, List
 from .global_parameter import GlobalParameter
 from .constant_global_parameter import ConstantGlobalParameter
 
+
 def _convert_global_parameters(sync_metadata, async_metadata):
     global_parameters = [
         GlobalParameter(
             name=parameter_name,
             global_parameter_metadata_sync=gp_sync,
-            global_parameter_metadata_async=async_metadata[parameter_name]
+            global_parameter_metadata_async=async_metadata[parameter_name],
         )
         for parameter_name, gp_sync in sync_metadata.items()
     ]
     return global_parameters
 
+
 class GlobalParameters:
     def __init__(
         self,
@@ -31,12 +33,15 @@ class GlobalParameters:
         """Return global params specific to multiapi service client + config
         api_version, endpoint (re-adding it in specific are), and profile
         """
-        service_client_params_sync = self.global_parameters_metadata["service_client_specific"]["sync"]
-        service_client_params_async = self.global_parameters_metadata["service_client_specific"]["async"]
+        service_client_params_sync = self.global_parameters_metadata[
+            "service_client_specific"
+        ]["sync"]
+        service_client_params_async = self.global_parameters_metadata[
+            "service_client_specific"
+        ]["async"]
 
         return _convert_global_parameters(
-            service_client_params_sync,
-            service_client_params_async
+            service_client_params_sync, service_client_params_async
         )
 
     @property
@@ -45,13 +50,14 @@ class GlobalParameters:
         global_parameters_metadata_async = self.global_parameters_metadata["async"]
 
         return _convert_global_parameters(
-            global_parameters_metadata_sync,
-            global_parameters_metadata_async
+            global_parameters_metadata_sync, global_parameters_metadata_async
         )
 
     @property
     def constant_parameters(self) -> List[ConstantGlobalParameter]:
         return [
             ConstantGlobalParameter(constant_name, constant_value)
-            for constant_name, constant_value in self.global_parameters_metadata["constant"].items()
+            for constant_name, constant_value in self.global_parameters_metadata[
+                "constant"
+            ].items()
         ]

package/autorest/multiapi/models/imports.py

@@ -13,6 +13,7 @@ class ImportType(str, Enum):
     AZURECORE = "azurecore"
     LOCAL = "local"
 
+
 class TypingSection(str, Enum):
     REGULAR = "regular"  # this import is always a typing import
     CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
@@ -23,8 +24,9 @@ class FileImport:
     def __init__(
         self,
         imports: Dict[
-            TypingSection, Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = None
+            TypingSection,
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        ] = None,
     ) -> None:
         # Basic implementation
         # First level dict: TypingSection
@@ -32,51 +34,54 @@ class FileImport:
         # Third level dict: the package name.
         # Fourth level set: None if this import is a "import", the name to import if it's a "from"
         self._imports: Dict[
-            TypingSection, Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = imports or dict()
+            TypingSection,
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        ] = (
+            imports or dict()
+        )
 
     def _add_import(
         self,
         from_section: str,
         import_type: ImportType,
         name_import: Optional[Union[str, Tuple[str, str]]] = None,
-        typing_section: TypingSection = TypingSection.REGULAR
+        typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
         name_input: Optional[Union[str, Tuple[str, str]]] = None
         if isinstance(name_import, list):
             name_input = tuple(name_import)
         else:
             name_input = name_import
-        self._imports.setdefault(
-            typing_section, dict()
-        ).setdefault(
+        self._imports.setdefault(typing_section, dict()).setdefault(
             import_type, dict()
-        ).setdefault(
-            from_section, set()
-        ).add(name_input)
+        ).setdefault(from_section, set()).add(name_input)
 
     def add_submodule_import(
         self,
         from_section: str,
         name_import: str,
         import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR
+        typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
-        """Add an import to this import block.
-        """
+        """Add an import to this import block."""
         self._add_import(from_section, import_type, name_import, typing_section)
 
     def add_import(
         self,
         name_import: str,
         import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR
+        typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
         self._add_import(name_import, import_type, None, typing_section)
 
     @property
-    def imports(self) -> Dict[TypingSection, Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]]:
+    def imports(
+        self,
+    ) -> Dict[
+        TypingSection,
+        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+    ]:
         return self._imports
 
     def merge(self, file_import: "FileImport") -> None:
@@ -85,4 +90,6 @@ class FileImport:
             for import_type, package_list in import_type_dict.items():
                 for package_name, module_list in package_list.items():
                     for module_name in module_list:
-                        self._add_import(package_name, import_type, module_name, typing_section)
+                        self._add_import(
+                            package_name, import_type, module_name, typing_section
+                        )

package/autorest/multiapi/models/mixin_operation.py

@@ -6,15 +6,19 @@
 from typing import Any, Dict, List, TypeVar
 from ..utils import _sync_or_async
 
-T = TypeVar('T')
+T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+
 class MixinOperation:
     def __init__(self, name: str, mixin_operation_metadata: Dict[str, Any]):
         self.name = name
         self.mixin_operation_metadata = mixin_operation_metadata
         self._available_apis: OrderedSet[str] = {}
 
+    def call(self, async_mode: bool) -> str:
+        return self.mixin_operation_metadata[_sync_or_async(async_mode)]["call"]
+
     def signature(self, async_mode: bool) -> str:
         return self.mixin_operation_metadata[_sync_or_async(async_mode)]["signature"]
 
@@ -26,10 +30,6 @@ class MixinOperation:
             return False
         return self.mixin_operation_metadata["async"]["coroutine"]
 
-    @property
-    def call(self) -> str:
-        return self.mixin_operation_metadata["call"]
-
     @property
     def available_apis(self) -> List[str]:
         return list(self._available_apis.keys())

package/autorest/multiapi/models/operation_group.py

@@ -5,9 +5,10 @@
 # --------------------------------------------------------------------------
 from typing import Dict, List, TypeVar
 
-T = TypeVar('T')
+T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+
 class OperationGroup:
     def __init__(self, name: str):
         self.name = name

package/autorest/multiapi/models/operation_mixin_group.py

@@ -9,11 +9,12 @@ from pathlib import Path
 from .imports import FileImport
 from .mixin_operation import MixinOperation
 
+
 class OperationMixinGroup:
     def __init__(
         self,
         version_path_to_metadata: Dict[Path, Dict[str, Any]],
-        default_api_version: str
+        default_api_version: str,
     ):
         self.default_api_version = default_api_version
         self.version_path_to_metadata = version_path_to_metadata
@@ -22,9 +23,9 @@ class OperationMixinGroup:
         imports = FileImport()
         imports_to_load = "async_imports" if async_mode else "sync_imports"
         for metadata_json in self.version_path_to_metadata.values():
-            if not metadata_json.get('operation_mixins'):
+            if not metadata_json.get("operation_mixins"):
                 continue
-            mixin_imports = metadata_json['operation_mixins'][imports_to_load]
+            mixin_imports = metadata_json["operation_mixins"][imports_to_load]
             if mixin_imports != "None":
                 current_version_imports = FileImport(json.loads(mixin_imports))
                 imports.merge(current_version_imports)
@@ -34,20 +35,24 @@ class OperationMixinGroup:
         self, mixin_operations: List[MixinOperation]
     ) -> List[MixinOperation]:
         default_api_version_path = [
-            version_path for version_path in self.version_path_to_metadata.keys()
+            version_path
+            for version_path in self.version_path_to_metadata.keys()
             if version_path.name == self.default_api_version
         ][0]
-        default_version_metadata = self.version_path_to_metadata[default_api_version_path]
+        default_version_metadata = self.version_path_to_metadata[
+            default_api_version_path
+        ]
         if not default_version_metadata.get("operation_mixins"):
             return mixin_operations
-        for name, metadata in default_version_metadata["operation_mixins"]["operations"].items():
+        for name, metadata in default_version_metadata["operation_mixins"][
+            "operations"
+        ].items():
             if name.startswith("_"):
                 continue
             mixin_operation = [mo for mo in mixin_operations if mo.name == name][0]
             mixin_operation.mixin_operation_metadata = metadata
         return mixin_operations
 
-
     @property
     def mixin_operations(self) -> List[MixinOperation]:
         mixin_operations: List[MixinOperation] = []
@@ -55,14 +60,20 @@ class OperationMixinGroup:
             if not metadata_json.get("operation_mixins"):
                 continue
             mixin_operations_metadata = metadata_json["operation_mixins"]["operations"]
-            for mixin_operation_name, mixin_operation_metadata in mixin_operations_metadata.items():
+            for (
+                mixin_operation_name,
+                mixin_operation_metadata,
+            ) in mixin_operations_metadata.items():
                 if mixin_operation_name.startswith("_"):
                     continue
                 try:
-                    mixin_operation = [mo for mo in mixin_operations if mo.name == mixin_operation_name][0]
+                    mixin_operation = [
+                        mo for mo in mixin_operations if mo.name == mixin_operation_name
+                    ][0]
                 except IndexError:
                     mixin_operation = MixinOperation(
-                        name=mixin_operation_name, mixin_operation_metadata=mixin_operation_metadata
+                        name=mixin_operation_name,
+                        mixin_operation_metadata=mixin_operation_metadata,
                     )
                     mixin_operations.append(mixin_operation)
                 mixin_operation.append_available_api(version_path.name)

package/autorest/multiapi/serializers/__init__.py

@@ -21,9 +21,10 @@ _FILE_TO_TEMPLATE = {
     "service_client": "multiapi_service_client.py.jinja2",
     "config": "multiapi_config.py.jinja2",
     "models": "multiapi_models.py.jinja2",
-    "operations_mixin": "multiapi_operations_mixin.py.jinja2"
+    "operations_mixin": "multiapi_operations_mixin.py.jinja2",
 }
 
+
 def _get_file_path(filename: str, async_mode: bool) -> Path:
     filename += ".py"
     if async_mode:
@@ -43,44 +44,45 @@ class MultiAPISerializer(object):
             lstrip_blocks=True,
         )
 
-
     def _serialize_helper(self, code_model: CodeModel, async_mode: bool) -> None:
         def _render_template(file: str, **kwargs: Any) -> str:
             template = self.env.get_template(_FILE_TO_TEMPLATE[file])
-            return template.render(code_model=code_model, async_mode=async_mode, **kwargs)
+            return template.render(
+                code_model=code_model, async_mode=async_mode, **kwargs
+            )
 
         # serialize init file
-        self._autorestapi.write_file(_get_file_path("__init__", async_mode), _render_template("init"))
+        self._autorestapi.write_file(
+            _get_file_path("__init__", async_mode), _render_template("init")
+        )
 
         # serialize service client file
         imports = FileImportSerializer(
-            code_model.service_client.imports(async_mode),
-            is_python3_file=async_mode
+            code_model.service_client.imports(async_mode), is_python3_file=async_mode
         )
         self._autorestapi.write_file(
             _get_file_path(code_model.service_client.filename, async_mode),
-            _render_template("service_client", imports=imports)
+            _render_template("service_client", imports=imports),
         )
 
         # serialize config file
         imports = FileImportSerializer(
-            code_model.config.imports(async_mode),
-            is_python3_file=async_mode
+            code_model.config.imports(async_mode), is_python3_file=async_mode
         )
         self._autorestapi.write_file(
             _get_file_path("_configuration", async_mode),
-            _render_template("config", imports=imports)
+            _render_template("config", imports=imports),
         )
 
         # serialize mixins
         if code_model.operation_mixin_group.mixin_operations:
             imports = FileImportSerializer(
                 code_model.operation_mixin_group.imports(async_mode),
-                is_python3_file=async_mode
+                is_python3_file=async_mode,
             )
             self._autorestapi.write_file(
                 _get_file_path("_operations_mixin", async_mode),
-                _render_template("operations_mixin", imports=imports)
+                _render_template("operations_mixin", imports=imports),
             )
 
         # serialize models
@@ -89,21 +91,15 @@ class MultiAPISerializer(object):
     def _serialize_version_file(self) -> None:
         if self._autorestapi.read_file("_version.py"):
             self._autorestapi.write_file(
-                "_version.py",
-                self._autorestapi.read_file("_version.py")
+                "_version.py", self._autorestapi.read_file("_version.py")
             )
         elif self._autorestapi.read_file("version.py"):
             self._autorestapi.write_file(
-                "_version.py",
-                self._autorestapi.read_file("version.py")
+                "_version.py", self._autorestapi.read_file("version.py")
             )
         else:
             template = self.env.get_template("multiapi_version.py.jinja2")
-            self._autorestapi.write_file(
-                Path("_version.py"),
-                template.render()
-            )
-
+            self._autorestapi.write_file(Path("_version.py"), template.render())
 
     def serialize(self, code_model: CodeModel, no_async: Optional[bool]) -> None:
         self._serialize_helper(code_model, async_mode=False)
@@ -115,8 +111,7 @@ class MultiAPISerializer(object):
         # don't erase patch file
         if self._autorestapi.read_file("_patch.py"):
             self._autorestapi.write_file(
-                "_patch.py",
-                self._autorestapi.read_file("_patch.py")
+                "_patch.py", self._autorestapi.read_file("_patch.py")
             )
 
         self._autorestapi.write_file(Path("py.typed"), "# Marker file for PEP 561.")