@autorest/python 6.13.16 → 6.13.17

package/autorest/multiapi/__init__.py

@@ -66,9 +66,7 @@ class MultiAPI(ReaderAndWriter):  # pylint: disable=abstract-method
     ) -> None:
         super().__init__(output_folder=Path(output_folder).resolve(), **kwargs)
         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)
         _LOGGER.debug("Received output-folder %s", output_folder)
@@ -116,8 +114,7 @@ class MultiAPI(ReaderAndWriter):  # pylint: disable=abstract-method
         # 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,
+            self.user_specified_default_api and "preview" in self.user_specified_default_api,
         )
 
     @property
@@ -147,9 +144,7 @@ class MultiAPI(ReaderAndWriter):  # pylint: disable=abstract-method
             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}"
-                    )
+                    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}")
             mod_to_api_version[version_path.name] = version
@@ -186,6 +181,4 @@ class MultiAPIAutorest(MultiAPI, ReaderAndWriterAutorest):
 
     @property
     def serializer(self) -> MultiAPISerializer:
-        return MultiAPISerializerAutorest(
-            self._autorestapi, output_folder=self.output_folder
-        )
+        return MultiAPISerializerAutorest(self._autorestapi, output_folder=self.output_folder)

package/autorest/multiapi/models/client.py

@@ -16,9 +16,7 @@ def _extract_version(metadata_json: Dict[str, Any], version_path: Path) -> str:
     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}"
-            )
+            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}")
     return version
@@ -36,20 +34,14 @@ class Client:
         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"
-        file_import = FileImport(
-            json.loads(self.default_version_metadata["client"][imports_to_load])
-        )
-        local_imports = file_import.imports.get(TypingSection.REGULAR, {}).get(
-            ImportType.LOCAL, {}
-        )
+        file_import = FileImport(json.loads(self.default_version_metadata["client"][imports_to_load]))
+        local_imports = file_import.imports.get(TypingSection.REGULAR, {}).get(ImportType.LOCAL, {})
         for key in local_imports:
             if re.search("^\\.*_serialization$", key):
                 relative_path = ".." if async_mode else "."
@@ -61,22 +53,16 @@ class Client:
     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_public_lro_operations(self) -> bool:
         has_public_lro_operations = False
         for _, metadata_json in self.version_path_to_metadata.items():
-            current_client_has_public_lro_operations = metadata_json["client"][
-                "has_public_lro_operations"
-            ]
+            current_client_has_public_lro_operations = metadata_json["client"]["has_public_lro_operations"]
             if current_client_has_public_lro_operations:
                 has_public_lro_operations = True
         return has_public_lro_operations

package/autorest/multiapi/models/code_model.py

@@ -34,16 +34,10 @@ 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.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.global_parameters = GlobalParameters(
-            default_version_metadata["global_parameters"]
-        )
+        self.operation_mixin_group = OperationMixinGroup(version_path_to_metadata, default_api_version)
+        self.global_parameters = GlobalParameters(default_version_metadata["global_parameters"])
         self.user_specified_default_api = user_specified_default_api
         self.options: Dict[str, Any] = {"flavor": "azure", "company_name": "Microsoft"}
         self.core_library = "azure.core"
@@ -60,16 +54,12 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
                 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
 
@@ -77,10 +67,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
     def host_variable_name(self) -> str:
         if self.client.parameterized_host_template_to_api_version:
             return "base_url"
-        params = (
-            self.global_parameters.parameters
-            + self.global_parameters.service_client_specific_global_parameters
-        )
+        params = self.global_parameters.parameters + self.global_parameters.service_client_specific_global_parameters
         try:
             return next(p for p in params if p.name in ["endpoint", "base_url"]).name
         except StopIteration:
@@ -121,8 +108,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
 
         # First let's map operation groups to their available APIs
         versioned_dict = {
-            operation_group.name: operation_group.available_apis
-            for operation_group in self.operation_groups
+            operation_group.name: operation_group.available_apis for operation_group in self.operation_groups
         }
 
         # Now let's also include mixins to their available APIs
@@ -144,9 +130,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
             # If some others RT contains "local_default_api_version", and
             # if it's greater than the future default, danger, don't profile it
             if (
-                there_is_a_rt_that_contains_api_version(
-                    versioned_dict, local_default_api_version
-                )
+                there_is_a_rt_that_contains_api_version(versioned_dict, local_default_api_version)
                 and local_default_api_version > self.default_api_version
             ):
                 continue
