@autorest/python 5.14.0 → 5.17.0

package/autorest/multiapi/serializers/__init__.py

@@ -18,12 +18,13 @@ __all__ = [
 
 _FILE_TO_TEMPLATE = {
     "init": "multiapi_init.py.jinja2",
-    "service_client": "multiapi_service_client.py.jinja2",
+    "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.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)
+            _get_file_path(code_model.client.filename, async_mode),
+            _render_template("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

package/autorest/multiapi/serializers/multiapi_serializer.py

@@ -12,7 +12,11 @@ from ...jsonrpc import AutorestAPI
 
 class MultiAPISerializer:
     def __init__(
-        self, conf: Dict[str, Any], async_mode: bool, autorestapi: AutorestAPI, service_client_filename: str
+        self,
+        conf: Dict[str, Any],
+        async_mode: bool,
+        autorestapi: AutorestAPI,
+        service_client_filename: str,
     ):
         self.conf = conf
         self.async_mode = async_mode
@@ -33,64 +37,60 @@ class MultiAPISerializer:
         return Path(filename)
 
     def serialize(self):
-        self._autorestapi.write_file(self._get_file_path("__init__.py"), self.serialize_multiapi_init())
+        self._autorestapi.write_file(
+            self._get_file_path("__init__.py"), self.serialize_multiapi_init()
+        )
 
         service_client_filename_with_py_extension = self.service_client_filename + ".py"
         self._autorestapi.write_file(
             self._get_file_path(service_client_filename_with_py_extension),
-            self.serialize_multiapi_client()
+            self.serialize_multiapi_client(),
         )
 
         configuration_filename = "_configuration.py"
         self._autorestapi.write_file(
             self._get_file_path(configuration_filename),
-            self.serialize_multiapi_config()
+            self.serialize_multiapi_config(),
         )
 
         operation_mixins_filename = "_operations_mixin.py"
         if self.conf["mixin_operations"]:
             self._autorestapi.write_file(
                 self._get_file_path(operation_mixins_filename),
-                self.serialize_multiapi_operation_mixins()
+                self.serialize_multiapi_operation_mixins(),
             )
 
         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:
             self._autorestapi.write_file(
-                Path("_version.py"),
-                self.serialize_multiapi_version()
+                Path("_version.py"), self.serialize_multiapi_version()
             )
 
         # 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("models.py"),
-            self.serialize_multiapi_models()
+            Path("models.py"), self.serialize_multiapi_models()
         )
 
         self._autorestapi.write_file(Path("py.typed"), "# Marker file for PEP 561.")
 
-
     def serialize_multiapi_init(self) -> str:
         template = self.env.get_template("multiapi_init.py.jinja2")
         return template.render(
             service_client_filename=self.service_client_filename,
             client_name=self.conf["client_name"],
-            async_mode=self.async_mode
+            async_mode=self.async_mode,
         )
 
     def serialize_multiapi_client(self) -> str:

package/autorest/multiapi/templates/multiapi_config.py.jinja2

@@ -28,8 +28,8 @@ def __init__(
 # --------------------------------------------------------------------------
 {{ imports }}
 
-class {{ code_model.service_client.name }}Configuration(Configuration):
-    """Configuration for {{ code_model.service_client.name }}.
+class {{ code_model.client.name }}Configuration(Configuration):
+    """Configuration for {{ code_model.client.name }}.
 
     Note that all parameters used to create this instance are saved as instance
     attributes.
@@ -52,7 +52,7 @@ class {{ code_model.service_client.name }}Configuration(Configuration):
             raise ValueError("Parameter '{{ parameter.name }}' must not be None.")
     {% endif %}
 {% endfor %}
-        super({{ code_model.service_client.name }}Configuration, self).__init__(**kwargs)
+        super({{ code_model.client.name }}Configuration, self).__init__(**kwargs)
 
 {% for parameter in code_model.global_parameters.parameters %}
         self.{{ parameter.name }} = {{ parameter.name }}

package/autorest/multiapi/templates/multiapi_init.py.jinja2

@@ -6,8 +6,8 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from .{{ code_model.service_client.filename }} import {{ code_model.service_client.name }}
-__all__ = ['{{ code_model.service_client.name }}']
+from .{{ code_model.client.filename }} import {{ code_model.client.name }}
+__all__ = ['{{ code_model.client.name }}']
 {% if not async_mode %}
 
 try:

package/autorest/multiapi/templates/multiapi_operations_mixin.py.jinja2

@@ -14,7 +14,7 @@ from msrest import Serializer, Deserializer
 {% endif %}
 
 
-class {{ code_model.service_client.name }}OperationsMixin(object):
+class {{ code_model.client.name }}OperationsMixin(object):
 {% for mixin_operation in code_model.operation_mixin_group.mixin_operations %}
 
     {{ mixin_operation.signature(async_mode) | indent }}        {{ mixin_operation.description(async_mode) | indent(8) }}
@@ -22,7 +22,7 @@ class {{ code_model.service_client.name }}OperationsMixin(object):
         {% for api in mixin_operation.available_apis|sort %}
         {% set if_statement = "if" if loop.first else "elif" %}
         {{ if_statement }} api_version == '{{ code_model.mod_to_api_version[api] }}':
-            from {{ ".." if async_mode else "." }}{{ api }}{{ ".aio" if async_mode else "" }}.operations import {{ code_model.service_client.name }}OperationsMixin as OperationClass
+            from {{ ".." if async_mode else "." }}{{ api }}{{ ".aio" if async_mode else "" }}.operations import {{ code_model.client.name }}OperationsMixin as OperationClass
         {% endfor %}
         else:
             raise ValueError("API version {} does not have operation '{{ mixin_operation.name }}'".format(api_version))
@@ -30,9 +30,9 @@ class {{ code_model.service_client.name }}OperationsMixin(object):
         mixin_instance._client = self._client
         mixin_instance._config = self._config
         mixin_instance._serialize = Serializer(self._models_dict(api_version))
-        {% if not code_model.service_client.client_side_validation %}
+        {% if not code_model.client.client_side_validation %}
         mixin_instance._serialize.client_side_validation = False
         {% endif %}
         mixin_instance._deserialize = Deserializer(self._models_dict(api_version))
-        return {{ "await " if mixin_operation.coroutine(async_mode) }}mixin_instance.{{ mixin_operation.name }}({{ mixin_operation.call }}{{ ", **kwargs" if  mixin_operation.call else "**kwargs" }})
+        return {{ "await " if mixin_operation.coroutine(async_mode) }}mixin_instance.{{ mixin_operation.name }}({{ mixin_operation.call(async_mode) }})
 {% endfor %}

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -43,8 +43,8 @@ class _SDKClient(object):
         """
         pass
 
-class {{ code_model.service_client.name }}({% if code_model.operation_mixin_group.mixin_operations %}{{ code_model.service_client.name }}OperationsMixin, {% endif %}MultiApiClientMixin, _SDKClient):
-    """{{ code_model.service_client.description }}
+class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_operations %}{{ code_model.client.name }}OperationsMixin, {% endif %}MultiApiClientMixin, _SDKClient):
+    """{{ code_model.client.description }}
 
     This ready contains multiple API versions, to help you deal with all of the Azure clouds
     (Azure Stack, Azure Government, Azure China, etc.).
@@ -64,13 +64,13 @@ class {{ code_model.service_client.name }}({% if code_model.operation_mixin_grou
     :param {{ parameter.name }}: {{ parameter.description(async_mode) }}
     :type {{ parameter.name }}: {{ parameter.docstring_type(async_mode) }}
 {% endfor %}
-    {% if code_model.service_client.has_lro_operations %}
+    {% if code_model.client.has_lro_operations %}
     :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
     {% endif %}
     """
 
     DEFAULT_API_VERSION = '{{ code_model.mod_to_api_version[code_model.default_api_version] }}'
-    _PROFILE_TAG = "{{ code_model.module_name }}.{{ code_model.service_client.name }}"
+    _PROFILE_TAG = "{{ code_model.module_name }}.{{ code_model.client.name }}"
     LATEST_PROFILE = ProfileDefinition({
         _PROFILE_TAG: {
             None: DEFAULT_API_VERSION,
@@ -82,8 +82,8 @@ class {{ code_model.service_client.name }}({% if code_model.operation_mixin_grou
     )
 
     {{ method_signature()|indent }}
-        {% if not code_model.service_client.host_value %}
-        {% for parameterized_host_template, api_versions in code_model.service_client.parameterized_host_template_to_api_version|dictsort %}
+        {% if not code_model.client.host_value %}
+        {% for parameterized_host_template, api_versions in code_model.client.parameterized_host_template_to_api_version|dictsort %}
         {% set if_statement = "if" if loop.first else "elif" %}
         {{ if_statement ~ " api_version == '" ~ api_versions|join("' or api_version == '") ~ "'" }}:
             base_url = {{ parameterized_host_template }}
@@ -91,9 +91,9 @@ class {{ code_model.service_client.name }}({% if code_model.operation_mixin_grou
         else:
             raise ValueError("API version {} is not available".format(api_version))
         {% endif %}
-        self._config = {{ code_model.service_client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
-        self._client = {{ async_prefix }}{{ code_model.service_client.pipeline_client }}(base_url=base_url, config=self._config, **kwargs)
-        super({{ code_model.service_client.name }}, self).__init__(
+        self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
+        self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url=base_url, config=self._config, **kwargs)
+        super({{ code_model.client.name }}, self).__init__(
             api_version=api_version,
             profile=profile
         )

package/autorest/multiapi/utils.py

@@ -12,14 +12,14 @@ _LOGGER = logging.getLogger(__name__)
 def _sync_or_async(async_mode: bool) -> str:
     return "async" if async_mode else "sync"
 
+
 def _get_default_api_version_from_list(
     mod_to_api_version: Dict[str, str],
     api_versions_list: List[str],
     preview_mode: bool,
-    user_specified_default_api: Optional[str]
+    user_specified_default_api: Optional[str],
 ) -> str:
-    """Get the floating latest, from a random list of API versions.
-    """
+    """Get the floating latest, from a random list of API versions."""
 
     # I need user_specified_default_api to be v2019_06_07_preview shaped if it exists, let's be smart
     # and change it automatically so I can take both syntax as input

package/autorest/postprocess/__init__.py

@@ -0,0 +1,202 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Tuple
+from pathlib import Path
+import os
+import shutil
+from venv import EnvBuilder
+import black
+from .venvtools import ExtendedEnvBuilder, python_run
+
+from .. import Plugin
+
+_BLACK_MODE = black.Mode()
+_BLACK_MODE.line_length = 120
+
+
+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
+        )
+    except black.NothingChanged:
+        pass
+    return file_content
+
+
+class PostProcessPlugin(Plugin):
+    def __init__(self, autorestapi):
+        super().__init__(autorestapi)
+        output_folder_uri = self._autorestapi.get_value("outputFolderUri")
+        if output_folder_uri.startswith("file:"):
+            output_folder_uri = output_folder_uri[5:]
+        if os.name == "nt" and output_folder_uri.startswith("///"):
+            output_folder_uri = output_folder_uri[3:]
+        self.output_folder = Path(output_folder_uri)  # path to where the setup.py is
+        self.setup_venv()
+
+        # set up the venv
+        # base folder is where the code starts, i.e. where we
+        self.base_folder, self.namespace = self.get_namespace(self.output_folder, "")
+
+    def setup_venv(self):
+        venv_path = self.output_folder / Path(".temp_folder") / Path("temp_venv")
+
+        if venv_path.exists():
+            env_builder = EnvBuilder(with_pip=True)
+            self.venv_context = env_builder.ensure_directories(venv_path)
+        else:
+            env_builder = ExtendedEnvBuilder(with_pip=True)
+            env_builder.create(venv_path)
+            self.venv_context = env_builder.context
+            python_run(
+                self.venv_context,
+                "pip",
+                ["install", "-e", str(self.output_folder)],
+                directory=self.output_folder,
+            )
+
+    def get_namespace(self, dir: Path, namespace: str) -> Tuple[Path, str]:
+        try:
+            init_file = next(d for d in dir.iterdir() if d.name == "__init__.py")
+            # we don't care about pkgutil inits, we skip over them
+            file_content = self._autorestapi.read_file(
+                init_file.relative_to(self.output_folder)
+            )
+            if not "pkgutil" in file_content:
+                return dir, namespace
+        except StopIteration:
+            pass
+
+        try:
+            # first, see if we can get a folder that has the same name as the current output folder
+            start = self.output_folder.stem.split("-")[0]
+            next_dir = next(d for d in dir.iterdir() if d.is_dir() and d.name == start)
+        except StopIteration:
+            invalid_start_chars = [".", "_"]
+            invalid_dirs = [
+                "swagger",
+                "out",
+                "tests",
+                "samples",
+            ]
+
+            next_dir = next(
+                d
+                for d in dir.iterdir()
+                if d.is_dir()
+                and not str(d).endswith("egg-info")
+                and d.name[0] not in invalid_start_chars
+                and d.name not in invalid_dirs
+            )
+
+        namespace = f"{namespace}.{next_dir.name}" if namespace else next_dir.name
+        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("__")
+        ]
+        # will always have the root
+        self.fix_imports_in_init(
+            generated_file_name="_client",
+            folder_path=self.base_folder,
+            namespace=self.namespace,
+        )
+        try:
+            aio_folder = next(f for f in folders if f.stem == "aio")
+            self.fix_imports_in_init(
+                generated_file_name="_client",
+                folder_path=aio_folder,
+                namespace=f"{self.namespace}.aio",
+            )
+        except StopIteration:
+            pass
+
+        try:
+            models_folder = next(f for f in folders if f.stem == "models")
+            self.fix_imports_in_init(
+                generated_file_name="_models",
+                folder_path=models_folder,
+                namespace=f"{self.namespace}.models",
+            )
+        except StopIteration:
+            pass
+        operations_folders = [
+            f for f in folders if f.stem in ["operations", "_operations"]
+        ]
+        for operations_folder in operations_folders:
+            aio = ".aio" if operations_folder.parent.stem == "aio" else ""
+            self.fix_imports_in_init(
+                generated_file_name="_operations",
+                folder_path=operations_folder,
+                namespace=f"{self.namespace}{aio}.{operations_folder.stem}",
+            )
+        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:
+        customized_objects_str = python_run(
+            self.venv_context,
+            command=[namespace, str(self.output_folder)],
+            module="get_all",
+        )
+
+        if not customized_objects_str:
+            return
+        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._autorestapi.read_file(file)
+        added_objs = []
+        for obj in customized_objects:
+            if f" import {obj}\n" in file_content:
+                # means we're overriding a generated model
+                file_content = file_content.replace(
+                    f"from .{generated_file_name} import {obj}\n",
+                    f"from ._patch import {obj}\n",
+                )
+            else:
+                added_objs.append(obj)
+        file_content = file_content.replace(
+            "try:\n    from ._patch import __all__ as _patch_all\n    "
+            "from ._patch import *  # type: ignore # pylint: disable=unused-wildcard-import"
+            "\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 *  # type: ignore # pylint: disable=unused-wildcard-import\n",
+            "",
+        )
+        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"
+            imports = "\n".join([f"from ._patch import {obj}" for obj in added_objs])
+            if imports:
+                replacement = f"{imports}\n{patch_sdk_import}"
+            else:
+                replacement = patch_sdk_import
+            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
+            )
+        formatted_file = format_file(file, file_content)
+        self._autorestapi.write_file(file, formatted_file)