@autorest/python 6.0.0 → 6.0.1

package/ChangeLog.md

@@ -1,5 +1,20 @@
 # Release History
 
+### 2022-06-29 - 6.0.1
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Bug Fixes**
+
+- Ignore linting error for clients with no credentials  #1333
+
 ### 2022-06-24 - 6.0.0
 
 | Library                                                                 | Min Version |

package/autorest/__init__.py

@@ -4,8 +4,9 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
+from pathlib import Path
 from abc import ABC, abstractmethod
-from typing import Any, Dict
+from typing import Any, Dict, Union
 
 import yaml
 
@@ -17,14 +18,40 @@ __version__ = VERSION
 _LOGGER = logging.getLogger(__name__)
 
 
-class Plugin(ABC):
+class ReaderAndWriter:
+    def __init__(self, **kwargs: Any) -> None:
+        pass
+
+    def read_file(self, path: Union[str, Path]) -> str:
+        """How does one read a file in cadl?"""
+        raise NotImplementedError("Haven't plugged in Cadl yet")
+
+    def write_file(self, filename: Union[str, Path], file_content: str) -> None:
+        """How does writing work in cadl?"""
+        raise NotImplementedError("Haven't plugged in Cadl yet")
+
+
+class ReaderAndWriterAutorest(ReaderAndWriter):
+    def __init__(self, *, autorestapi: AutorestAPI) -> None:
+        super().__init__()
+        self._autorestapi = autorestapi
+
+    def read_file(self, path: Union[str, Path]) -> str:
+        return self._autorestapi.read_file(path)
+
+    def write_file(self, filename: Union[str, Path], file_content: str) -> None:
+        return self._autorestapi.write_file(filename, file_content)
+
+
+class Plugin(ReaderAndWriter, ABC):
     """A base class for autorest plugin.
 
     :param autorestapi: An autorest API instance
     """
 
-    def __init__(self, autorestapi: AutorestAPI) -> None:
-        self._autorestapi = autorestapi
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.options: Dict[str, Any] = {}
 
     @abstractmethod
     def process(self) -> bool:
@@ -37,24 +64,30 @@ class Plugin(ABC):
         raise NotImplementedError()
 
 
+class PluginAutorest(Plugin, ReaderAndWriterAutorest):
+    """For our Autorest plugins, we want to take autorest api as input as options, then pass it to the Plugin"""
+
+    def __init__(self, autorestapi: AutorestAPI) -> None:
+        super().__init__(autorestapi=autorestapi)
+        self.options = self.get_options()
+
+    @abstractmethod
+    def get_options(self) -> Dict[str, Any]:
+        """Get the options bag using the AutorestAPI that we send to the parent plugin"""
+
+
 class YamlUpdatePlugin(Plugin):
     """A plugin that update the YAML as input."""
 
     def process(self) -> bool:
         # List the input file, should be only one
-        inputs = self._autorestapi.list_inputs()
-        _LOGGER.debug("Possible Inputs: %s", inputs)
-        if "code-model-v4-no-tags.yaml" not in inputs:
-            raise ValueError("code-model-v4-no-tags.yaml must be a possible input")
-
-        file_content = self._autorestapi.read_file("code-model-v4-no-tags.yaml")
-        yaml_data = yaml.safe_load(file_content)
+        yaml_data = yaml.safe_load(self.read_file("code-model-v4-no-tags.yaml"))
 
         self.update_yaml(yaml_data)
 
         yaml_string = yaml.safe_dump(yaml_data)
 
-        self._autorestapi.write_file("code-model-v4-no-tags.yaml", yaml_string)
+        self.write_file("code-model-v4-no-tags.yaml", yaml_string)
         return True
 
     @abstractmethod
@@ -67,4 +100,12 @@ class YamlUpdatePlugin(Plugin):
         raise NotImplementedError()
 
 
-__all__ = ["Plugin", "YamlUpdatePlugin"]
+class YamlUpdatePluginAutorest(  # pylint: disable=abstract-method
+    YamlUpdatePlugin, PluginAutorest
+):
+    def get_options(self) -> Dict[str, Any]:
+        inputs = self._autorestapi.list_inputs()
+        _LOGGER.debug("Possible Inputs: %s", inputs)
+        if "code-model-v4-no-tags.yaml" not in inputs:
+            raise ValueError("code-model-v4-no-tags.yaml must be a possible input")
+        return {}

package/autorest/black/__init__.py

@@ -6,9 +6,10 @@
 import logging
 from pathlib import Path
 import os
+from typing import Any, Dict
 import black
 
-from .. import Plugin
+from .. import Plugin, PluginAutorest
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,10 +17,10 @@ _BLACK_MODE = black.Mode()
 _BLACK_MODE.line_length = 120
 
 
-class BlackScriptPlugin(Plugin):
-    def __init__(self, autorestapi):
-        super().__init__(autorestapi)
-        output_folder_uri = self._autorestapi.get_value("outputFolderUri")
+class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        output_folder_uri = self.options["outputFolderUri"]
         if output_folder_uri.startswith("file:"):
             output_folder_uri = output_folder_uri[5:]
         if os.name == "nt" and output_folder_uri.startswith("///"):
@@ -38,9 +39,9 @@ class BlackScriptPlugin(Plugin):
 
     def format_file(self, full_path) -> None:
         file = full_path.relative_to(self.output_folder)
-        file_content = self._autorestapi.read_file(file)
+        file_content = self.read_file(file)
         if not file.suffix == ".py":
-            self._autorestapi.write_file(file, file_content)
+            self.write_file(file, file_content)
             return
         try:
             file_content = black.format_file_contents(
@@ -48,4 +49,9 @@ class BlackScriptPlugin(Plugin):
             )
         except black.NothingChanged:
             pass
