@autorest/python 6.13.16 → 6.13.17

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -25,11 +25,7 @@ class OperationsInitSerializer:
 
     def operation_group_imports(self) -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            return (
-                "_operations"
-                if self.code_model.options["combine_operation_files"]
-                else operation_group.filename
-            )
+            return "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
 
         return [
             f"from .{_get_filename(og)} import {og.class_name}"
@@ -38,9 +34,7 @@ class OperationsInitSerializer:
         ]
 
     def serialize(self) -> str:
-        operation_group_init_template = self.env.get_template(
-            "operations_folder_init.py.jinja2"
-        )
+        operation_group_init_template = self.env.get_template("operations_folder_init.py.jinja2")
 
         return operation_group_init_template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/parameter_serializer.py

@@ -121,9 +121,7 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    ParameterSerializer.serialize_parameter(
-                        path_parameter, serializer_name
-                    ),
+                    ParameterSerializer.serialize_parameter(path_parameter, serializer_name),
                 )
                 for path_parameter in parameters
             ]
@@ -172,9 +170,7 @@ class ParameterSerializer:
 
         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 {{}}')
 
@@ -189,35 +185,21 @@ class ParameterSerializer:
                     default_value = f"self._config.{kwarg.client_name}"
                 else:
                     default_value = kwarg.client_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"
-                    )
+                if check_kwarg_dict and (kwarg.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]):
+                    kwarg_dict = "headers" if kwarg.location == ParameterLocation.HEADER else "params"
                     if (
                         kwarg.client_name == "api_version"
                         and kwarg.code_model.options["multiapi"]
                         and operation_name is not None
                     ):
-                        default_value = (
-                            f"self._api_version{operation_name} or {default_value}"
-                        )
-                    default_value = (
-                        f"_{kwarg_dict}.pop('{kwarg.wire_name}', {default_value})"
-                    )
+                        default_value = f"self._api_version{operation_name} or {default_value}"
+                    default_value = f"_{kwarg_dict}.pop('{kwarg.wire_name}', {default_value})"
 
                 retval.append(
-                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}', "
-                    + f"{default_value})"
+                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}', " + f"{default_value})"
                 )
             else:
-                retval.append(
-                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')"
-                )
+                retval.append(f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')")
         return retval
 
     @staticmethod

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -48,7 +48,5 @@ class RequestBuildersSerializer(BaseSerializer):
             imports=FileImportSerializer(
                 self.imports,
             ),
-            request_builder_serializer=RequestBuilderSerializer(
-                self.code_model, async_mode=False
-            ),
+            request_builder_serializer=RequestBuilderSerializer(self.code_model, async_mode=False),
         )

package/autorest/codegen/serializers/sample_serializer.py

@@ -42,31 +42,23 @@ class SampleSerializer(BaseSerializer):
         self.operation = operation
         self.sample = sample
         self.file_name = file_name
-        self.sample_params = {
-            to_snake_case(k): v for k, v in sample.get("parameters", {}).items()
-        }
+        self.sample_params = {to_snake_case(k): v for k, v in sample.get("parameters", {}).items()}
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport(self.code_model)
-        namespace_from_package_name = get_namespace_from_package_name(
-            self.code_model.options["package_name"]
-        )
-        namespace_config = get_namespace_config(
-            self.code_model.namespace, self.code_model.options["multiapi"]
-        )
+        namespace_from_package_name = get_namespace_from_package_name(self.code_model.options["package_name"])
+        namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
         namespace = namespace_from_package_name or namespace_config
         # mainly for "azure-mgmt-rdbms"
