@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/serializers/utils.py

@@ -23,13 +23,11 @@ def serialize_method(
     lines.append(first_line)
     if is_in_class:
         lines.append("    self,")
-    lines.extend([
-        ("    " + line)
-        for line in method_param_signatures
-    ])
+    lines.extend([("    " + line) for line in method_param_signatures])
     lines.append(")")
     return "\n".join(lines)
 
+
 def build_serialize_data_call(
     parameter: Parameter, function_name: str, serializer_name: str
 ) -> str:
@@ -69,30 +67,32 @@ def build_serialize_data_call(
         f'"{origin_name.lstrip("_")}"',
         "q" if parameter.explode else origin_name,
         f"'{serialization_schema.serialization_type}'",
-        *optional_parameters
+        *optional_parameters,
     ]
-    parameters_line = ', '.join(parameters)
+    parameters_line = ", ".join(parameters)
 
-    serialize_line = f'{serializer_name}.{function_name}({parameters_line})'
+    serialize_line = f"{serializer_name}.{function_name}({parameters_line})"
 
     if parameter.explode:
         return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
     return serialize_line
 
-def serialize_path(
-    parameters: List[Parameter], serializer_name: str
-) -> List[str]:
+
+def serialize_path(parameters: List[Parameter], serializer_name: str) -> List[str]:
     retval = ["path_format_arguments = {"]
-    retval.extend([
-        "    \"{}\": {},".format(
-            path_parameter.rest_api_name,
-            build_serialize_data_call(path_parameter, "url", serializer_name)
-        )
-        for path_parameter in parameters
-    ])
+    retval.extend(
+        [
+            '    "{}": {},'.format(
+                path_parameter.rest_api_name,
+                build_serialize_data_call(path_parameter, "url", serializer_name),
+            )
+            for path_parameter in parameters
+        ]
+    )
     retval.append("}")
     return retval
 
+
 def method_signature_and_response_type_annotation_template(
     *,
     is_python3_file: bool,
@@ -103,11 +103,13 @@ def method_signature_and_response_type_annotation_template(
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
 
+
 class PopKwargType(Enum):
     NO = auto()
     SIMPLE = auto()
     CASE_INSENSITIVE = auto()
 
+
 def pop_kwargs_from_signature(
     kwargs_to_pop: List[Parameter],
     check_kwarg_dict: bool,
@@ -115,11 +117,15 @@ def pop_kwargs_from_signature(
     pop_params_kwarg: PopKwargType,
 ) -> List[str]:
     retval = []
+
     def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
         if PopKwargType.CASE_INSENSITIVE == pop_type:
-            retval.append(f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})')
+            retval.append(
+                f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})'
+            )
         elif PopKwargType.SIMPLE == pop_type:
             retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
+
     append_pop_kwarg("headers", pop_headers_kwarg)
     append_pop_kwarg("params", pop_params_kwarg)
     if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
@@ -127,9 +133,17 @@ def pop_kwargs_from_signature(
     for kwarg in kwargs_to_pop:
         if kwarg.has_default_value:
             default_value = kwarg.default_value_declaration
-            if check_kwarg_dict and (kwarg.location in [ParameterLocation.Header, ParameterLocation.Query]):
-                kwarg_dict = "headers" if kwarg.location == ParameterLocation.Header else "params"
-                default_value = f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
+            if check_kwarg_dict and (
+                kwarg.location in [ParameterLocation.Header, ParameterLocation.Query]
+            ):
+                kwarg_dict = (
+                    "headers"
+                    if kwarg.location == ParameterLocation.Header
+                    else "params"
+                )
+                default_value = (
+                    f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
+                )
             retval.append(
                 f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}', "
                 + f"{default_value})  # type: {kwarg.type_annotation(is_operation_file=True)}"

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

@@ -2,7 +2,7 @@
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-{% if code_model.rest.request_builders %}
+{% if code_model.request_builders %}
 from .{{ code_model.service_client.filename }} import {{ code_model.class_name }}
 {% endif %}
 {% if not async_mode and code_model.options['package_version']%}
@@ -12,7 +12,7 @@ __version__ = VERSION
 {% endif %}
 
 {{ keywords.patch_imports(try_except=True) }}
-__all__ = [{{("'" + code_model.class_name + "'") if code_model.rest.request_builders else ""}}]
+__all__ = [{{("'" + code_model.class_name + "'") if code_model.request_builders else ""}}]
 {{ keywords.extend_all }}
 
 _patch_sdk()

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

@@ -1,18 +1,16 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
     {{ op_tools.description(operation, operation_serializer) | indent -}}
-    {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {%- endif %}
+        {%- endif %}
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
 
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,20 +1,18 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {% import 'keywords.jinja2' as keywords with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
     {{ op_tools.description(operation, operation_serializer) | indent }}
-    {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}
 
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

package/autorest/codegen/templates/metadata.json.jinja2

@@ -126,8 +126,9 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set sync_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, False, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call(is_python3_file=False) | join(', ') | tojson }}
                 },
                 "async": {
                     {% set coroutine = False if (is_paging(operation) and not is_lro(operation)) else True %}
@@ -146,10 +147,10 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set async_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
-                },
-                "call": {{ operation.parameters.method | rejectattr("is_kwarg") | map(attribute="serialized_name") | rejectattr("is_kwarg") | join(', ') | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, True, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call(is_python3_file=True) | join(', ') | tojson }}
+                }
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         }

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