-        self._autorestapi.write_file(file, file_content)
+        self.write_file(file, file_content)
+
+
+class BlackScriptPluginAutorest(BlackScriptPlugin, PluginAutorest):
+    def get_options(self) -> Dict[str, Any]:
+        return {"outputFolderUri": self._autorestapi.get_value("outputFolderUri")}

package/autorest/codegen/__init__.py

@@ -10,13 +10,13 @@ from pathlib import Path
 import yaml
 
 
-from .. import Plugin
+from .. import Plugin, PluginAutorest
 from .models.client import Client, Config
 from .models.code_model import CodeModel
 from .models import build_type
 from .models.request_builder import get_request_builder
 from .models.operation_group import OperationGroup
-from .serializers import JinjaSerializer
+from .serializers import JinjaSerializer, JinjaSerializerAutorest
 
 
 def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -> None:
@@ -162,8 +162,8 @@ class CodeGenerator(Plugin):
 
     def _build_code_model_options(self) -> Dict[str, Any]:
         """Build en options dict from the user input while running autorest."""
-        azure_arm = self._autorestapi.get_boolean_value("azure-arm", False)
-        license_header = self._autorestapi.get_value("header-text")
+        azure_arm = self.options.get("azure-arm", False)
+        license_header = self.options["header-text"]
         if license_header:
             license_header = license_header.replace("\n", "\n# ")
             license_header = (
@@ -172,83 +172,46 @@ class CodeGenerator(Plugin):
             )
             license_header += "\n# --------------------------------------------------------------------------"
 
-        low_level_client = cast(
-            bool, self._autorestapi.get_boolean_value("low-level-client", False)
-        )
-        version_tolerant = cast(
-            bool, self._autorestapi.get_boolean_value("version-tolerant")
-        )
-        show_operations = self._autorestapi.get_boolean_value(
-            "show-operations", not low_level_client
-        )
+        low_level_client = cast(bool, self.options.get("low-level-client", False))
+        version_tolerant = cast(bool, self.options.get("version-tolerant", True))
+        show_operations = self.options.get("show-operations", not low_level_client)
         models_mode_default = (
             "none" if low_level_client or version_tolerant else "msrest"
         )
-        if self._autorestapi.get_boolean_value("python3-only") is False:
-            _LOGGER.warning(
-                "You have passed in --python3-only=False. We have force overriden "
-                "this to True."
-            )
-        if self._autorestapi.get_boolean_value("add-python3-operation-files"):
-            _LOGGER.warning(
-                "You have passed in --add-python3-operation-files. "
-                "This flag no longer has an effect bc all SDKs are now Python3 only."
-            )
-        if self._autorestapi.get_boolean_value("reformat-next-link"):
-            _LOGGER.warning(
-                "You have passed in --reformat-next-link. We have force overriden "
-                "this to False because we no longer reformat initial query parameters into next "
-                "calls unless explicitly defined in the service definition."
-            )
 
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
-            "head_as_boolean": self._autorestapi.get_boolean_value(
-                "head-as-boolean", False
-            ),
+            "head_as_boolean": self.options.get("head-as-boolean", True),
             "license_header": license_header,
-            "keep_version_file": self._autorestapi.get_boolean_value(
-                "keep-version-file", False
-            ),
-            "no_async": self._autorestapi.get_boolean_value("no-async", False),
-            "no_namespace_folders": self._autorestapi.get_boolean_value(
-                "no-namespace-folders", False
-            ),
-            "basic_setup_py": self._autorestapi.get_boolean_value(
-                "basic-setup-py", False
-            ),
-            "package_name": self._autorestapi.get_value("package-name"),
-            "package_version": self._autorestapi.get_value("package-version"),
-            "client_side_validation": self._autorestapi.get_boolean_value(
-                "client-side-validation", False
-            ),
-            "tracing": self._autorestapi.get_boolean_value("trace", show_operations),
-            "multiapi": self._autorestapi.get_boolean_value("multiapi", False),
-            "polymorphic_examples": self._autorestapi.get_value("polymorphic-examples")
-            or 5,
-            "models_mode": (
-                self._autorestapi.get_value("models-mode") or models_mode_default
-            ).lower(),
-            "builders_visibility": self._autorestapi.get_value("builders-visibility"),
+            "keep_version_file": self.options.get("keep-version-file", False),
+            "no_async": self.options.get("no-async", False),
+            "no_namespace_folders": self.options.get("no-namespace-folders", False),
+            "basic_setup_py": self.options.get("basic-setup-py", False),
+            "package_name": self.options.get("package-name"),
+            "package_version": self.options.get("package-version"),
+            "client_side_validation": self.options.get("client-side-validation", False),
+            "tracing": self.options.get("tracing", show_operations),
+            "multiapi": self.options.get("multiapi", False),
+            "polymorphic_examples": self.options.get("polymorphic-examples", 5),
+            "models_mode": self.options.get("models-mode", models_mode_default).lower(),
+            "builders_visibility": self.options.get("builders-visibility"),
             "show_operations": show_operations,
