@autorest/python 5.15.0 → 5.16.0

package/autorest/multiapi/serializers/import_serializer.py

@@ -7,21 +7,34 @@ from copy import deepcopy
 from typing import Dict, Set, Optional, List
 from ..models import ImportType, FileImport, TypingSection
 
-def _serialize_package(package_name: str, module_list: Set[Optional[str]], delimiter: str) -> str:
+
+def _serialize_package(
+    package_name: str, module_list: Set[Optional[str]], delimiter: str
+) -> str:
     buffer = []
     if None in module_list:
         buffer.append(f"import {package_name}")
     if module_list != {None}:
         buffer.append(
             "from {} import {}".format(
-                package_name, ", ".join(sorted([
-                    mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}" for mod in module_list if mod is not None
-                ]))
+                package_name,
+                ", ".join(
+                    sorted(
+                        [
+                            mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}"
+                            for mod in module_list
+                            if mod is not None
+                        ]
+                    )
+                ),
             )
         )
     return delimiter.join(buffer)
 
-def _serialize_type(import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str) -> str:
+
+def _serialize_type(
+    import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str
+) -> str:
     """Serialize a given import type."""
     import_list = []
     for package_name in sorted(list(import_type_dict.keys())):
@@ -29,7 +42,10 @@ def _serialize_type(import_type_dict: Dict[str, Set[Optional[str]]], delimiter:
         import_list.append(_serialize_package(package_name, module_list, delimiter))
     return delimiter.join(import_list)
 
-def _get_import_clauses(imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str) -> List[str]:
+
+def _get_import_clauses(
+    imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str
+) -> List[str]:
     import_clause = []
     for import_type in ImportType:
         if import_type in imports:
@@ -44,33 +60,44 @@ class FileImportSerializer:
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
-        switched_dictionary[new_key] = self._file_import.imports[TypingSection.CONDITIONAL]
+        switched_dictionary[new_key] = self._file_import.imports[
+            TypingSection.CONDITIONAL
+        ]
         return switched_dictionary
 
-    def _get_imports_dict(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
+    def _get_imports_dict(
+        self, baseline_typing_section: TypingSection, add_conditional_typing: bool
+    ):
         # If this is a python 3 file, our regular imports include the CONDITIONAL category
         # If this is not a python 3 file, our typing imports include the CONDITIONAL category
         file_import_copy = deepcopy(self._file_import)
-        if add_conditional_typing and self._file_import.imports.get(TypingSection.CONDITIONAL):
+        if add_conditional_typing and self._file_import.imports.get(
+            TypingSection.CONDITIONAL
+        ):
             # we switch the TypingSection key for the CONDITIONAL typing imports so we can merge
             # the imports together
-            switched_imports_dictionary = self._switch_typing_section_key(baseline_typing_section)
+            switched_imports_dictionary = self._switch_typing_section_key(
+                baseline_typing_section
+            )
             switched_imports = FileImport(switched_imports_dictionary)
             file_import_copy.merge(switched_imports)
         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) or (
+            not self.is_python3_file
+            and self._file_import.imports.get(TypingSection.CONDITIONAL)
         ):
-            self._file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+            self._file_import.add_submodule_import(
+                "typing", "TYPE_CHECKING", ImportType.STDLIB
+            )
 
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
+            baseline_typing_section=TypingSection.REGULAR,
+            add_conditional_typing=self.is_python3_file,
         )
 
         if regular_imports_dict:
@@ -80,10 +107,13 @@ class FileImportSerializer:
 
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
+            baseline_typing_section=TypingSection.TYPING,
+            add_conditional_typing=not self.is_python3_file,
         )
         if typing_imports_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_dict, "\n    "))
+            typing_imports += "\n\n    ".join(
+                _get_import_clauses(typing_imports_dict, "\n    ")
+            )
 
         return regular_imports + typing_imports

package/autorest/multiapi/serializers/multiapi_serializer.py