-        if not self.code_model.options["multiapi"] and namespace_config.count(
+        if not self.code_model.options["multiapi"] and namespace_config.count(".") > namespace_from_package_name.count(
             "."
-        ) > namespace_from_package_name.count("."):
+        ):
             namespace = namespace_config
         client = self.code_model.clients[0]
         imports.add_submodule_import(namespace, client.name, ImportType.LOCAL)
         credential_type = getattr(client.credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
-            imports.add_submodule_import(
-                "azure.identity", "DefaultAzureCredential", ImportType.SDKCORE
-            )
+            imports.add_submodule_import("azure.identity", "DefaultAzureCredential", ImportType.SDKCORE)
         elif isinstance(credential_type, KeyCredentialType):
             imports.add_import("os", ImportType.STDLIB)
             imports.add_submodule_import(
@@ -75,11 +67,7 @@ class SampleSerializer(BaseSerializer):
                 ImportType.SDKCORE,
             )
         for param in self.operation.parameters.positional:
-            if (
-                not param.client_default_value
-                and not param.optional
-                and param.client_name in self.sample_params
-            ):
+            if not param.client_default_value and not param.optional and param.client_name in self.sample_params:
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
@@ -90,14 +78,10 @@ class SampleSerializer(BaseSerializer):
         if isinstance(credential_type, TokenCredentialType):
             special_param.update({"credential": "DefaultAzureCredential()"})
         elif isinstance(credential_type, KeyCredentialType):
-            special_param.update(
-                {"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'}
-            )
+            special_param.update({"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'})
 
         params_positional = [
-            p
-            for p in self.code_model.clients[0].parameters.positional
-            if not (p.optional or p.client_default_value)
+            p for p in self.code_model.clients[0].parameters.positional if not (p.optional or p.client_default_value)
         ]
         client_params = {
             p.client_name: special_param.get(
@@ -119,11 +103,7 @@ class SampleSerializer(BaseSerializer):
 
     # prepare operation parameters
     def _operation_params(self) -> Dict[str, Any]:
-        params_positional = [
-            p
-            for p in self.operation.parameters.positional
-            if not p.client_default_value
-        ]
+        params_positional = [p for p in self.operation.parameters.positional if not p.client_default_value]
         failure_info = "fail to find required param named {}"
         operation_params = {}
         for param in params_positional:
@@ -131,12 +111,8 @@ class SampleSerializer(BaseSerializer):
             param_value = self.sample_params.get(name)
             if not param.optional:
                 if not param_value:
-                    raise Exception(  # pylint: disable=broad-exception-raised
-                        failure_info.format(name)
-                    )
-                operation_params[param.client_name] = self.handle_param(
-                    param, param_value
-                )
+                    raise Exception(failure_info.format(name))  # pylint: disable=broad-exception-raised
+                operation_params[param.client_name] = self.handle_param(param, param_value)
         return operation_params
 
     def _operation_group_name(self) -> str:
@@ -145,9 +121,7 @@ class SampleSerializer(BaseSerializer):
         return f".{self.operation_group.property_name}"
 
     def _operation_result(self) -> Tuple[str, str]:
-        is_response_none = "None" in self.operation.response_type_annotation(
-            async_mode=False
-        )
+        is_response_none = "None" in self.operation.response_type_annotation(async_mode=False)
         lro = ".result()"
         if is_response_none:
             paging, normal_print, return_var = "", "", ""

package/autorest/codegen/serializers/test_serializer.py

@@ -119,9 +119,7 @@ class Test(TestName):
 
 
 class TestGeneralSerializer(BaseSerializer):
-    def __init__(
-        self, code_model: CodeModel, env: Environment, *, is_async: bool = False
-    ) -> None:
+    def __init__(self, code_model: CodeModel, env: Environment, *, is_async: bool = False) -> None:
         super().__init__(code_model, env)
         self.is_async = is_async
 
@@ -131,29 +129,19 @@ class TestGeneralSerializer(BaseSerializer):
 
     @property
     def test_names(self) -> List[TestName]:
-        return [
-            TestName(c.name, is_async=self.is_async) for c in self.code_model.clients
-        ]
+        return [TestName(c.name, is_async=self.is_async) for c in self.code_model.clients]
 
     @property
     def import_clients(self) -> FileImportSerializer:
         imports = self.init_file_import()
-        namespace = get_namespace_from_package_name(
-            self.code_model.options["package_name"]
-        )
+        namespace = get_namespace_from_package_name(self.code_model.options["package_name"])
 
-        imports.add_submodule_import(
-            "devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB
-        )
+        imports.add_submodule_import("devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB)
         if not self.is_async:
             imports.add_import("functools", ImportType.STDLIB)
-            imports.add_submodule_import(
-                "devtools_testutils", "PowerShellPreparer", ImportType.STDLIB
-            )
+            imports.add_submodule_import("devtools_testutils", "PowerShellPreparer", ImportType.STDLIB)
         for client in self.code_model.clients:
-            imports.add_submodule_import(
-                namespace + self.aio_str, client.name, ImportType.STDLIB
-            )
+            imports.add_submodule_import(namespace + self.aio_str, client.name, ImportType.STDLIB)
         return FileImportSerializer(imports, self.is_async)
 
     def serialize_conftest(self) -> str:
@@ -194,9 +182,7 @@ class TestSerializer(TestGeneralSerializer):
             test_name.base_test_class_name,
             ImportType.LOCAL,
         )
-        imports.add_submodule_import(
-            "testpreparer", test_name.preparer_name, ImportType.LOCAL
-        )
+        imports.add_submodule_import("testpreparer", test_name.preparer_name, ImportType.LOCAL)
         imports.add_submodule_import(
             "devtools_testutils" + self.aio_str,
             "recorded_by_proxy" + async_suffix,
@@ -235,9 +221,7 @@ class TestSerializer(TestGeneralSerializer):
         for param in required_params:
             model_type = self.get_model_type(param.type)
             param_type = self.get_sub_type(model_type) if model_type else param.type
-            operation_params[param.client_name] = json_dumps_template(
-                param_type.get_json_template_representation()
-            )
+            operation_params[param.client_name] = json_dumps_template(param_type.get_json_template_representation())
         return operation_params
 
     def get_test(self) -> Test:
@@ -255,9 +239,7 @@ class TestSerializer(TestGeneralSerializer):
                 )
                 testcases.append(testcase)
         if not testcases:
-            raise Exception(  # pylint: disable=broad-exception-raised
-                "no public operation to test"
-            )
+            raise Exception("no public operation to test")  # pylint: disable=broad-exception-raised
 
         return Test(
             client_name=self.client.name,
@@ -270,9 +252,7 @@ class TestSerializer(TestGeneralSerializer):
     @property
     def test_class_name(self) -> str:
         test_name = TestName(self.client.name, is_async=self.is_async)
-        class_name = (
-            "" if self.operation_group.is_mixin else self.operation_group.class_name
-        )
+        class_name = "" if self.operation_group.is_mixin else self.operation_group.class_name
         return f"Test{test_name.prefix}{class_name}{test_name.async_suffix_capt}"
 
     def serialize_test(self) -> str:

package/autorest/codegen/serializers/types_serializer.py

@@ -18,9 +18,7 @@ class TypesSerializer(BaseSerializer):
                 ImportType.STDLIB,
             )
         for nu in self.code_model.named_unions:
-            file_import.merge(
-                nu.imports(relative_path=".", model_typing=True, is_types_file=True)
-            )
+            file_import.merge(nu.imports(relative_path=".", model_typing=True, is_types_file=True))
         return file_import
 
     def serialize(self) -> str:

package/autorest/jsonrpc/__init__.py

@@ -114,9 +114,7 @@ class AutorestAPI(ABC):
     def message(self, channel: Channel, text: str) -> None:
         """Send a log message to autorest."""
 
-    def get_boolean_value(
-        self, key: str, default: Optional[bool] = None
-    ) -> Optional[bool]:
+    def get_boolean_value(self, key: str, default: Optional[bool] = None) -> Optional[bool]:
         """Check if value is present on the line, and interpret it as bool if it was.
 
         If value is not not on the line, return the "default".

package/autorest/jsonrpc/server.py

@@ -80,15 +80,11 @@ 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 debugpy  # pylint: disable=import-outside-toplevel
         except ImportError as exc:
-            raise SystemExit(
-                "Please pip install ptvsd in order to use VSCode debugging"
-            ) from exc
+            raise SystemExit("Please pip install ptvsd in order to use VSCode debugging") from exc
 
         # 5678 is the default attach port in the VS Code debug configurations
         debugpy.listen(("localhost", 5678))
@@ -101,9 +97,7 @@ def main() -> None:
         _LOGGER.debug("Trying to read")
         message = read_message()
 
-        response = typing.cast(
-            JSONRPC20Response, JSONRPCResponseManager.handle(message, dispatcher)
-        ).json
+        response = typing.cast(JSONRPC20Response, JSONRPCResponseManager.handle(message, dispatcher)).json
         _LOGGER.debug("Produced: %s", response)
         write_message(response)
         _LOGGER.debug("Message processed")

package/autorest/jsonrpc/stdstream.py

@@ -72,25 +72,19 @@ 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"]
 
@@ -101,7 +95,5 @@ 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

@@ -34,9 +34,7 @@ class M2R(YamlUpdatePlugin):  # pylint: disable=abstract-method
         """Convert in place the YAML str."""
         self._convert_docstring_no_cycles(yaml_data, set())
 
-    def _convert_docstring_no_cycles(
-        self, yaml_data: Union[Dict[str, Any], str], node_list: Set[int]
-    ) -> None:
+    def _convert_docstring_no_cycles(self, yaml_data: Union[Dict[str, Any], str], node_list: Set[int]) -> None:
         """Walk the YAML tree to convert MD to RST."""
         if id(yaml_data) in node_list:
             return
@@ -69,6 +67,4 @@ class M2RAutorest(YamlUpdatePluginAutorest, M2R):
 if __name__ == "__main__":
     # CADL pipeline will call this
     args, unknown_args = parse_args()
-    M2R(
-        output_folder=args.output_folder, cadl_file=args.cadl_file, **unknown_args
-    ).process()
+    M2R(output_folder=args.output_folder, cadl_file=args.cadl_file, **unknown_args).process()