-            "show_send_request": self._autorestapi.get_boolean_value(
+            "show_send_request": self.options.get(
                 "show-send-request", low_level_client or version_tolerant
             ),
-            "only_path_and_body_params_positional": self._autorestapi.get_boolean_value(
+            "only_path_and_body_params_positional": self.options.get(
                 "only-path-and-body-params-positional",
                 low_level_client or version_tolerant,
             ),
             "version_tolerant": version_tolerant,
             "low_level_client": low_level_client,
-            "combine_operation_files": self._autorestapi.get_boolean_value(
+            "combine_operation_files": self.options.get(
                 "combine-operation-files", version_tolerant
             ),
-            "package_mode": self._autorestapi.get_value("package-mode"),
-            "package_pprint_name": self._autorestapi.get_value("package-pprint-name"),
-            "package_configuration": self._autorestapi.get_value(
-                "package-configuration"
-            ),
-            "default_optional_constants_to_none": self._autorestapi.get_boolean_value(
+            "package_mode": self.options.get("package-mode"),
+            "package_pprint_name": self.options.get("package-pprint-name"),
+            "package_configuration": self.options.get("package-configuration"),
+            "default_optional_constants_to_none": self.options.get(
                 "default-optional-constants-to-none",
                 low_level_client or version_tolerant,
             ),
@@ -272,8 +235,102 @@ class CodeGenerator(Plugin):
             options["head_as_boolean"] = True
         return options
 
+    def get_yaml(self) -> Dict[str, Any]:
+        # cadl should call this one
+        raise NotImplementedError()
+
+    @staticmethod
+    def get_serializer(code_model: CodeModel):
+        return JinjaSerializer(code_model)
+
     def process(self) -> bool:
         # List the input file, should be only one
+
+        options = self._build_code_model_options()
+        yaml_data = self.get_yaml()
+
+        if options["azure_arm"]:
+            self.remove_cloud_errors(yaml_data)
+
+        code_model = self._create_code_model(yaml_data=yaml_data, options=options)
+
+        serializer = self.get_serializer(code_model)
+        serializer.serialize()
+
+        return True
+
+
+class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
+    def get_options(self) -> Dict[str, Any]:
+        if self._autorestapi.get_boolean_value("python3-only") is False:
+            _LOGGER.warning(
+                "You have passed in --python3-only=False. We have force overriden "
+                "this to True."
+            )
+        if self._autorestapi.get_boolean_value("add-python3-operation-files"):
+            _LOGGER.warning(
+                "You have passed in --add-python3-operation-files. "
+                "This flag no longer has an effect bc all SDKs are now Python3 only."
+            )
+        if self._autorestapi.get_boolean_value("reformat-next-link"):
+            _LOGGER.warning(
+                "You have passed in --reformat-next-link. We have force overriden "
+                "this to False because we no longer reformat initial query parameters into next "
+                "calls unless explicitly defined in the service definition."
+            )
+        options = {
+            "azure-arm": self._autorestapi.get_boolean_value("azure-arm"),
+            "header-text": self._autorestapi.get_value("header-text"),
+            "low-level-client": self._autorestapi.get_boolean_value(
+                "low-level-client", False
+            ),
+            "version-tolerant": self._autorestapi.get_boolean_value(
+                "version-tolerant", True
+            ),
+            "show-operations": self._autorestapi.get_boolean_value("show-operations"),
+            "python3-only": self._autorestapi.get_boolean_value("python3-only"),
+            "head-as-boolean": self._autorestapi.get_boolean_value(
+                "head-as-boolean", False
+            ),
+            "keep-version-file": self._autorestapi.get_boolean_value(
+                "keep-version-file"
+            ),
+            "no-async": self._autorestapi.get_boolean_value("no-async"),
+            "no-namespace-folders": self._autorestapi.get_boolean_value(
+                "no-namespace-folders"
+            ),
+            "basic-setup-py": self._autorestapi.get_boolean_value("basic-setup-py"),
+            "package-name": self._autorestapi.get_value("package-name"),
+            "package-version": self._autorestapi.get_value("package-version"),
+            "client-side-validation": self._autorestapi.get_boolean_value(
+                "client-side-validation"
+            ),
+            "tracing": self._autorestapi.get_boolean_value("trace"),
+            "multiapi": self._autorestapi.get_boolean_value("multiapi", False),
+            "polymorphic-examples": self._autorestapi.get_value("polymorphic-examples"),
+            "models-mode": self._autorestapi.get_value("models-mode"),
+            "builders-visibility": self._autorestapi.get_value("builders-visibility"),
+            "show-send-request": self._autorestapi.get_boolean_value(
+                "show-send-request"
+            ),
+            "only-path-and-body-params-positional": self._autorestapi.get_boolean_value(
+                "only-path-and-body-params-positional"
+            ),
+            "combine-operation-files": self._autorestapi.get_boolean_value(
+                "combine-operation-files"
+            ),
+            "package-mode": self._autorestapi.get_value("package-mode"),
+            "package-pprint-name": self._autorestapi.get_value("package-pprint-name"),
+            "package-configuration": self._autorestapi.get_value(
+                "package-configuration"
+            ),
+            "default-optional-constants-to-none": self._autorestapi.get_boolean_value(
+                "default-optional-constants-to-none"
+            ),
+        }
+        return {k: v for k, v in options.items() if v is not None}
+
+    def get_yaml(self) -> Dict[str, Any]:
         inputs = self._autorestapi.list_inputs()
         _LOGGER.debug("Possible Inputs: %s", inputs)
         if "code-model-v4-no-tags.yaml" not in inputs:
@@ -291,19 +348,10 @@ class CodeGenerator(Plugin):
             file_content = self._autorestapi.read_file("code-model-v4-no-tags.yaml")
 
         # Parse the received YAML
-        yaml_data = yaml.safe_load(file_content)
+        return yaml.safe_load(file_content)
 
-        options = self._build_code_model_options()
-
-        if options["azure_arm"]:
-            self.remove_cloud_errors(yaml_data)
-
-        code_model = self._create_code_model(yaml_data=yaml_data, options=options)
-
-        serializer = JinjaSerializer(self._autorestapi, code_model)
-        serializer.serialize()
-
-        return True
+    def get_serializer(self, code_model: CodeModel):  # type: ignore
+        return JinjaSerializerAutorest(self._autorestapi, code_model)
 
 
 def main(yaml_model_file: str) -> None:
@@ -311,7 +359,7 @@ def main(yaml_model_file: str) -> None:
         LocalAutorestAPI,
     )
 
-    code_generator = CodeGenerator(
+    code_generator = CodeGeneratorAutorest(
         autorestapi=LocalAutorestAPI(reachable_files=[yaml_model_file])
     )
     if not code_generator.process():

package/autorest/codegen/serializers/__init__.py

@@ -9,6 +9,7 @@ from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 from autorest.codegen.models.operation_group import OperationGroup
 from autorest.codegen.models.request_builder import OverloadedRequestBuilder
 
+from ... import ReaderAndWriter, ReaderAndWriterAutorest
 from ...jsonrpc import AutorestAPI
 from ..models import CodeModel, OperationGroup, RequestBuilder
 from ..models import TokenCredentialType
@@ -38,9 +39,9 @@ _PACKAGE_FILES = [
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
 
 
-class JinjaSerializer:
-    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
-        self._autorestapi = autorestapi
+class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+    def __init__(self, code_model: CodeModel, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self.code_model = code_model
 
     @property
@@ -129,10 +130,10 @@ class JinjaSerializer:
             )
         if not self.code_model.options["models_mode"]:
             # keep models file if users ended up just writing a models file
-            if self._autorestapi.read_file(namespace_path / Path("models.py")):
-                self._autorestapi.write_file(
+            if self.read_file(namespace_path / Path("models.py")):
+                self.write_file(
                     namespace_path / Path("models.py"),
-                    self._autorestapi.read_file(namespace_path / Path("models.py")),
+                    self.read_file(namespace_path / Path("models.py")),
                 )
 
         if self.code_model.options["package_mode"]:
@@ -143,13 +144,10 @@ class JinjaSerializer:
             for template_name in package_files:
                 file = template_name.replace(".jinja2", "")
                 output_name = out_path / file
-                if (
-                    not self._autorestapi.read_file(output_name)
-                    or file in _REGENERATE_FILES
-                ):
+                if not self.read_file(output_name) or file in _REGENERATE_FILES:
                     template = env.get_template(template_name)
                     render_result = template.render(**kwargs)
-                    self._autorestapi.write_file(output_name, render_result)
+                    self.write_file(output_name, render_result)
 
         def _prepare_params() -> Dict[Any, Any]:
             package_parts = package_name.split("-")[:-1]
@@ -207,12 +205,10 @@ class JinjaSerializer:
             _serialize_and_write_package_files_proc(**params)
 
     def _keep_patch_file(self, path_file: Path, env: Environment):
-        if self._autorestapi.read_file(path_file):
-            self._autorestapi.write_file(
-                path_file, self._autorestapi.read_file(path_file)
-            )
+        if self.read_file(path_file):
+            self.write_file(path_file, self.read_file(path_file))
         else:
-            self._autorestapi.write_file(
+            self.write_file(
                 path_file,
                 PatchSerializer(env=env, code_model=self.code_model).serialize(),
             )
@@ -223,16 +219,16 @@ class JinjaSerializer:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if self.code_model.model_types:
-            self._autorestapi.write_file(
+            self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
                 ModelSerializer(code_model=self.code_model, env=env).serialize(),
             )
         if self.code_model.enums:
-            self._autorestapi.write_file(
+            self.write_file(
                 models_path / Path(f"{self.code_model.enums_filename}.py"),
                 EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
-        self._autorestapi.write_file(
+        self.write_file(
             models_path / Path("__init__.py"),
             ModelInitSerializer(code_model=self.code_model, env=env).serialize(),
         )
@@ -253,7 +249,7 @@ class JinjaSerializer:
                 env, rest_path, request_builders
             )
         if not "" in group_names:
-            self._autorestapi.write_file(
+            self.write_file(
                 rest_path / Path("__init__.py"),
                 self.code_model.options["license_header"],
             )
@@ -267,7 +263,7 @@ class JinjaSerializer:
         group_name = request_builders[0].group_name
         output_path = rest_path / Path(group_name) if group_name else rest_path
         # write generic request builders file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("_request_builders.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
@@ -277,7 +273,7 @@ class JinjaSerializer:
         )
 
         # write rest init file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("__init__.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
@@ -300,7 +296,7 @@ class JinjaSerializer:
             async_mode=False,
             operation_group=operation_group,
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path(f"{filename}.py"),
@@ -315,7 +311,7 @@ class JinjaSerializer:
                 async_mode=True,
                 operation_group=operation_group,
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 (
                     namespace_path
                     / Path("aio")
@@ -332,7 +328,7 @@ class JinjaSerializer:
         operations_init_serializer = OperationsInitSerializer(
             code_model=self.code_model, env=env, async_mode=False
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path("__init__.py"),
@@ -344,7 +340,7 @@ class JinjaSerializer:
             operations_async_init_serializer = OperationsInitSerializer(
                 code_model=self.code_model, env=env, async_mode=True
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path
                 / Path("aio")
                 / Path(self.code_model.operations_folder_name)
@@ -369,12 +365,10 @@ class JinjaSerializer:
         self, namespace_path: Path, general_serializer: GeneralSerializer
     ):
         def _read_version_file(original_version_file_name: str) -> str:
-            return self._autorestapi.read_file(
-                namespace_path / original_version_file_name
-            )
+            return self.read_file(namespace_path / original_version_file_name)
 
         def _write_version_file(original_version_file_name: str) -> None:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 _read_version_file(original_version_file_name),
             )
@@ -385,7 +379,7 @@ class JinjaSerializer:
         elif keep_version_file and _read_version_file("version.py"):
             _write_version_file(original_version_file_name="version.py")
         elif self.code_model.options["package_version"]:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
             )
@@ -397,14 +391,14 @@ class JinjaSerializer:
             code_model=self.code_model, env=env, async_mode=False
         )
 
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("__init__.py"),
             general_serializer.serialize_init_file(),
         )
         p = namespace_path.parent
         while p != Path("."):
             # write pkgutil init file
-            self._autorestapi.write_file(
+            self.write_file(
                 p / Path("__init__.py"),
                 general_serializer.serialize_pkgutil_init_file(),
             )
@@ -412,13 +406,13 @@ class JinjaSerializer:
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path(f"{self.code_model.client.filename}.py"),
                 general_serializer.serialize_service_client_file(),
             )
 
         if self.code_model.need_vendored_code(async_mode=False):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_vendor.py"),
                 general_serializer.serialize_vendor_file(),
             )
@@ -426,31 +420,27 @@ class JinjaSerializer:
         self._serialize_and_write_version_file(namespace_path, general_serializer)
 
         # write the empty py.typed file
-        self._autorestapi.write_file(
-            namespace_path / Path("py.typed"), "# Marker file for PEP 561."
-        )
+        self.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
 
         if (
             not self.code_model.options["client_side_validation"]
             and not self.code_model.options["multiapi"]
         ):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_serialization.py"),
                 general_serializer.serialize_serialization_file(),
             )
 
         # Write the config file
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_configuration.py"),
                 general_serializer.serialize_config_file(),
             )
 
         # Write the setup file
         if self.code_model.options["basic_setup_py"]:
-            self._autorestapi.write_file(
-                Path("setup.py"), general_serializer.serialize_setup_file()
-            )
+            self.write_file(Path("setup.py"), general_serializer.serialize_setup_file())
 
     def _serialize_and_write_aio_top_level_folder(
         self, env: Environment, namespace_path: Path
@@ -462,24 +452,24 @@ class JinjaSerializer:
         aio_path = namespace_path / Path("aio")
 
         # Write the __init__ file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("__init__.py"), aio_general_serializer.serialize_init_file()
         )
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path(f"{self.code_model.client.filename}.py"),
                 aio_general_serializer.serialize_service_client_file(),
             )
 
         # Write the config file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("_configuration.py"),
             aio_general_serializer.serialize_config_file(),
         )
         if self.code_model.need_vendored_code(async_mode=True):
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path("_vendor.py"),
                 aio_general_serializer.serialize_vendor_file(),
             )
@@ -488,6 +478,11 @@ class JinjaSerializer:
         self, env: Environment, namespace_path: Path
     ) -> None:
         metadata_serializer = MetadataSerializer(self.code_model, env)
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
+
+
+class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
+    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
+        super().__init__(autorestapi=autorestapi, code_model=code_model)

