@autorest/python 5.13.0 → 5.16.0

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.parameters.kwargs_to_pop(async_mode) %}
+        {% 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/patch.py.jinja2

@@ -1,31 +1,20 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-#
-# Copyright (c) Microsoft Corporation. All rights reserved.
-#
-# The MIT License (MIT)
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the ""Software""), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-# --------------------------------------------------------------------------
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Customize generated code here.
+
+Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
+"""
+{{ 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
 
-# This file is used for handwritten extensions to the generated code. Example:
-# https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
 def patch_sdk():
-    pass
+    """Do not remove from this file.
+
+    `patch_sdk` is a last resort escape hatch that allows you to do customizations
+    you can't accomplish using the techniques described in
+    https://aka.ms/azsdk/python/dpcodegen/python/customize
+    """

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

@@ -1,28 +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.parameters.kwargs_to_pop(is_python3_file) %}
+{% 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.parameters.constant|selectattr("original_parameter", "equalto", None)|selectattr("in_method_code")|selectattr("in_method_signature", "equalto", False) %}
-    {% for constant_parameter in request_builder.parameters.constant|selectattr("original_parameter", "equalto", None)|selectattr("in_method_code")|selectattr("in_method_signature", "equalto", False) %}
-    {{ constant_parameter.serialized_name }} = {{ constant_parameter.constant_declaration }}
-    {% endfor %}
-{% endif %}
+    {%- 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 %}
     # 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/codegen/templates/setup.py.jinja2

@@ -1,34 +1,93 @@
-{% set name = code_model.options["package_name"] or code_model.class_name %}
-{% set azure_mgmt_core_import = ', "azure-mgmt-core<2.0.0,>=1.2.1"' if code_model.options["azure_arm"] else "" %}
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ license_header }}
 # coding: utf-8
-
+{% if package_mode %}
+import os
+import re
+{% endif -%}
 from setuptools import setup, find_packages
 
-NAME = "{{ name|lower }}"
-VERSION = "{{ code_model.options.get('package_version', '0.0.0') }}"
+{% set package_name_render = package_name or code_model.class_name %}
+
+PACKAGE_NAME = "{{ package_name_render|lower }}"
+{% if package_mode -%}
+PACKAGE_PPRINT_NAME = "{{ package_pprint_name }}"
+
+# a-b-c => a/b/c
+package_folder_path = PACKAGE_NAME.replace("-", "/")
 
-# To install the library, run the following
-#
-# python setup.py install
-#
-# prerequisite: setuptools
-# http://pypi.python.org/pypi/setuptools
+# Version extraction inspired from 'requests'
+with open(os.path.join(package_folder_path, "_version.py"), "r") as fd:
+    version = re.search(
+        r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE
+    ).group(1)
 
-REQUIRES = ["msrest>=0.6.21", "azure-core<2.0.0,>=1.20.1"{{ azure_mgmt_core_import }}]
+if not version:
+    raise RuntimeError("Cannot find version information")
+{% set description = "Microsoft %s Client Library for Python"|format(package_pprint_name) %}
+{% set author_email = "azpysdkhelp@microsoft.com" %}
+{% set url = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk" %}
+{% else %}
+version = "{{ code_model.options['package_version'] }}"
+{% set description = "%s"|format(package_name_render) %}
+{% set long_description = code_model.description %}
+{% set author_email = "" %}
+{% set url = "" %}
+{% endif -%}
 
 setup(
-    name=NAME,
-    version=VERSION,
-    description="{{ name }}",
-    author_email="",
-    url="",
-    keywords=["Swagger", "{{ code_model.class_name }}"],
-    install_requires=REQUIRES,
+    name=PACKAGE_NAME,
+    version=version,
+    description="{{ description }}",
+    {% if package_mode %}
+    long_description=open("README.md", "r").read(),
+    long_description_content_type="text/markdown",
+    license="MIT License",
+    author="Microsoft Corporation",
+    {% endif %}
+    author_email="{{ author_email }}",
+    url="{{ url }}",
+    keywords="azure, azure sdk",
+    {% if package_mode %}
+    classifiers=[
+        "Development Status :: {{ dev_status }}",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "License :: OSI Approved :: MIT License",
+    ],
+    zip_safe=False,
+    packages=find_packages(
+        exclude=[
+            "tests",
+            # Exclude packages that will be covered by PEP420 or nspkg
+            {%- for pkgutil_name in pkgutil_names %}
+            "{{ pkgutil_name }}",
+            {%- endfor %}
+        ]
+    ),
+    {% else %}
     packages=find_packages(),
     include_package_data=True,
+    {% endif %}
+    install_requires=[
+        "{{ dependency_msrest }}",
+        {% if azure_arm %}
+        "{{ dependency_azure_mgmt_core }}",
+        {% else %}
+        "{{ dependency_azure_core }}",
+        {% endif %}
+    ],
+    {% if package_mode %}
+    python_requires=">=3.6",
+    {% else %}
     long_description="""\
     {{ code_model.description }}
     """
+    {% endif %}
 )

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

@@ -1,8 +1,9 @@
+{% import 'keywords.jinja2' as keywords with context %}
 {{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if code_model.need_request_converter %}
+{% if code_model.need_request_converter and not async_mode %}
 def _convert_request(request, files=None):
     data = request.content if not files else None
     request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
@@ -10,7 +11,7 @@ def _convert_request(request, files=None):
         request.set_formdata_body(files)
     return request
 {% endif %}
-{% if code_model.need_format_url %}
+{% if code_model.need_format_url and not async_mode %}
 
 def _format_url_section(template, **kwargs):
     components = template.split("/")
@@ -24,3 +25,12 @@ def _format_url_section(template, **kwargs):
             ]
             template = "/".join(components)
 {% endif %}
+{% if code_model.need_mixin_abc %}
+
+class MixinABC(ABC):
+    """DO NOT use this class. It is for internal typing use only."""
+    _client: "{{ keywords.async_class }}PipelineClient"
+    _config: {{ code_model.class_name }}Configuration
+    _serialize: "Serializer"
+    _deserialize: "Deserializer"
+{% 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
 

package/autorest/multiapi/models/client.py

@@ -9,54 +9,64 @@ from typing import Any, Dict, List
 from pathlib import Path
 from .imports import FileImport
 
+
 def _extract_version(metadata_json: Dict[str, Any], version_path: Path) -> str:
-    version = metadata_json['chosen_version']
-    total_api_version_list = metadata_json['total_api_version_list']
+    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}")
     return version
 
+
 class Client:
     def __init__(
         self,
         azure_arm: bool,
         default_version_metadata: Dict[str, Any],
-        version_path_to_metadata: Dict[Path, Dict[str, Any]]
+        version_path_to_metadata: Dict[Path, Dict[str, Any]],
     ):
         self.name = default_version_metadata["client"]["name"]
         self.pipeline_client = "ARMPipelineClient" if azure_arm else "PipelineClient"
         self.filename = default_version_metadata["client"]["filename"]
         self.host_value = default_version_metadata["client"]["host_value"]
         self.description = default_version_metadata["client"]["description"]
-        self.client_side_validation = default_version_metadata["client"]["client_side_validation"]
+        self.client_side_validation = default_version_metadata["client"][
+            "client_side_validation"
+        ]
         self.default_version_metadata = default_version_metadata
         self.version_path_to_metadata = version_path_to_metadata
 
     def imports(self, async_mode: bool) -> FileImport:
         imports_to_load = "async_imports" if async_mode else "sync_imports"
-        return FileImport(json.loads(self.default_version_metadata['client'][imports_to_load]))
+        return FileImport(
+            json.loads(self.default_version_metadata["client"][imports_to_load])
+        )
 
     @property
     def parameterized_host_template_to_api_version(self) -> Dict[str, List[str]]:
         parameterized_host_template_to_api_version: Dict[str, List[str]] = {}
         for version_path, metadata_json in self.version_path_to_metadata.items():
-            parameterized_host_template = metadata_json["client"]["parameterized_host_template"]
+            parameterized_host_template = metadata_json["client"][
+                "parameterized_host_template"
+            ]
             version = _extract_version(metadata_json, version_path)
-            parameterized_host_template_to_api_version.setdefault(parameterized_host_template, []).append(version)
+            parameterized_host_template_to_api_version.setdefault(
+                parameterized_host_template, []
+            ).append(version)
         return parameterized_host_template_to_api_version
 
     @property
     def has_lro_operations(self) -> bool:
         has_lro_operations = False
         for _, metadata_json in self.version_path_to_metadata.items():
-            current_client_has_lro_operations = metadata_json["client"]["has_lro_operations"]
+            current_client_has_lro_operations = metadata_json["client"][
+                "has_lro_operations"
+            ]
             if current_client_has_lro_operations:
                 has_lro_operations = True
         return has_lro_operations