@@ -1,21 +1,18 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {% set stream_request_parameter = "stream=" ~ ("True" if operation.is_stream_response else "False") %}
 {# actual template starts here #}
-{%- if code_model.options['tracing'] and operation.want_tracing -%}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
 {% if operation.want_description_docstring %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
-{% if operation.deprecated %}
+    {% if not operation.abstract %}
+        {% if operation.deprecated %}
     warnings.warn('Method {{operation.name}} is deprecated', DeprecationWarning)
-{% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.error_map(operation)) | indent }}
-    {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
     pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
         request,
@@ -23,6 +20,7 @@
         **kwargs
     )
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -1,12 +1,6 @@
 {% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
-{% if operation_group.is_empty_operation_group and code_model.need_mixin_abc %}
-    {% set object_base_class = "(MixinABC)" %}
-{% elif not (async_mode or code_model.options["python3_only"]) %}
-    {% set object_base_class = "(object)" %}
-{% else %}
-    {% set object_base_class = "" %}
-{% endif %}
-class {{ operation_group.class_name }}{{ object_base_class }}:{{ disable }}
+{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
+class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
 {% if not operation_group.is_empty_operation_group %}
     """
     .. warning::

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

@@ -12,7 +12,7 @@
 # fmt: off
 {% endif %}
 {% for operation_group in operation_groups %}
-    {% for request_builder in code_model.rest.request_builders | selectattr("operation_group_name", "equalto", operation_group.name) %}
+    {% for request_builder in code_model.request_builders | selectattr("operation_group_name", "equalto", operation_group.name) %}
 
         {% include "request_builder.py.jinja2" %}
     {% endfor %}

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

@@ -1,22 +1,21 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] and operation.want_tracing %}
-@distributed_trace
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
 {% if operation.want_description_docstring %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
-{% if operation.deprecated %}
+    {% if not operation.abstract %}
+        {% if operation.deprecated %}
     warnings.warn('Method {{operation.name}} is deprecated', DeprecationWarning)
-{% endif %}
-    {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+        {% endif %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}
 
     return {{ operation.get_pager(async_mode) }}(
         get_next, extract_data
     )
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,26 +1,33 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools with context %}
-{{ request_builder_serializer.method_signature_and_response_type_annotation(request_builder) }}
+{{ request_builder_serializer.method_signature_and_response_type_annotation(request_builder, False) }}
 {% if code_model.options["builders_visibility"] == "public" %}
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
-{% if request_builder_serializer.pop_kwargs_from_signature(request_builder) %}
+{% if request_builder.abstract %}
+    raise NotImplementedError(
+        "You need to write a custom operation for '{{ request_builder.name }}'. "
+        "Please refer to https://aka.ms/azsdk/python/dpcodegen/python/customize to learn how to customize."
+    )
+{% else %}
+    {% 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) %}
+    {%- endif -%}
+    {% if request_builder_serializer.declare_non_inputtable_constants(request_builder) %}
     {{ op_tools.serialize(request_builder_serializer.declare_non_inputtable_constants(request_builder)) | indent }}
-{% endif %}
+    {% endif %}
     # Construct URL
     {{ request_builder_serializer.construct_url(request_builder) }}
-{% if request_builder.parameters.path %}
+    {% if request_builder.parameters.path %}
     {{ op_tools.serialize(request_builder_serializer.serialize_path(request_builder)) | indent }}
     _url = _format_url_section(_url, **path_format_arguments)
-{% endif %}
+    {% endif %}
 
-{% if request_builder.parameters.query %}
+    {% if request_builder.parameters.query %}
     {{ op_tools.serialize(request_builder_serializer.serialize_query(request_builder)) | indent }}
-{% endif %}
-{% if request_builder.parameters.headers %}
+    {% endif %}
+    {% if request_builder.parameters.headers %}
     {{ op_tools.serialize(request_builder_serializer.serialize_headers(request_builder)) | indent }}
-{% endif %}
+    {% endif %}
     {{ op_tools.serialize(request_builder_serializer.create_http_request(request_builder)) | indent }}
+{% endif %}

package/autorest/jsonrpc/__init__.py

@@ -7,7 +7,7 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Any, List, Optional, Union
 import logging
-import logging.config # need to include this extra import so mypy doesn't throw logging module has no config
+import logging.config  # need to include this extra import so mypy doesn't throw logging module has no config
 from pathlib import Path
 
 
@@ -45,13 +45,12 @@ class AutorestHandler(logging.Handler):
         # Initialize this handler with the max loglevel, since
         # autorest is deciding what to show, not us
         # so we want to log everything and let autorest filters.
-        super(AutorestHandler, self).__init__(logging.DEBUG)
+        super().__init__(logging.DEBUG)
         self._autorest_api = autorest_api
 
     @staticmethod
     def _get_log_level(level: int) -> Channel:
-        """Convert Python log levels to Autorest Channel.
-        """
+        """Convert Python log levels to Autorest Channel."""
         return _LEVEL_MAPPING.get(level, Channel.Warning)
 
     def emit(self, record: logging.LogRecord) -> None:
@@ -65,8 +64,7 @@ class AutorestHandler(logging.Handler):
 
 
 class AutorestAPI(ABC):
-    """Defines the base interface of communication to Autorest from the plugin.
-    """
+    """Defines the base interface of communication to Autorest from the plugin."""
 
     def __init__(self) -> None:
         if Path("logging.conf").exists():
@@ -106,18 +104,15 @@ class AutorestAPI(ABC):
 
     @abstractmethod
     def list_inputs(self) -> List[str]:
-        """List possible inputs for this plugin.
-        """
+        """List possible inputs for this plugin."""
 
     @abstractmethod
     def get_value(self, key: str) -> Any:
-        """Get a value from configuration.
-        """
+        """Get a value from configuration."""
 
     @abstractmethod
     def message(self, channel: Channel, text: str) -> None:
-        """Send a log message to autorest.
-        """
+        """Send a log message to autorest."""
 
     def get_boolean_value(self, key: str, default: bool = None) -> Optional[bool]:
         """Check if value is present on the line, and interpret it as bool if it was.

package/autorest/jsonrpc/localapi.py

@@ -14,10 +14,11 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class LocalAutorestAPI(AutorestAPI):
-    """A local API that will write on local disk.
-    """
+    """A local API that will write on local disk."""
 
-    def __init__(self, reachable_files: List[str] = None, output_folder: str = "generated") -> None:
+    def __init__(
+        self, reachable_files: List[str] = None, output_folder: str = "generated"
+    ) -> None:
         super().__init__()
         if reachable_files is None:
             reachable_files = []

package/autorest/jsonrpc/server.py

@@ -24,13 +24,16 @@ def GetPluginNames():
 @dispatcher.add_method
 def Process(plugin_name: str, session_id: str) -> bool:
     # pylint: disable=import-outside-toplevel
-    """JSON-RPC process call.
-    """
+    """JSON-RPC process call."""
     from .stdstream import StdStreamAutorestAPI
 
     with contextlib.closing(StdStreamAutorestAPI(session_id)) as stdstream_connection:
 
-        _LOGGER.debug("Autorest called process with plugin_name '%s' and session_id: '%s'", plugin_name, session_id)
+        _LOGGER.debug(
+            "Autorest called process with plugin_name '%s' and session_id: '%s'",
+            plugin_name,
+            session_id,
+        )
         if plugin_name == "m2r":
             from ..m2r import M2R as PluginToLoad
         elif plugin_name == "namer":
@@ -38,7 +41,7 @@ def Process(plugin_name: str, session_id: str) -> bool:
         elif plugin_name == "codegen":
             from ..codegen import CodeGenerator as PluginToLoad  # type: ignore
         elif plugin_name == "black":
-            from ..black import BlackScriptPlugin  as PluginToLoad  # type: ignore
+            from ..black import BlackScriptPlugin as PluginToLoad  # type: ignore
         elif plugin_name == "multiapiscript":
             from ..multiapi import MultiApiScriptPlugin as PluginToLoad  # type: ignore
         else:
@@ -58,11 +61,15 @@ def Process(plugin_name: str, session_id: str) -> bool:
 def main() -> None:
     # If --python.debugger is specified on the command line, we call the server.py file internally
     # with flag --debug.
-    if '--debug' in sys.argv or os.environ.get("AUTOREST_PYTHON_ATTACH_VSCODE_DEBUG", False):
+    if "--debug" in sys.argv or os.environ.get(
+        "AUTOREST_PYTHON_ATTACH_VSCODE_DEBUG", False
+    ):
         try:
             import ptvsd  # pylint: disable=import-outside-toplevel
         except ImportError:
-            raise SystemExit("Please pip install ptvsd in order to use VSCode debugging")
+            raise SystemExit(
+                "Please pip install ptvsd in order to use VSCode debugging"
+            )
 
         # 5678 is the default attach port in the VS Code debug configurations
         ptvsd.enable_attach(address=("localhost", 5678), redirect_output=True)

package/autorest/jsonrpc/stdstream.py

@@ -53,8 +53,7 @@ def write_message(message: str, stream: BinaryIO = sys.stdout.buffer) -> None:
 
 
 class StdStreamAutorestAPI(AutorestAPI):
-    """The stream API with Autorest
-    """
+    """The stream API with Autorest"""
 
     def __init__(self, session_id: str) -> None:
         super().__init__()
@@ -73,19 +72,25 @@ class StdStreamAutorestAPI(AutorestAPI):
     def read_file(self, filename: Union[str, Path]) -> str:
         _LOGGER.debug("Asking content for file %s", filename)
         filename = os.fspath(filename)
-        request = JSONRPC20Request(method="ReadFile", params=[self.session_id, filename], _id=42)
+        request = JSONRPC20Request(
+            method="ReadFile", params=[self.session_id, filename], _id=42
+        )
         write_message(request.json)
         return json.loads(read_message())["result"]
 
     def list_inputs(self) -> List[str]:
         _LOGGER.debug("Calling list inputs to Autorest")
-        request = JSONRPC20Request(method="ListInputs", params=[self.session_id, None], _id=42)
+        request = JSONRPC20Request(
+            method="ListInputs", params=[self.session_id, None], _id=42
+        )
         write_message(request.json)
         return json.loads(read_message())["result"]
 
     def get_value(self, key: str) -> Any:
         _LOGGER.debug("Calling get value to Autorest: %s", key)
-        request = JSONRPC20Request(method="GetValue", params=[self.session_id, key], _id=42)
+        request = JSONRPC20Request(
+            method="GetValue", params=[self.session_id, key], _id=42
+        )
         write_message(request.json)
         return json.loads(read_message())["result"]
 
@@ -96,5 +101,7 @@ class StdStreamAutorestAPI(AutorestAPI):
             "Channel": channel.value,
             "Text": text,
         }
-        request = JSONRPC20Request(method="Message", params=[self.session_id, message], is_notification=True)
+        request = JSONRPC20Request(
+            method="Message", params=[self.session_id, message], is_notification=True
+        )
         write_message(request.json)

package/autorest/m2r/__init__.py

@@ -27,18 +27,16 @@ class AutorestRender(m2r.RestRenderer):
 
 
 class M2R(YamlUpdatePlugin):
-    """A plugin to convert any description and summary from MD to RST.
-    """
+    """A plugin to convert any description and summary from MD to RST."""
+
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
-        """Convert in place the YAML str.
-        """
+        """Convert in place the YAML str."""
         self._convert_docstring_no_cycles(yaml_data, set())
 
     def _convert_docstring_no_cycles(
         self, yaml_data: Dict[str, Any], node_list: Set[int]
     ) -> None:
-        """Walk the YAML tree to convert MD to RST.
-        """
+        """Walk the YAML tree to convert MD to RST."""
         if id(yaml_data) in node_list:
             return
         node_list.add(id(yaml_data))
@@ -55,8 +53,7 @@ class M2R(YamlUpdatePlugin):
 
     @staticmethod
     def convert_to_rst(string_to_convert: str) -> str:
-        """Convert that string from MD to RST.
-        """
+        """Convert that string from MD to RST."""
         try:
             return m2r.convert(string_to_convert, renderer=AutorestRender()).strip()
         except Exception:  # pylint: disable=broad-except

package/autorest/multiapi/__init__.py

@@ -32,7 +32,7 @@ class MultiApiScriptPlugin(Plugin):
             output_folder,
             self._autorestapi,
             no_async,
-            user_specified_default_api
+            user_specified_default_api,
         )
         return generator.process()
 