package/autorest/codegen/serializers/client_serializer.py

@@ -16,6 +16,11 @@ class ClientSerializer:
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
+        pylint_disable = ""
+        if not self.code_model.client.parameters.credential:
+            pylint_disable = (
+                "  # pylint: disable=missing-client-constructor-parameter-credential"
+            )
         return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name="__init__",
@@ -23,6 +28,7 @@ class ClientSerializer:
             method_param_signatures=self.code_model.client.parameters.method_signature(
                 async_mode
             ),
+            pylint_disable=pylint_disable,
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:

package/autorest/jsonrpc/server.py

@@ -43,24 +43,24 @@ def Process(plugin_name: str, session_id: str) -> bool:
             session_id,
         )
         if plugin_name == "m2r":
-            from ..m2r import M2R as PluginToLoad
+            from ..m2r import M2RAutorest as PluginToLoad
         elif plugin_name == "preprocess":
-            from ..preprocess import PreProcessPlugin as PluginToLoad  # type: ignore
+            from ..preprocess import PreProcessPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "m4reformatter":
             from ..m4reformatter import M4Reformatter as PluginToLoad  # type: ignore
         elif plugin_name == "codegen":
-            from ..codegen import CodeGenerator as PluginToLoad  # type: ignore
+            from ..codegen import CodeGeneratorAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "postprocess":
-            from ..postprocess import PostProcessPlugin as PluginToLoad  # type: ignore
+            from ..postprocess import PostProcessPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "black":
-            from ..black import BlackScriptPlugin as PluginToLoad  # type: ignore
+            from ..black import BlackScriptPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "multiapiscript":
-            from ..multiapi import MultiApiScriptPlugin as PluginToLoad  # type: ignore
+            from ..multiapi import MultiApiScriptPluginAutorest as PluginToLoad  # type: ignore
         else:
             _LOGGER.fatal("Unknown plugin name %s", plugin_name)
             raise RuntimeError(f"Unknown plugin name {plugin_name}")
 