@@ -155,7 +139,4 @@ 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()}
-        )
+        return sorted({self.default_api_version} | {versions for _, versions in self.last_rt_list.items()})

package/autorest/multiapi/models/config.py

@@ -16,9 +16,7 @@ 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/global_parameters.py

@@ -33,31 +33,21 @@ 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"]
-
-        return _convert_global_parameters(
-            service_client_params_sync, service_client_params_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)
 
     @property
     def parameters(self) -> List[GlobalParameter]:
         global_parameters_metadata_sync = self.global_parameters_metadata["sync"]
         global_parameters_metadata_async = self.global_parameters_metadata["async"]
 
-        return _convert_global_parameters(
-            global_parameters_metadata_sync, global_parameters_metadata_async
-        )
+        return _convert_global_parameters(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

@@ -43,9 +43,7 @@ class FileImport:
                                     Tuple[
                                         str,
                                         Optional[str],
-                                        Tuple[
-                                            Tuple[Tuple[int, int], str, Optional[str]]
-                                        ],
+                                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
                                     ],
                                 ]
                             ]
@@ -125,9 +123,9 @@ class FileImport:
             ],
             convert_list_to_tuple(name_import),
         )
-        self._imports.setdefault(typing_section, {}).setdefault(
-            import_type, {}
-        ).setdefault(from_section, set()).add(name_input)
+        self._imports.setdefault(typing_section, {}).setdefault(import_type, {}).setdefault(from_section, set()).add(
+            name_input
+        )
 
     def add_submodule_import(
         self,
@@ -175,6 +173,4 @@ 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/operation_mixin_group.py

@@ -32,11 +32,7 @@ class OperationMixinGroup:
         return imports
 
     def typing_definitions(self, async_mode: bool) -> str:
-        key = (
-            "sync_mixin_typing_definitions"
-            if async_mode
-            else "async_mixin_typing_definitions"
-        )
+        key = "sync_mixin_typing_definitions" if async_mode else "async_mixin_typing_definitions"
         origin = "".join(
             [
                 metadata_json.get("operation_mixins", {}).get(key, "")
@@ -45,22 +41,16 @@ class OperationMixinGroup:
         )
         return "\n".join(set(origin.split("\n")))
 
-    def _use_metadata_of_default_api_version(
-        self, mixin_operations: List[MixinOperation]
-    ) -> List[MixinOperation]:
+    def _use_metadata_of_default_api_version(self, mixin_operations: List[MixinOperation]) -> List[MixinOperation]:
         default_api_version_path = [
             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]
@@ -81,9 +71,7 @@ class OperationMixinGroup:
                 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,

package/autorest/multiapi/serializers/__init__.py

@@ -27,13 +27,8 @@ _FILE_TO_TEMPLATE = {
 }
 
 
-def _method_signature_helper(
-    parameters: List[GlobalParameter], async_mode: bool
-) -> List[str]:
-    return [
-        p.signature(async_mode)
-        for p in sorted(parameters, key=lambda p: p.required, reverse=True)
-    ]
+def _method_signature_helper(parameters: List[GlobalParameter], async_mode: bool) -> List[str]:
+    return [p.signature(async_mode) for p in sorted(parameters, key=lambda p: p.required, reverse=True)]
 
 
 def _get_file_path(filename: str, async_mode: bool) -> Path:
@@ -62,39 +57,25 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 code_model.global_parameters.parameters
                 + code_model.global_parameters.service_client_specific_global_parameters
             )
-            positional_params = [
-                p for p in all_params if p.method_location == "positional"
-            ]
-            keyword_only_params = [
-                p for p in all_params if p.method_location == "keywordOnly"
-            ]
+            positional_params = [p for p in all_params if p.method_location == "positional"]
+            keyword_only_params = [p for p in all_params if p.method_location == "keywordOnly"]
             return template.render(
                 code_model=code_model,
                 async_mode=async_mode,
-                positional_params=_method_signature_helper(
-                    positional_params, async_mode
-                ),
-                keyword_only_params=_method_signature_helper(
-                    keyword_only_params, async_mode
-                ),
+                positional_params=_method_signature_helper(positional_params, async_mode),
+                keyword_only_params=_method_signature_helper(keyword_only_params, async_mode),
                 **kwargs
             )
 
         # serialize init file
-        self.write_file(
-            _get_file_path("__init__", async_mode), _render_template("init")
-        )
+        self.write_file(_get_file_path("__init__", async_mode), _render_template("init"))
 
         # serialize service client file
         imports = FileImportSerializer(code_model.client.imports(async_mode))
-        config_policies = build_policies(
-            code_model.azure_arm, async_mode, is_azure_flavor=True
-        )
+        config_policies = build_policies(code_model.azure_arm, async_mode, is_azure_flavor=True)
         self.write_file(
             _get_file_path(code_model.client.filename, async_mode),
-            _render_template(
-                "client", imports=imports, config_policies=config_policies
-            ),
+            _render_template("client", imports=imports, config_policies=config_policies),
         )
 
         # serialize config file
@@ -158,7 +139,5 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
 
 
 class MultiAPISerializerAutorest(MultiAPISerializer, ReaderAndWriterAutorest):
-    def __init__(
-        self, autorestapi: AutorestAPI, *, output_folder: Union[str, Path]
-    ) -> None:
+    def __init__(self, autorestapi: AutorestAPI, *, output_folder: Union[str, Path]) -> None:
         super().__init__(autorestapi=autorestapi, output_folder=output_folder)

package/autorest/multiapi/serializers/import_serializer.py

@@ -57,9 +57,7 @@ def _serialize_package(
         )
     for submodule_name, alias, version_modules in versioned_modules:
         for n, (version, module_name, comment) in enumerate(version_modules):
-            buffer.append(
-                "{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version)
-            )
+            buffer.append("{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version))
             buffer.append(
                 f"    from {module_name} import {submodule_name}{f' as {alias}' if alias else ''}"
                 f"{f' # {comment}' if comment else ''}"
@@ -141,34 +139,24 @@ 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):
-            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()
@@ -179,9 +167,7 @@ class FileImportSerializer:
         )
 
         if regular_imports_dict:
-            regular_imports = "\n\n".join(
-                _get_import_clauses(regular_imports_dict, "\n")
-            )
+            regular_imports = "\n\n".join(_get_import_clauses(regular_imports_dict, "\n"))
 
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
@@ -190,8 +176,6 @@ class FileImportSerializer:
         )
         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 + self._typing_definitions

