@autorest/python 5.19.0 → 6.0.1

package/autorest/codegen/templates/operation_groups_container.py.jinja2

@@ -8,18 +8,12 @@
 
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
 {{ op_tools.declare_serializer(code_model, request_builders) }}
-{%- if not is_python3_file %}
-# fmt: off
-{% endif %}
 {% for operation_group in operation_groups %}
     {% for request_builder in request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
 
         {% include "request_builder.py.jinja2" %}
     {% endfor %}
 {% endfor %}
-{% if not is_python3_file %}
-# fmt: on
-{% endif %}
 {% endif %}
 {% for operation_group in operation_groups %}
     {% include "operation_group.py.jinja2" %}

package/autorest/codegen/templates/patch.py.jinja2

@@ -8,8 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python
 """
 {{ imports }}
 
-{% set type_annotation = ": List[str]" %}
-__all__{{ type_annotation if is_python3_file else "" }} = []{{ "" if is_python3_file else ("  # type" + type_annotation) }}  # Add all objects you want publicly available to users at this package level
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
 
 def patch_sdk():
     """Do not remove from this file.

package/autorest/codegen/templates/request_builders.py.jinja2

@@ -4,9 +4,6 @@
 {{ imports }}
 
 {{ op_tools.declare_serializer(code_model, request_builders) }}
-{% if not is_python3_file %}
-# fmt: off
-{% endif %}
 {% for request_builder in request_builders %}
 
 {% include "request_builder.py.jinja2" %}

package/autorest/codegen/templates/rest_init.py.jinja2

@@ -1,14 +1,9 @@
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-try:
-    {% for request_builder in request_builders %}
-    from ._request_builders_py3 import {{ request_builder.name }}
-    {% endfor %}
-except (SyntaxError, ImportError):
-    {% for request_builder in request_builders %}
-    from ._request_builders import {{ request_builder.name }}  # type: ignore
-    {% endfor %}
+{% for request_builder in request_builders %}
+from ._request_builders import {{ request_builder.name }}
+{% endfor %}
 
 __all__ = [
     {% for request_builder in request_builders %}

package/autorest/codegen/templates/serialization.py.jinja2

@@ -106,7 +106,7 @@ class RawDeserializer:
                 except NameError:
                     pass
 
-                return ET.fromstring(data_as_str)
+                return ET.fromstring(data_as_str)  # nosec
             except ET.ParseError:
                 # It might be because the server has an issue, and returned JSON with
                 # content-type XML....
@@ -831,7 +831,7 @@ class Serializer(object):
             return custom_serializer(data)
         if data_type == 'str':
             return cls.serialize_unicode(data)
-        return eval(data_type)(data)
+        return eval(data_type)(data)  # nosec
 
     @classmethod
     def serialize_unicode(cls, data):
@@ -1765,7 +1765,7 @@ class Deserializer(object):
 
         if data_type == 'str':
             return self.deserialize_unicode(attr)
-        return eval(data_type)(attr)
+        return eval(data_type)(attr)  # nosec
 
     @staticmethod
     def deserialize_unicode(data):

package/autorest/codegen/templates/setup.py.jinja2

@@ -85,7 +85,7 @@ setup(
         {% if code_model.is_legacy %}
         "{{ dependency_msrest }}",
         {% else %}
-        "isodate>=0.6.1",
+        "isodate<1.0.0,>=0.6.1",
         {% endif %}
         {% if azure_arm %}
         "{{ dependency_azure_mgmt_core }}",

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
@@ -494,6 +496,13 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         in_overriden = (
             body_parameter["type"]["type"] == "combined" if body_parameter else False
         )
+        abstract = False
+        if body_parameter and (
+            body_parameter.get("entries")
+            or len(body_parameter["type"].get("types", [])) > 2
+        ):
+            # this means it's formdata or urlencoded, or there are more than 2 types of body
+            abstract = True
         return {
             "name": yaml_data["language"]["default"]["name"],
             "description": yaml_data["language"]["default"]["description"],
@@ -520,6 +529,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             "discriminator": "operation",
             "isOverload": is_overload,
             "apiVersions": _get_api_versions(yaml_data.get("apiVersions", [])),
+            "abstract": abstract,
         }
 
     def get_operation_creator(
@@ -1072,9 +1082,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             "skipUrlEncoding": True,
             "inOverload": False,
         }
-        if self._autorestapi.get_boolean_value(
-            "version-tolerant"
-        ) or self._autorestapi.get_boolean_value("low-level-client"):
+        if self.version_tolerant or self.low_level_client:
             parameters.append(credential)
         else:
             parameters.insert(0, credential)

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,24 +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), is_python3_file=async_mode
-        )
-        self._autorestapi.write_file(
+        imports = FileImportSerializer(code_model.client.imports(async_mode))
+        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), is_python3_file=async_mode
-        )
-        self._autorestapi.write_file(
+        imports = FileImportSerializer(code_model.config.imports(async_mode))
+        self.write_file(
             _get_file_path("_configuration", async_mode),
             _render_template("config", imports=imports),
         )
@@ -77,29 +74,24 @@ class MultiAPISerializer(object):
         # 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,
+                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)
@@ -109,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(
@@ -125,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/import_serializer.py

@@ -54,9 +54,8 @@ def _get_import_clauses(
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport, is_python3_file: bool) -> None:
+    def __init__(self, file_import: FileImport) -> None:
         self._file_import = file_import
-        self.is_python3_file = is_python3_file
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
@@ -84,10 +83,7 @@ class FileImportSerializer:
         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):
             self._file_import.add_submodule_import(
                 "typing", "TYPE_CHECKING", ImportType.STDLIB
             )
@@ -97,7 +93,7 @@ class FileImportSerializer:
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
             baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=self.is_python3_file,
+            add_conditional_typing=True,
         )
 
         if regular_imports_dict:
@@ -108,7 +104,7 @@ class FileImportSerializer:
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
             baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=not self.is_python3_file,
+            add_conditional_typing=False,
         )
         if typing_imports_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "

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,
+        )