-        plugin = PluginToLoad(stdstream_connection)
+        plugin = PluginToLoad(autorestapi=stdstream_connection)
 
         try:
             _LOGGER.debug("Starting plugin %s", PluginToLoad.__name__)

package/autorest/m2r/__init__.py

@@ -10,7 +10,7 @@ from typing import Any, Dict, Set
 
 import m2r
 
-from .. import YamlUpdatePlugin
+from .. import YamlUpdatePluginAutorest, YamlUpdatePlugin
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -26,7 +26,7 @@ class AutorestRender(m2r.RestRenderer):
         return f":code:`{html}`"
 
 
-class M2R(YamlUpdatePlugin):
+class M2R(YamlUpdatePlugin):  # pylint: disable=abstract-method
     """A plugin to convert any description and summary from MD to RST."""
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
@@ -58,3 +58,8 @@ class M2R(YamlUpdatePlugin):
             return m2r.convert(string_to_convert, renderer=AutorestRender()).strip()
         except Exception:  # pylint: disable=broad-except
             return string_to_convert
+
+
+class M2RAutorest(YamlUpdatePluginAutorest, M2R):
+    def get_options(self) -> Dict[str, Any]:
+        return {}

package/autorest/m4reformatter/__init__.py

@@ -11,7 +11,7 @@ import copy
 import logging
 from typing import Callable, Dict, Any, Iterable, List, Optional, Set
 