package/autorest/multiapi/utils.py

@@ -25,17 +25,13 @@ def _get_default_api_version_from_list(
     # and change it automatically so I can take both syntax as input
     if user_specified_default_api and not user_specified_default_api.startswith("v"):
         default_api_version = [
-            mod_api
-            for mod_api, real_api in mod_to_api_version.items()
-            if real_api == user_specified_default_api
+            mod_api for mod_api, real_api in mod_to_api_version.items() if real_api == user_specified_default_api
         ][0]
         _LOGGER.info("Default API version will be: %s", default_api_version)
         return default_api_version
 
     absolute_latest = sorted(api_versions_list)[-1]
-    not_preview_versions = [
-        version for version in api_versions_list if "preview" not in version
-    ]
+    not_preview_versions = [version for version in api_versions_list if "preview" not in version]
 
     # If there is no preview, easy: the absolute latest is the only latest
     if not not_preview_versions:

package/autorest/multiclient/__init__.py

@@ -33,9 +33,7 @@ class MultiClientPlugin(Plugin):  # pylint: disable=abstract-method
         template = env.get_template("version.py.jinja2")
         self.write_file(
             Path("_version.py"),
-            template.render(
-                package_version=self.options.get("package-version") or "1.0.0b1"
-            ),
+            template.render(package_version=self.options.get("package-version") or "1.0.0b1"),
         )
 
         # py.typed

package/autorest/postprocess/__init__.py

@@ -22,9 +22,7 @@ def format_file(file: Path, file_content: str) -> str:
     if not file.suffix == ".py":
         return file_content
     try:
-        file_content = black.format_file_contents(
-            file_content, fast=True, mode=_BLACK_MODE
-        )
+        file_content = black.format_file_contents(file_content, fast=True, mode=_BLACK_MODE)
     except NothingChanged:
         pass
     return file_content
@@ -98,11 +96,7 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
         return self.get_namespace(next_dir, namespace)
 
     def process(self) -> bool:
-        folders = [
-            f
-            for f in self.base_folder.glob("**/*")
-            if f.is_dir() and not f.stem.startswith("__")
-        ]
+        folders = [f for f in self.base_folder.glob("**/*") if f.is_dir() and not f.stem.startswith("__")]
         # will always have the root
         self.fix_imports_in_init(
             generated_file_name="_client",
@@ -128,13 +122,9 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
             )
         except StopIteration:
             pass
-        operations_folders = [
-            f for f in folders if f.stem in ["operations", "_operations"]
-        ]
+        operations_folders = [f for f in folders if f.stem in ["operations", "_operations"]]
         for operations_folder in operations_folders:
-            sub_namespace = ".".join(
-                str(operations_folder.relative_to(self.base_folder)).split(os.sep)
-            )
+            sub_namespace = ".".join(str(operations_folder.relative_to(self.base_folder)).split(os.sep))
             self.fix_imports_in_init(
                 generated_file_name="_operations",
                 folder_path=operations_folder,
@@ -143,9 +133,7 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
         shutil.rmtree(f"{str(self.output_folder)}/.temp_folder")
         return True
 
-    def fix_imports_in_init(
-        self, generated_file_name: str, folder_path: Path, namespace: str
-    ) -> None:
+    def fix_imports_in_init(self, generated_file_name: str, folder_path: Path, namespace: str) -> None:
         customized_objects_str = python_run(
             self.venv_context,
             command=[namespace, str(self.output_folder)],
@@ -154,9 +142,7 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
 
         if not customized_objects_str:
             return
-        customized_objects = {
-            k: None for k in customized_objects_str.split(",")
-        }.keys()  # filter out duplicates
+        customized_objects = {k: None for k in customized_objects_str.split(",")}.keys()  # filter out duplicates
         file = (folder_path / "__init__.py").relative_to(self.output_folder)
         file_content = self.read_file(file).replace("\r\n", "\n")
         added_objs = []
@@ -175,16 +161,12 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
             "\nexcept ImportError:\n    _patch_all = []",
             "",
         )
-        file_content = file_content.replace(
-            "from ._patch import __all__ as _patch_all", ""
-        )
+        file_content = file_content.replace("from ._patch import __all__ as _patch_all", "")
         file_content = file_content.replace(
             "from ._patch import *  # pylint: disable=unused-wildcard-import\n",
             "",
         )
-        file_content = file_content.replace(
-            "__all__.extend([p for p in _patch_all if p not in __all__])", ""
-        )
+        file_content = file_content.replace("__all__.extend([p for p in _patch_all if p not in __all__])", "")
         if added_objs:
             # add import
             patch_sdk_import = "from ._patch import patch_sdk as _patch_sdk"
@@ -196,9 +178,7 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
             file_content = file_content.replace(patch_sdk_import, replacement)
             # add to __all__
             added_objs_all = "\n".join([f'    "{obj}",' for obj in added_objs]) + "\n"
-            file_content = file_content.replace(
-                "__all__ = [", f"__all__ = [\n{added_objs_all}", 1
-            )
+            file_content = file_content.replace("__all__ = [", f"__all__ = [\n{added_objs_all}", 1)
         formatted_file = format_file(file, file_content)
         self.write_file(file, formatted_file)
 

package/autorest/postprocess/get_all.py

@@ -15,7 +15,5 @@ def main(namespace):
 if __name__ == "__main__":
     patched = ",".join(main(sys.argv[1]))
     output_folder = sys.argv[2]
-    with open(
-        f"{output_folder}/.temp_folder/patched.txt", "w", encoding="utf-8-sig"
-    ) as f:
+    with open(f"{output_folder}/.temp_folder/patched.txt", "w", encoding="utf-8-sig") as f:
         f.write(patched)

package/autorest/postprocess/venvtools.py

@@ -69,9 +69,7 @@ def python_run(  # pylint: disable=inconsistent-return-statements
             stdout=False,
         )
         if module == "get_all":
-            with open(
-                f"{command[1]}/.temp_folder/patched.txt", "r", encoding="utf-8-sig"
-            ) as f:
+            with open(f"{command[1]}/.temp_folder/patched.txt", "r", encoding="utf-8-sig") as f:
                 return f.read()
     except subprocess.CalledProcessError as err:
         print(err)