@autorest/python 5.13.0 → 5.16.0

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

@@ -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)

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

package/autorest/multiapi/serializers/import_serializer.py

@@ -7,19 +7,34 @@ from copy import deepcopy
 from typing import Dict, Set, Optional, List
 from ..models import ImportType, FileImport, TypingSection
 
-def _serialize_package(package_name: str, module_list: Set[Optional[str]], delimiter: str) -> str:
+
+def _serialize_package(
+    package_name: str, module_list: Set[Optional[str]], delimiter: str
+) -> str:
     buffer = []
     if None in module_list:
         buffer.append(f"import {package_name}")
     if module_list != {None}:
         buffer.append(
             "from {} import {}".format(
-                package_name, ", ".join(sorted([mod for mod in module_list if mod is not None]))
+                package_name,
+                ", ".join(
+                    sorted(
+                        [
+                            mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}"
+                            for mod in module_list
+                            if mod is not None
+                        ]
+                    )
+                ),
             )
         )
     return delimiter.join(buffer)
 
-def _serialize_type(import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str) -> str:
+
+def _serialize_type(
+    import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str
+) -> str:
     """Serialize a given import type."""
     import_list = []
     for package_name in sorted(list(import_type_dict.keys())):
@@ -27,7 +42,10 @@ def _serialize_type(import_type_dict: Dict[str, Set[Optional[str]]], delimiter:
         import_list.append(_serialize_package(package_name, module_list, delimiter))
     return delimiter.join(import_list)
 
-def _get_import_clauses(imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str) -> List[str]:
+
+def _get_import_clauses(
+    imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str
+) -> List[str]:
     import_clause = []
     for import_type in ImportType:
         if import_type in imports:
@@ -42,33 +60,44 @@ class FileImportSerializer:
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
-        switched_dictionary[new_key] = self._file_import.imports[TypingSection.CONDITIONAL]
+        switched_dictionary[new_key] = self._file_import.imports[
+            TypingSection.CONDITIONAL
+        ]
         return switched_dictionary
 
-    def _get_imports_dict(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
+    def _get_imports_dict(
+        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)
-        if add_conditional_typing and self._file_import.imports.get(TypingSection.CONDITIONAL):
+        if add_conditional_typing and self._file_import.imports.get(
+            TypingSection.CONDITIONAL
+        ):
             # we switch the TypingSection key for the CONDITIONAL typing imports so we can merge
             # the imports together
-            switched_imports_dictionary = self._switch_typing_section_key(baseline_typing_section)
+            switched_imports_dictionary = self._switch_typing_section_key(
+                baseline_typing_section
+            )
             switched_imports = FileImport(switched_imports_dictionary)
             file_import_copy.merge(switched_imports)
         return file_import_copy.imports.get(baseline_typing_section, {})
 
     def _add_type_checking_import(self):
-        if (
-            self._file_import.imports.get(TypingSection.TYPING) or
-            (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
+        if self._file_import.imports.get(TypingSection.TYPING) or (
+            not self.is_python3_file
+            and self._file_import.imports.get(TypingSection.CONDITIONAL)
         ):
-            self._file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+            self._file_import.add_submodule_import(
+                "typing", "TYPE_CHECKING", ImportType.STDLIB
+            )
 
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
-            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_dict:
@@ -78,10 +107,13 @@ class FileImportSerializer:
 
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
-            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_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_dict, "\n    "))
+            typing_imports += "\n\n    ".join(
+                _get_import_clauses(typing_imports_dict, "\n    ")
+            )
 
         return regular_imports + typing_imports