@@ -44,10 +44,12 @@ class MultiAPI:
         output_folder: str,
         autorestapi: AutorestAPI,
         no_async: Optional[bool] = False,
-        user_specified_default_api: Optional[str] = None
+        user_specified_default_api: Optional[str] = None,
     ) -> None:
         if input_package_name is None:
-            raise ValueError("package-name is required, either provide it as args or check your readme configuration")
+            raise ValueError(
+                "package-name is required, either provide it as args or check your readme configuration"
+            )
         self.input_package_name = input_package_name
         _LOGGER.debug("Received package name %s", input_package_name)
 
@@ -64,7 +66,7 @@ class MultiAPI:
             self.mod_to_api_version,
             [p.name for p in self.paths_to_versions],
             self.preview_mode,
-            self.user_specified_default_api
+            self.user_specified_default_api,
         )
 
     @property
@@ -75,7 +77,9 @@ 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._autorestapi.read_file(path_to_default_version / "_metadata.json")
+        )
 
     @property
     def module_name(self) -> str:
@@ -96,7 +100,11 @@ class MultiAPI:
     def preview_mode(self) -> bool:
         # If True, means the auto-profile will consider preview versions.
         # If not, if it exists a stable API version for a global or RT, will always be used
-        return cast(bool, self.user_specified_default_api and "preview" in self.user_specified_default_api)
+        return cast(
+            bool,
+            self.user_specified_default_api
+            and "preview" in self.user_specified_default_api,
+        )
 
     @property
     def paths_to_versions(self) -> List[Path]:
@@ -105,14 +113,16 @@ class MultiAPI:
         directory.sort()
         for child in directory:
             child_dir = (self.output_folder / child).resolve()
-            if Path(child_dir / '_metadata.json') in child_dir.iterdir():
+            if Path(child_dir / "_metadata.json") in child_dir.iterdir():
                 paths_to_versions.append(Path(child.stem))
         return paths_to_versions
 
     @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._autorestapi.read_file(version_path / "_metadata.json")
+            )
             for version_path in self.paths_to_versions
         }
 
@@ -120,18 +130,18 @@ 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"))
-            version = metadata_json['chosen_version']
-            total_api_version_list = metadata_json['total_api_version_list']
+            metadata_json = json.loads(
+                self._autorestapi.read_file(version_path / "_metadata.json")
+            )
+            version = metadata_json["chosen_version"]
+            total_api_version_list = metadata_json["total_api_version_list"]
             if not version:
                 if total_api_version_list:
                     sys.exit(
                         f"Unable to match {total_api_version_list} to label {version_path.stem}"
                     )
                 else:
-                    sys.exit(
-                        f"Unable to extract api version of {version_path.stem}"
-                    )
+                    sys.exit(f"Unable to extract api version of {version_path.stem}")
             mod_to_api_version[version_path.name] = version
         return mod_to_api_version