-from .. import YamlUpdatePlugin
+from .. import YamlUpdatePluginAutorest
 
 JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 ORIGINAL_ID_TO_UPDATED_TYPE: Dict[int, Dict[str, Any]] = {}
@@ -431,7 +431,9 @@ def update_client_url(yaml_data: Dict[str, Any]) -> str:
     ]["uri"]
 
 
-class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-methods
+class M4Reformatter(
+    YamlUpdatePluginAutorest
+):  # pylint: disable=too-many-public-methods
     """Add Python naming information."""
 
     @property

package/autorest/multiapi/__init__.py

@@ -11,41 +11,62 @@ import shutil
 from collections import defaultdict
 from pathlib import Path
 from typing import Dict, List, Optional, cast, Any
-from .serializers import MultiAPISerializer
+
+from .serializers import MultiAPISerializer, MultiAPISerializerAutorest
 from .models import CodeModel
 from .utils import _get_default_api_version_from_list
-from ..jsonrpc import AutorestAPI
 
-from .. import Plugin
+from .. import Plugin, PluginAutorest, ReaderAndWriter, ReaderAndWriterAutorest
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class MultiApiScriptPlugin(Plugin):
+class MultiApiScriptPlugin(Plugin):  # pylint: disable=abstract-method
     def process(self) -> bool:
-        input_package_name: str = self._autorestapi.get_value("package-name")
-        output_folder: str = self._autorestapi.get_value("output-folder")
-        user_specified_default_api: str = self._autorestapi.get_value("default-api")
-        no_async = self._autorestapi.get_boolean_value("no-async")
-        generator = MultiAPI(
-            input_package_name,
-            output_folder,
-            self._autorestapi,
-            no_async,
-            user_specified_default_api,
+        return self.generator.process()
+
+    @property
+    def generator(self) -> "MultiAPI":
+        return MultiAPI(
+            input_package_name=self.options.get("package-name"),
+            output_folder=self.options["output-folder"],
+            user_specified_default_api=self.options.get("default-api"),
+            no_async=self.options.get("no-async", False),
         )
-        return generator.process()
 
 
-class MultiAPI:
+class MultiApiScriptPluginAutorest(MultiApiScriptPlugin, PluginAutorest):
+    @property
+    def generator(self) -> "MultiAPI":
+        return MultiAPIAutorest(
+            autorestapi=self._autorestapi,
+            input_package_name=self.options.get("package-name"),
+            output_folder=self.options["output-folder"],
+            user_specified_default_api=self.options.get("default-api"),
+            no_async=self.options.get("no-async", False),
+        )
+
+    def get_options(self) -> Dict[str, Any]:
+        options = {
+            "package-name": self._autorestapi.get_value("package-name"),
+            "output-folder": self._autorestapi.get_value("output-folder"),
+            "default-api": self._autorestapi.get_value("default-api"),
+            "no-async": self._autorestapi.get_value("no-async"),
+        }
+        return {k: v for k, v in options.items() if v is not None}
+
+
+class MultiAPI(ReaderAndWriter):  # pylint: disable=abstract-method
     def __init__(
         self,
-        input_package_name: str,
+        *,
+        input_package_name: Optional[str] = None,
         output_folder: str,
-        autorestapi: AutorestAPI,
         no_async: Optional[bool] = False,
         user_specified_default_api: Optional[str] = None,
+        **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         if input_package_name is None:
             raise ValueError(
                 "package-name is required, either provide it as args or check your readme configuration"
@@ -57,7 +78,6 @@ class MultiAPI:
         _LOGGER.debug("Received output-folder %s", output_folder)
         self.output_package_name: str = ""
         self.no_async = no_async
-        self._autorestapi = autorestapi
         self.user_specified_default_api = user_specified_default_api
 
     @property
@@ -77,9 +97,7 @@ 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.read_file(path_to_default_version / "_metadata.json"))
 
     @property
     def module_name(self) -> str:
@@ -120,9 +138,7 @@ class MultiAPI:
     @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.read_file(version_path / "_metadata.json"))
             for version_path in self.paths_to_versions
         }
 
@@ -130,9 +146,7 @@ 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")
-            )
+            metadata_json = json.loads(self.read_file(version_path / "_metadata.json"))
             version = metadata_json["chosen_version"]
             total_api_version_list = metadata_json["total_api_version_list"]
             if not version:
@@ -145,6 +159,10 @@ class MultiAPI:
             mod_to_api_version[version_path.name] = version
         return mod_to_api_version
 
+    @property
+    def serializer(self) -> MultiAPISerializer:
+        return MultiAPISerializer()
+
     def process(self) -> bool:
         _LOGGER.info("Generating multiapi client")
 
@@ -163,8 +181,17 @@ class MultiAPI:
         shutil.rmtree(str(self.output_folder / "operations"), ignore_errors=True)
         shutil.rmtree(str(self.output_folder / "models"), ignore_errors=True)
 