@@ -12,7 +12,11 @@ from ...jsonrpc import AutorestAPI
 
 class MultiAPISerializer:
     def __init__(
-        self, conf: Dict[str, Any], async_mode: bool, autorestapi: AutorestAPI, service_client_filename: str
+        self,
+        conf: Dict[str, Any],
+        async_mode: bool,
+        autorestapi: AutorestAPI,
+        service_client_filename: str,
     ):
         self.conf = conf
         self.async_mode = async_mode
@@ -33,64 +37,60 @@ class MultiAPISerializer:
         return Path(filename)
 
     def serialize(self):
-        self._autorestapi.write_file(self._get_file_path("__init__.py"), self.serialize_multiapi_init())
+        self._autorestapi.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._get_file_path(service_client_filename_with_py_extension),
-            self.serialize_multiapi_client()
+            self.serialize_multiapi_client(),
         )
 
         configuration_filename = "_configuration.py"
         self._autorestapi.write_file(
             self._get_file_path(configuration_filename),
-            self.serialize_multiapi_config()
+            self.serialize_multiapi_config(),
         )
 
         operation_mixins_filename = "_operations_mixin.py"
         if self.conf["mixin_operations"]:
             self._autorestapi.write_file(
                 self._get_file_path(operation_mixins_filename),
-                self.serialize_multiapi_operation_mixins()
+                self.serialize_multiapi_operation_mixins(),
             )
 
         if self._autorestapi.read_file("_version.py"):
             self._autorestapi.write_file(
-                "_version.py",
-                self._autorestapi.read_file("_version.py")
+                "_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")
+                "_version.py", self._autorestapi.read_file("version.py")
             )
         else:
             self._autorestapi.write_file(
-                Path("_version.py"),
-                self.serialize_multiapi_version()
+                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")
+                "_patch.py", self._autorestapi.read_file("_patch.py")
             )
 
         self._autorestapi.write_file(
-            Path("models.py"),
-            self.serialize_multiapi_models()
+            Path("models.py"), self.serialize_multiapi_models()
         )
 
         self._autorestapi.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")
         return template.render(
             service_client_filename=self.service_client_filename,
             client_name=self.conf["client_name"],
-            async_mode=self.async_mode
+            async_mode=self.async_mode,
         )
 
     def serialize_multiapi_client(self) -> str:

package/autorest/multiapi/templates/multiapi_operations_mixin.py.jinja2

@@ -34,5 +34,5 @@ class {{ code_model.service_client.name }}OperationsMixin(object):
         mixin_instance._serialize.client_side_validation = False
         {% endif %}
         mixin_instance._deserialize = Deserializer(self._models_dict(api_version))
-        return {{ "await " if mixin_operation.coroutine(async_mode) }}mixin_instance.{{ mixin_operation.name }}({{ mixin_operation.call }}{{ ", **kwargs" if  mixin_operation.call else "**kwargs" }})
+        return {{ "await " if mixin_operation.coroutine(async_mode) }}mixin_instance.{{ mixin_operation.name }}({{ mixin_operation.call(async_mode) }})
 {% endfor %}

package/autorest/multiapi/utils.py

@@ -12,14 +12,14 @@ _LOGGER = logging.getLogger(__name__)
 def _sync_or_async(async_mode: bool) -> str:
     return "async" if async_mode else "sync"
 
+
 def _get_default_api_version_from_list(
     mod_to_api_version: Dict[str, str],
     api_versions_list: List[str],
     preview_mode: bool,
-    user_specified_default_api: Optional[str]
+    user_specified_default_api: Optional[str],
 ) -> str:
-    """Get the floating latest, from a random list of API versions.
-    """
+    """Get the floating latest, from a random list of API versions."""
 
     # I need user_specified_default_api to be v2019_06_07_preview shaped if it exists, let's be smart
     # and change it automatically so I can take both syntax as input

package/autorest/namer/__init__.py

@@ -16,10 +16,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class Namer(YamlUpdatePlugin):
-    """Add Python naming information.
-    """
+    """Add Python naming information."""
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
-        """Convert in place the YAML str.
-        """
+        """Convert in place the YAML str."""
         NameConverter.convert_yaml_names(yaml_data)