@autorest/python 6.14.3 → 6.16.0

package/{autorest → generator/pygen}/codegen/models/client.py

@@ -18,6 +18,7 @@ from .request_builder import (
 from .parameter import Parameter, ParameterMethodLocation
 from .lro_operation import LROOperation
 from .lro_paging_operation import LROPagingOperation
+from ...utils import extract_original_name
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -92,7 +93,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 if operation_yaml.get("isLroInitialOperation"):
                     # we want to change the name
                     request_builder.name = request_builder.get_name(
-                        request_builder.yaml_data["name"][1 : -len("_initial")],
+                        extract_original_name(request_builder.yaml_data["name"]),
                         request_builder.yaml_data,
                         request_builder.code_model,
                         request_builder.client,

package/{autorest → generator/pygen}/codegen/models/combined_type.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, Type, Tuple, Union
 import re
-from autorest.codegen.models.imports import FileImport, ImportType, TypingSection
+from .imports import FileImport, ImportType, TypingSection
 from .base import BaseType
 from .model_type import ModelType
 

package/{autorest → generator/pygen}/codegen/models/model_type.py

@@ -7,7 +7,7 @@ from enum import Enum
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 import sys
-from autorest.codegen.models.utils import (
+from .utils import (
     add_to_pylint_disable,
     NAME_LENGTH_LIMIT,
 )

package/{autorest → generator/pygen}/codegen/models/operation.py

@@ -343,6 +343,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             "ResourceExistsError",
             "ResourceNotModifiedError",
         ]
+        if self.stream_value:
+            errors.extend(["StreamConsumedError", "StreamClosedError"])
         for error in errors:
             file_import.add_submodule_import("exceptions", error, ImportType.SDKCORE)
         if self.code_model.options["azure_arm"]:

package/{autorest → generator/pygen}/codegen/models/operation_group.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from typing import Dict, List, Any, TYPE_CHECKING
 
-from autorest.codegen.models.utils import OrderedSet
+from .utils import OrderedSet
 
 from .base import BaseModel
 from .operation import get_operation

package/{autorest → generator/pygen}/codegen/serializers/__init__.py

@@ -8,8 +8,7 @@ from typing import List, Optional, Any, Union
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
-from ... import ReaderAndWriter, ReaderAndWriterAutorest
-from ...jsonrpc import AutorestAPI
+from ... import ReaderAndWriter
 from ..models import (
     OperationGroup,
     RequestBuilder,
@@ -29,7 +28,7 @@ from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
 from .test_serializer import TestSerializer, TestGeneralSerializer
 from .types_serializer import TypesSerializer
-from ..._utils import to_snake_case
+from ...utils import to_snake_case
 from .._utils import VALID_PACKAGE_MODE
 from .utils import (
     extract_sample_name,
@@ -132,13 +131,12 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             self.code_model.options["show_operations"]
             and self.code_model.has_operations
             and self.code_model.options["generate_test"]
-            and not self.code_model.options["azure_arm"]
         ):
             self._serialize_and_write_test(env, namespace_path)
 
     def serialize(self) -> None:
         env = Environment(
-            loader=PackageLoader("autorest.codegen", "templates"),
+            loader=PackageLoader("pygen.codegen", "templates"),
             keep_trailing_newline=True,
             line_statement_prefix="##",
             line_comment_prefix="###",
@@ -196,7 +194,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         root_of_sdk = self._package_root_folder(namespace_path)
         if self.code_model.options["package_mode"] in VALID_PACKAGE_MODE:
             env = Environment(
-                loader=PackageLoader("autorest.codegen", "templates/packaging_templates"),
+                loader=PackageLoader("pygen.codegen", "templates/packaging_templates"),
                 undefined=StrictUndefined,
             )
 
@@ -546,16 +544,21 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         out_path = self._package_root_folder(namespace_path) / Path("generated_tests")
         general_serializer = TestGeneralSerializer(code_model=self.code_model, env=env)
         self.write_file(out_path / "conftest.py", general_serializer.serialize_conftest())
-        for is_async in (True, False):
-            async_suffix = "_async" if is_async else ""
-            general_serializer.is_async = is_async
-            self.write_file(
-                out_path / f"testpreparer{async_suffix}.py",
-                general_serializer.serialize_testpreparer(),
-            )
+        if not self.code_model.options["azure_arm"]:
+            for is_async in (True, False):
+                async_suffix = "_async" if is_async else ""
+                general_serializer.is_async = is_async
+                self.write_file(
+                    out_path / f"testpreparer{async_suffix}.py",
+                    general_serializer.serialize_testpreparer(),
+                )
 
         for client in self.code_model.clients:
             for og in client.operation_groups:
+                if self.code_model.options["multiapi"] and any(
+                    o.api_versions[0] != self.code_model.options["default_api_version"] for o in og.operations
+                ):
+                    continue
                 test_serializer = TestSerializer(self.code_model, env, client=client, operation_group=og)
                 for is_async in (True, False):
                     try:
@@ -569,20 +572,3 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                         log_error = f"error happens in test generation for operation group {og.class_name}: {e}"
                         _LOGGER.error(log_error)
         self.code_model.for_test = False
-
-
-class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
-    def __init__(
-        self,
-        autorestapi: AutorestAPI,
-        code_model: CodeModel,
-        *,
-        output_folder: Union[str, Path],
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(
-            autorestapi=autorestapi,
-            code_model=code_model,
-            output_folder=output_folder,
-            **kwargs,
-        )

package/{autorest → generator/pygen}/codegen/serializers/builder_serializer.py

@@ -36,7 +36,7 @@ from ..models import (
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from ..models.parameter_list import ParameterType
 from . import utils
-from ..._utils import JSON_REGEXP
+from ...utils import JSON_REGEXP
 
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
@@ -410,14 +410,19 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # p
         return "response.json()"
 
     @staticmethod
-    def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
+    def declare_non_inputtable_headers_queries(builder: RequestBuilderType) -> List[str]:
         def _get_value(param):
+            declaration = param.get_declaration() if param.constant else None
             if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
                 kwarg_dict = "headers" if param.location == ParameterLocation.HEADER else "params"
-                return f"_{kwarg_dict}.pop('{param.wire_name}', {param.get_declaration()})"
-            return f"{param.get_declaration()}"
+                return f"_{kwarg_dict}.pop('{param.wire_name}', {declaration})"
+            return declaration
 
-        return [f"{p.client_name} = {_get_value(p)}" for p in builder.parameters.constant if not p.in_method_signature]
+        return [
+            f"{p.client_name} = {_get_value(p)}"
+            for p in (builder.parameters.headers + builder.parameters.query)
+            if not p.in_method_signature
+        ]
 
     @property
     def _function_def(self) -> str:
@@ -561,16 +566,22 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
+        retval = []
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
-        return [
-            f"_stream = {builder.stream_value}",
-            f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
-            + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
-            "    _request,",
-            "    stream=_stream,",
-            "    **kwargs",
-            ")",
-        ]
+        if builder.stream_value is True and not self.code_model.options["version_tolerant"]:
+            retval.append("_decompress = kwargs.pop('decompress', True)")
+        retval.extend(
+            [
+                f"_stream = {builder.stream_value}",
+                f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
+                + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
+                "    _request,",
+                "    stream=_stream,",
+                "    **kwargs",
+                ")",
+            ]
+        )
+        return retval
 
     @property
     def _function_def(self) -> str:
@@ -913,7 +924,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
                 if self.code_model.options["version_tolerant"]:
                     deserialized = "response.iter_bytes()"
                 else:
-                    deserialized = f"response.stream_download(self._client.{self.pipeline_name})"
+                    deserialized = (
+                        f"response.stream_download(self._client.{self.pipeline_name}, decompress=_decompress)"
+                    )
             deserialize_code.append(f"deserialized = {deserialized}")
         elif response.type:
             pylint_disable = ""
@@ -961,11 +974,17 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
     def handle_error_response(self, builder: OperationType) -> List[str]:
         async_await = "await " if self.async_mode else ""
         retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
-        response_read = f"    {async_await}response.read()  # Load the body in memory and close the socket"
+        response_read = [
+            "    try:",
+            f"        {async_await}response.read()  # Load the body in memory and close the socket",
+            "    except (StreamConsumedError, StreamClosedError):",
+            "        pass",
+        ]
         if builder.stream_value is True:  # _stream is True so no need to judge it
-            retval.append(response_read)
+            retval.extend(response_read)
         elif isinstance(builder.stream_value, str):  # _stream is not sure, so we need to judge it
-            retval.extend(["    if _stream:", f"    {response_read}"])
+            retval.append("    if _stream:")
+            retval.extend([f"    {l}" for l in response_read])
         type_ignore = "  # type: ignore" if _need_type_ignore(builder) else ""
         retval.append(
             f"    map_error(status_code=response.status_code, response=response, error_map=error_map){type_ignore}"

package/{autorest → generator/pygen}/codegen/serializers/client_serializer.py

@@ -8,7 +8,7 @@ from typing import List
 from . import utils
 from ..models import Client, ParameterMethodLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
-from ..._utils import build_policies
+from ...utils import build_policies
 
 
 class ClientSerializer:

package/{autorest → generator/pygen}/codegen/serializers/operations_init_serializer.py

@@ -6,7 +6,7 @@
 from typing import List
 from jinja2 import Environment
 
-from autorest.codegen.models.operation_group import OperationGroup
+from ..models.operation_group import OperationGroup
 from ..models import CodeModel, Client
 
 

package/{autorest → generator/pygen}/codegen/serializers/parameter_serializer.py

@@ -148,7 +148,7 @@ class ParameterSerializer:
             param.wire_name,
             ParameterSerializer.serialize_parameter(param, serializer_name),
         )
-        if not param.optional:
+        if not param.optional and (param.in_method_signature or param.constant):
             retval = [set_parameter]
         else:
             retval = [

package/{autorest → generator/pygen}/codegen/serializers/sample_serializer.py

@@ -8,7 +8,7 @@ import logging
 from typing import Dict, Any, Union, Tuple
 from jinja2 import Environment
 
-from autorest.codegen.models.operation import OperationBase
+from ..models.operation import OperationBase
 from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
 from ..models import (
@@ -22,7 +22,7 @@ from ..models import (
     FileImport,
 )
 from .utils import get_namespace_config, get_namespace_from_package_name
-from ..._utils import to_snake_case
+from ...utils import to_snake_case
 
 _LOGGER = logging.getLogger(__name__)
 

package/{autorest → generator/pygen}/codegen/serializers/test_serializer.py

@@ -18,12 +18,26 @@ from ..models import (
     ModelType,
     BaseType,
     CombinedType,
+    FileImport,
 )
 from .utils import get_namespace_from_package_name, json_dumps_template
 
 
+def is_lro(operation_type: str) -> bool:
+    return operation_type in ("lro", "lropaging")
+
+
+def is_paging(operation_type: str) -> bool:
+    return operation_type in ("paging", "lropaging")
+
+
+def is_common_operation(operation_type: str) -> bool:
+    return operation_type == "operation"
+
+
 class TestName:
-    def __init__(self, client_name: str, *, is_async: bool = False) -> None:
+    def __init__(self, code_model: CodeModel, client_name: str, *, is_async: bool = False) -> None:
+        self.code_model = code_model
         self.client_name = client_name
         self.is_async = is_async
 
@@ -41,10 +55,14 @@ class TestName:
 
     @property
     def preparer_name(self) -> str:
+        if self.code_model.options["azure_arm"]:
+            return "RandomNameResourceGroupPreparer"
         return self.prefix + "Preparer"
 
     @property
     def base_test_class_name(self) -> str:
+        if self.code_model.options["azure_arm"]:
+            return "AzureMgmtRecordedTestCase"
         return f"{self.client_name}TestBase{self.async_suffix_capt}"
 
 
@@ -71,40 +89,35 @@ class TestCase:
     @property
     def response(self) -> str:
         if self.is_async:
-            if self.operation.operation_type == "lropaging":
+            if is_lro(self.operation.operation_type):
                 return "response = await (await "
-            return "response = await "
+            if is_common_operation(self.operation.operation_type):
+                return "response = await "
         return "response = "
 
     @property
     def lro_comment(self) -> str:
-        return " # poll until service return final result"
+        return " # call '.result()' to poll until service return final result"
 
     @property
     def operation_suffix(self) -> str:
-        if self.operation.operation_type == "lropaging":
+        if is_lro(self.operation.operation_type):
             extra = ")" if self.is_async else ""
             return f"{extra}.result(){self.lro_comment}"
         return ""
 
     @property
     def extra_operation(self) -> str:
-        if self.is_async:
-            if self.operation.operation_type == "lro":
-                return f"result = await response.result(){self.lro_comment}"
-            if self.operation.operation_type == ("lropaging", "paging"):
-                return "result = [r async for r in response]"
-        else:
-            if self.operation.operation_type == "lro":
-                return f"result = response.result(){self.lro_comment}"
-            if self.operation.operation_type in ("lropaging", "paging"):
-                return "result = [r for r in response]"
+        if is_paging(self.operation.operation_type):
+            async_str = "async " if self.is_async else ""
+            return f"result = [r {async_str}for r in response]"
         return ""
 
 
 class Test(TestName):
     def __init__(
         self,
+        code_model: CodeModel,
         client_name: str,
         operation_group: OperationGroup,
         testcases: List[TestCase],
@@ -112,7 +125,7 @@ class Test(TestName):
         *,
         is_async: bool = False,
     ) -> None:
-        super().__init__(client_name, is_async=is_async)
+        super().__init__(code_model, client_name, is_async=is_async)
         self.operation_group = operation_group
         self.testcases = testcases
         self.test_class_name = test_class_name
@@ -129,19 +142,23 @@ class TestGeneralSerializer(BaseSerializer):
 
     @property
     def test_names(self) -> List[TestName]:
-        return [TestName(c.name, is_async=self.is_async) for c in self.code_model.clients]
+        return [TestName(self.code_model, c.name, is_async=self.is_async) for c in self.code_model.clients]
+
+    def add_import_client(self, imports: FileImport) -> None:
+        namespace = get_namespace_from_package_name(self.code_model.options["package_name"])
+        for client in self.code_model.clients:
+            imports.add_submodule_import(namespace + self.aio_str, client.name, ImportType.STDLIB)
 
     @property
     def import_clients(self) -> FileImportSerializer:
         imports = self.init_file_import()
-        namespace = get_namespace_from_package_name(self.code_model.options["package_name"])
 
         imports.add_submodule_import("devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB)
         if not self.is_async:
             imports.add_import("functools", ImportType.STDLIB)
             imports.add_submodule_import("devtools_testutils", "PowerShellPreparer", ImportType.STDLIB)
-        for client in self.code_model.clients:
-            imports.add_submodule_import(namespace + self.aio_str, client.name, ImportType.STDLIB)
+        self.add_import_client(imports)
+
         return FileImportSerializer(imports, self.is_async)
 
     def serialize_conftest(self) -> str:
@@ -175,19 +192,25 @@ class TestSerializer(TestGeneralSerializer):
     @property
     def import_test(self) -> FileImportSerializer:
         imports = self.init_file_import()
-        test_name = TestName(self.client.name, is_async=self.is_async)
+        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
         async_suffix = "_async" if self.is_async else ""
         imports.add_submodule_import(
-            "testpreparer" + async_suffix,
+            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer" + async_suffix,
             test_name.base_test_class_name,
             ImportType.LOCAL,
         )
-        imports.add_submodule_import("testpreparer", test_name.preparer_name, ImportType.LOCAL)
+        imports.add_submodule_import(
+            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer",
+            test_name.preparer_name,
+            ImportType.LOCAL,
+        )
         imports.add_submodule_import(
             "devtools_testutils" + self.aio_str,
             "recorded_by_proxy" + async_suffix,
             ImportType.LOCAL,
         )
+        if self.code_model.options["azure_arm"]:
+            self.add_import_client(imports)
         return FileImportSerializer(imports, self.is_async)
 
     @property
@@ -242,6 +265,7 @@ class TestSerializer(TestGeneralSerializer):
             raise Exception("no public operation to test")  # pylint: disable=broad-exception-raised
 
         return Test(
+            code_model=self.code_model,
             client_name=self.client.name,
             operation_group=self.operation_group,
             testcases=testcases,
@@ -251,7 +275,7 @@ class TestSerializer(TestGeneralSerializer):
 
     @property
     def test_class_name(self) -> str:
-        test_name = TestName(self.client.name, is_async=self.is_async)
+        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
         class_name = "" if self.operation_group.is_mixin else self.operation_group.class_name
         return f"Test{test_name.prefix}{class_name}{test_name.async_suffix_capt}"
 

package/{autorest → generator/pygen}/codegen/templates/conftest.py.jinja2

@@ -11,7 +11,7 @@ load_dotenv()
 @pytest.fixture(scope="session", autouse=True)
 def add_sanitizers(test_proxy):
     {% for test_name in test_names %}
-    {% set prefix_upper = test_name.prefix|upper %}
+    {% set prefix_upper = "AZURE" if code_model.options["azure_arm"] else test_name.prefix|upper %}
     {% set prefix_lower = test_name.prefix|lower %}
     {{ prefix_lower }}_subscription_id = os.environ.get("{{ prefix_upper }}_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000")
     {{ prefix_lower }}_tenant_id = os.environ.get("{{ prefix_upper }}_TENANT_ID", "00000000-0000-0000-0000-000000000000")

package/{autorest → generator/pygen}/codegen/templates/request_builder.py.jinja2

@@ -8,8 +8,8 @@
         {% if request_builder_serializer.pop_kwargs_from_signature(request_builder) %}
     {{ op_tools.serialize(request_builder_serializer.pop_kwargs_from_signature(request_builder)) | indent }}
         {%- endif -%}
-    {% if request_builder_serializer.declare_non_inputtable_constants(request_builder) %}
-    {{ op_tools.serialize(request_builder_serializer.declare_non_inputtable_constants(request_builder)) | indent }}
+    {% if request_builder_serializer.declare_non_inputtable_headers_queries(request_builder) %}
+    {{ op_tools.serialize(request_builder_serializer.declare_non_inputtable_headers_queries(request_builder)) | indent }}
         {% endif %}
     # Construct URL
     {{ request_builder_serializer.construct_url(request_builder) }}

package/generator/pygen/codegen/templates/test.py.jinja2

@@ -0,0 +1,50 @@
+{% set prefix_lower = test.prefix|lower %}
+{% set client_var = "self.client" if code_model.options["azure_arm"] else "client" %}
+{% set async = "async " if test.is_async else "" %}
+{% set async_suffix = "_async" if test.is_async else "" %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+import pytest
+{{ imports }}
+
+{% if code_model.options["azure_arm"] %}
+AZURE_LOCATION = "eastus"
+{% endif %}
+
+@pytest.mark.skip("you may need to update the auto-generated test case before run it")
+class {{ test.test_class_name }}({{ test.base_test_class_name }}):
+{% if code_model.options["azure_arm"] %}
+    def setup_method(self, method):
+        {% if test.is_async %}
+        self.client = self.create_mgmt_client({{ test.client_name }}, is_async=True)
+        {% else %}
+        self.client = self.create_mgmt_client({{ test.client_name }})
+        {% endif %}
+{% endif %}
+{% for testcase in test.testcases %}
+    {% if code_model.options["azure_arm"] %}
+    @{{ test.preparer_name }}(location=AZURE_LOCATION)
+    {% else %}
+    @{{ test.preparer_name }}()
+    {% endif %}
+    @recorded_by_proxy{{ async_suffix }}
+    {% if code_model.options["azure_arm"] %}
+    {{ async }}def test_{{ testcase.operation.name }}(self, resource_group):
+    {% else %}
+    {{ async }}def test_{{ testcase.operation.name }}(self, {{ prefix_lower }}_endpoint):
+        {{ client_var }} = self.{{ test.create_client_name }}(endpoint={{ prefix_lower }}_endpoint)
+    {% endif %}
+        {{testcase.response }}{{ client_var }}{{ testcase.operation_group_prefix }}.{{ testcase.operation.name }}(
+            {% for key, value in testcase.params.items() %}
+            {% if code_model.options["azure_arm"] and key == "resource_group_name" %}
+            {{ key }}=resource_group.name,
+            {% else %}
+            {{ key }}={{ value|indent(12) }},
+            {% endif %}
+            {% endfor %}
+        ){{ testcase.operation_suffix }}
+        {{ testcase.extra_operation }}
+        # please add some check logic here by yourself
+        # ...
+
+{% endfor %}

package/{autorest/m2r/__init__.py → generator/pygen/m2r.py}

@@ -3,21 +3,21 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-"""An autorest MD to RST plugin.
+"""An MD to RST plugin.
 """
 import logging
 from typing import Any, Dict, Set, Union
 
 import m2r2
 
-from .. import YamlUpdatePluginAutorest, YamlUpdatePlugin
-from .._utils import parse_args
+from . import YamlUpdatePlugin
+from .utils import parse_args
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class AutorestRender(m2r2.RestRenderer):
+class GeneratorRenderer(m2r2.RestRenderer):
     """Redefine the concept of inline HTML in the renderer, we don't want to define a new format
     in the description/summary.
     """
@@ -54,16 +54,11 @@ class M2R(YamlUpdatePlugin):  # pylint: disable=abstract-method
     def convert_to_rst(string_to_convert: str) -> str:
         """Convert that string from MD to RST."""
         try:
-            return m2r2.convert(string_to_convert, renderer=AutorestRender()).strip()
+            return m2r2.convert(string_to_convert, renderer=GeneratorRenderer()).strip()
         except Exception:  # pylint: disable=broad-except
             return string_to_convert
 
 
-class M2RAutorest(YamlUpdatePluginAutorest, M2R):
-    def get_options(self) -> Dict[str, Any]:
-        return {}
-
-
 if __name__ == "__main__":
     # CADL pipeline will call this
     args, unknown_args = parse_args()

package/{autorest → generator/pygen}/postprocess/__init__.py

@@ -12,7 +12,7 @@ import black
 from black.report import NothingChanged
 from .venvtools import ExtendedEnvBuilder, python_run
 
-from .. import Plugin, PluginAutorest
+from .. import Plugin
 
 _BLACK_MODE = black.Mode()  # pyright: ignore [reportPrivateImportUsage]
 _BLACK_MODE.line_length = 120
@@ -181,8 +181,3 @@ class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
             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)
-
-
-class PostProcessPluginAutorest(PostProcessPlugin, PluginAutorest):
-    def get_options(self) -> Dict[str, Any]:
-        return {"outputFolderUri": self._autorestapi.get_value("outputFolderUri")}