-        multiapi_serializer = MultiAPISerializer(self._autorestapi)
+        multiapi_serializer = self.serializer
         multiapi_serializer.serialize(code_model, self.no_async)
 
         _LOGGER.info("Done!")
         return True
+
+
+class MultiAPIAutorest(MultiAPI, ReaderAndWriterAutorest):
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+    @property
+    def serializer(self) -> MultiAPISerializer:
+        return MultiAPISerializerAutorest(self._autorestapi)

package/autorest/multiapi/serializers/__init__.py

@@ -11,6 +11,7 @@ from .import_serializer import FileImportSerializer
 
 from ...jsonrpc import AutorestAPI
 from ..models import CodeModel
+from ... import ReaderAndWriter, ReaderAndWriterAutorest
 
 __all__ = [
     "MultiAPISerializer",
@@ -32,9 +33,9 @@ def _get_file_path(filename: str, async_mode: bool) -> Path:
     return Path(filename)
 
 
-class MultiAPISerializer(object):
-    def __init__(self, autorestapi: AutorestAPI) -> None:
-        self._autorestapi = autorestapi
+class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self.env = Environment(
             loader=PackageLoader("autorest.multiapi", "templates"),
             keep_trailing_newline=True,
@@ -52,20 +53,20 @@ class MultiAPISerializer(object):
             )
 
         # serialize init file
-        self._autorestapi.write_file(
+        self.write_file(
             _get_file_path("__init__", async_mode), _render_template("init")
         )
 
         # serialize service client file
         imports = FileImportSerializer(code_model.client.imports(async_mode))
-        self._autorestapi.write_file(
+        self.write_file(
             _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))
-        self._autorestapi.write_file(
+        self.write_file(
             _get_file_path("_configuration", async_mode),
             _render_template("config", imports=imports),
         )
@@ -75,26 +76,22 @@ class MultiAPISerializer(object):
             imports = FileImportSerializer(
                 code_model.operation_mixin_group.imports(async_mode)
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 _get_file_path("_operations_mixin", async_mode),
                 _render_template("operations_mixin", imports=imports),
             )
 
         # serialize models
-        self._autorestapi.write_file(Path("models.py"), _render_template("models"))
+        self.write_file(Path("models.py"), _render_template("models"))
 
     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")
-            )
-        elif self._autorestapi.read_file("version.py"):
-            self._autorestapi.write_file(
-                "_version.py", self._autorestapi.read_file("version.py")
-            )
+        if self.read_file("_version.py"):
+            self.write_file("_version.py", self.read_file("_version.py"))
+        elif self.read_file("version.py"):
+            self.write_file("_version.py", self.read_file("version.py"))
         else:
             template = self.env.get_template("multiapi_version.py.jinja2")
-            self._autorestapi.write_file(Path("_version.py"), template.render())
+            self.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)
@@ -104,12 +101,10 @@ class MultiAPISerializer(object):
         self._serialize_version_file()
 
         # don't erase patch file
-        if self._autorestapi.read_file("_patch.py"):
-            self._autorestapi.write_file(
-                "_patch.py", self._autorestapi.read_file("_patch.py")
-            )
+        if self.read_file("_patch.py"):
+            self.write_file("_patch.py", self.read_file("_patch.py"))
 
-        self._autorestapi.write_file(Path("py.typed"), "# Marker file for PEP 561.")
+        self.write_file(Path("py.typed"), "# Marker file for PEP 561.")
 
         if not code_model.client.client_side_validation:
             codegen_env = Environment(
@@ -120,7 +115,12 @@ class MultiAPISerializer(object):
                 trim_blocks=True,
                 lstrip_blocks=True,
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 Path("_serialization.py"),
                 codegen_env.get_template("serialization.py.jinja2").render(),
             )
+
+
+class MultiAPISerializerAutorest(MultiAPISerializer, ReaderAndWriterAutorest):
+    def __init__(self, autorestapi: AutorestAPI) -> None:
+        super().__init__(autorestapi=autorestapi)

package/autorest/multiapi/serializers/multiapi_serializer.py

@@ -8,19 +8,20 @@ from pathlib import Path
 from jinja2 import Environment, PackageLoader
 
 from ...jsonrpc import AutorestAPI
+from ... import ReaderAndWriter, ReaderAndWriterAutorest
 
 
-class MultiAPISerializer:
+class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
     def __init__(
         self,
         conf: Dict[str, Any],
         async_mode: bool,
-        autorestapi: AutorestAPI,
         service_client_filename: str,
+        **kwargs: Any
     ):
+        super().__init__(**kwargs)
         self.conf = conf
         self.async_mode = async_mode
-        self._autorestapi = autorestapi
         self.service_client_filename = service_client_filename
         self.env = Environment(
             loader=PackageLoader("autorest.multiapi", "templates"),
@@ -37,53 +38,43 @@ class MultiAPISerializer:
         return Path(filename)
 
     def serialize(self):
-        self._autorestapi.write_file(
+        self.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.write_file(
             self._get_file_path(service_client_filename_with_py_extension),
             self.serialize_multiapi_client(),
         )
 
         configuration_filename = "_configuration.py"
-        self._autorestapi.write_file(
+        self.write_file(
             self._get_file_path(configuration_filename),
             self.serialize_multiapi_config(),
         )
 
         operation_mixins_filename = "_operations_mixin.py"
         if self.conf["mixin_operations"]:
-            self._autorestapi.write_file(
+            self.write_file(
                 self._get_file_path(operation_mixins_filename),
                 self.serialize_multiapi_operation_mixins(),
             )
 
-        if self._autorestapi.read_file("_version.py"):
-            self._autorestapi.write_file(
-                "_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")
-            )
+        if self.read_file("_version.py"):
+            self.write_file("_version.py", self.read_file("_version.py"))
+        elif self.read_file("version.py"):
+            self.write_file("_version.py", self.read_file("version.py"))
         else:
-            self._autorestapi.write_file(
-                Path("_version.py"), self.serialize_multiapi_version()
-            )
+            self.write_file(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")
-            )
+        if self.read_file("_patch.py"):
+            self.write_file("_patch.py", self.read_file("_patch.py"))
 
-        self._autorestapi.write_file(
-            Path("models.py"), self.serialize_multiapi_models()
-        )
+        self.write_file(Path("models.py"), self.serialize_multiapi_models())
 
-        self._autorestapi.write_file(Path("py.typed"), "# Marker file for PEP 561.")
+        self.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")
@@ -112,3 +103,19 @@ class MultiAPISerializer:
     def serialize_multiapi_operation_mixins(self) -> str:
         template = self.env.get_template("multiapi_operations_mixin.py.jinja2")
         return template.render(**self.conf, async_mode=self.async_mode)
+
+
+class MultiAPISerializerAutorest(MultiAPISerializer, ReaderAndWriterAutorest):
+    def __init__(
+        self,
+        autorestapi: AutorestAPI,
+        conf: Dict[str, Any],
+        async_mode: bool,
+        service_client_filename: str,
+    ):
+        super().__init__(
+            autorestapi=autorestapi,
+            conf=conf,
+            async_mode=async_mode,
+            service_client_filename=service_client_filename,
+        )

package/autorest/postprocess/__init__.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Tuple
+from typing import Tuple, Any, Dict
 from pathlib import Path
 import os
 import shutil
@@ -11,7 +11,7 @@ from venv import EnvBuilder
 import black
 from .venvtools import ExtendedEnvBuilder, python_run
 
-from .. import Plugin
+from .. import Plugin, PluginAutorest
 
 _BLACK_MODE = black.Mode()
 _BLACK_MODE.line_length = 120
@@ -29,10 +29,10 @@ def format_file(file: Path, file_content: str) -> str:
     return file_content
 
 
-class PostProcessPlugin(Plugin):
-    def __init__(self, autorestapi):
-        super().__init__(autorestapi)
-        output_folder_uri = self._autorestapi.get_value("outputFolderUri")
+class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        output_folder_uri = self.options["outputFolderUri"]
         if output_folder_uri.startswith("file:"):
             output_folder_uri = output_folder_uri[5:]
         if os.name == "nt" and output_folder_uri.startswith("///"):
@@ -65,9 +65,7 @@ class PostProcessPlugin(Plugin):
         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)
-            )
+            file_content = self.read_file(init_file.relative_to(self.output_folder))
             if not "pkgutil" in file_content:
                 return dir, namespace
         except StopIteration:
@@ -157,7 +155,7 @@ class PostProcessPlugin(Plugin):
             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)
+        file_content = self.read_file(file)
         added_objs = []
         for obj in customized_objects:
             if f" import {obj}\n" in file_content:
@@ -199,4 +197,9 @@ class PostProcessPlugin(Plugin):
                 "__all__ = [", f"__all__ = [\n{added_objs_all}", 1
             )
         formatted_file = format_file(file, file_content)
