@autorest/python 5.14.0 → 5.17.0

package/autorest/multiapi/__init__.py

@@ -32,7 +32,7 @@ class MultiApiScriptPlugin(Plugin):
             output_folder,
             self._autorestapi,
             no_async,
-            user_specified_default_api
+            user_specified_default_api,
         )
         return generator.process()
 
@@ -44,10 +44,12 @@ class MultiAPI:
         output_folder: str,
         autorestapi: AutorestAPI,
         no_async: Optional[bool] = False,
-        user_specified_default_api: Optional[str] = None
+        user_specified_default_api: Optional[str] = None,
     ) -> None:
         if input_package_name is None:
-            raise ValueError("package-name is required, either provide it as args or check your readme configuration")
+            raise ValueError(
+                "package-name is required, either provide it as args or check your readme configuration"
+            )
         self.input_package_name = input_package_name
         _LOGGER.debug("Received package name %s", input_package_name)
 
@@ -64,7 +66,7 @@ class MultiAPI:
             self.mod_to_api_version,
             [p.name for p in self.paths_to_versions],
             self.preview_mode,
-            self.user_specified_default_api
+            self.user_specified_default_api,
         )
 
     @property
@@ -75,7 +77,9 @@ class MultiAPI:
             if self.default_api_version.replace("-", "_") == path_to_version.stem:
                 path_to_default_version = path_to_version
                 break
-        return json.loads(self._autorestapi.read_file(path_to_default_version / "_metadata.json"))
+        return json.loads(
+            self._autorestapi.read_file(path_to_default_version / "_metadata.json")
+        )
 
     @property
     def module_name(self) -> str:
@@ -96,7 +100,11 @@ class MultiAPI:
     def preview_mode(self) -> bool:
         # If True, means the auto-profile will consider preview versions.
         # If not, if it exists a stable API version for a global or RT, will always be used
-        return cast(bool, self.user_specified_default_api and "preview" in self.user_specified_default_api)
+        return cast(
+            bool,
+            self.user_specified_default_api
+            and "preview" in self.user_specified_default_api,
+        )
 
     @property
     def paths_to_versions(self) -> List[Path]:
@@ -105,14 +113,16 @@ class MultiAPI:
         directory.sort()
         for child in directory:
             child_dir = (self.output_folder / child).resolve()
-            if Path(child_dir / '_metadata.json') in child_dir.iterdir():
+            if Path(child_dir / "_metadata.json") in child_dir.iterdir():
                 paths_to_versions.append(Path(child.stem))
         return paths_to_versions
 
     @property
     def version_path_to_metadata(self) -> Dict[Path, Dict[str, Any]]:
         return {
-            version_path: json.loads(self._autorestapi.read_file(version_path / "_metadata.json"))
+            version_path: json.loads(
+                self._autorestapi.read_file(version_path / "_metadata.json")
+            )
             for version_path in self.paths_to_versions
         }
 
@@ -120,18 +130,18 @@ class MultiAPI:
     def mod_to_api_version(self) -> Dict[str, str]:
         mod_to_api_version: Dict[str, str] = defaultdict(str)
         for version_path in self.paths_to_versions:
-            metadata_json = json.loads(self._autorestapi.read_file(version_path / "_metadata.json"))
-            version = metadata_json['chosen_version']
-            total_api_version_list = metadata_json['total_api_version_list']
+            metadata_json = json.loads(
+                self._autorestapi.read_file(version_path / "_metadata.json")
+            )
+            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}")
             mod_to_api_version[version_path.name] = version
         return mod_to_api_version
 

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.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

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum
-from typing import Dict, Optional, Set
+from typing import Dict, Optional, Set, Union, Tuple
 
 
 class ImportType(str, Enum):
@@ -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
@@ -21,52 +22,66 @@ class TypingSection(str, Enum):
 
 class FileImport:
     def __init__(
-        self, imports: Dict[TypingSection, Dict[ImportType, Dict[str, Set[Optional[str]]]]] = None
+        self,
+        imports: Dict[
+            TypingSection,
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        ] = None,
     ) -> None:
         # Basic implementation
         # First level dict: TypingSection
         # Second level dict: ImportType
         # 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[str]]]]] = imports or dict()
+        self._imports: 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[str] = None,
-        typing_section: TypingSection = TypingSection.REGULAR
+        name_import: Optional[Union[str, Tuple[str, str]]] = None,
+        typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
-        self._imports.setdefault(
-                typing_section, dict()
-            ).setdefault(
-                import_type, dict()
-            ).setdefault(
-                from_section, set()
-            ).add(name_import)
+        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(
+            import_type, dict()
+        ).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[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:
@@ -75,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)