-        self._autorestapi.write_file(file, formatted_file)
+        self.write_file(file, formatted_file)
+
+
+class PostProcessPluginAutorest(PostProcessPlugin, PluginAutorest):
+    def get_options(self) -> Dict[str, Any]:
+        return {"outputFolderUri": self._autorestapi.get_value("outputFolderUri")}

package/autorest/preprocess/__init__.py

@@ -9,7 +9,7 @@ from typing import Callable, Dict, Any, List, Optional
 from .helpers import to_snake_case, pad_reserved_words, add_redefined_builtin_info
 from .python_mappings import PadType
 
-from .. import YamlUpdatePlugin
+from .. import YamlUpdatePlugin, PluginAutorest
 
 
 def _remove_paging_maxpagesize(yaml_data: Dict[str, Any]) -> None:
@@ -92,12 +92,12 @@ def update_paging_response(yaml_data: Dict[str, Any]) -> None:
     )
 
 
-class PreProcessPlugin(YamlUpdatePlugin):
+class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     """Add Python naming information."""
 
     @property
     def version_tolerant(self) -> bool:
-        return bool(self._autorestapi.get_boolean_value("version-tolerant", True))
+        return self.options.get("version-tolerant", True)
 
     def get_operation_updater(
         self, yaml_data: Dict[str, Any]
@@ -133,7 +133,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
             response["discriminator"] = "operation"
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
-        azure_arm = self._autorestapi.get_boolean_value("azure-arm", False)
+        azure_arm = self.options.get("azure-arm", False)
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lro"
             response["pollerSync"] = (
@@ -228,3 +228,12 @@ class PreProcessPlugin(YamlUpdatePlugin):
         update_client(yaml_data["client"])
         update_types(yaml_data["types"])
         self.update_operation_groups(yaml_data)
+
+
+class PreProcessPluginAutorest(PluginAutorest, PreProcessPlugin):
+    def get_options(self) -> Dict[str, Any]:
+        options = {
+            "version-tolerant": self._autorestapi.get_boolean_value("version-tolerant"),
+            "azure-arm": self._autorestapi.get_boolean_value("azure-arm"),
+        }
+        return {k: v for k, v in options.items() if v is not None}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "6.0.0",
+    "version": "6.0.1",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",