@autorest/python 6.13.16 → 6.13.17

package/autorest/codegen/serializers/client_serializer.py

@@ -19,9 +19,7 @@ class ClientSerializer:
     def _init_signature(self, async_mode: bool) -> str:
         pylint_disable = ""
         if not self.client.parameters.credential:
-            pylint_disable = (
-                "  # pylint: disable=missing-client-constructor-parameter-credential"
-            )
+            pylint_disable = "  # pylint: disable=missing-client-constructor-parameter-credential"
         return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name="__init__",
@@ -61,14 +59,10 @@ class ClientSerializer:
         operations_folder = ".aio.operations." if async_mode else ".operations."
         for og in [og for og in self.client.operation_groups if not og.is_mixin]:
             retval.append(f":ivar {og.property_name}: {og.class_name} operations")
-            property_type = (
-                f"{self.client.code_model.namespace}{operations_folder}{og.class_name}"
-            )
+            property_type = f"{self.client.code_model.namespace}{operations_folder}{og.class_name}"
             retval.append(f":vartype {og.property_name}: {property_type}")
         for param in self.client.parameters.method:
-            retval.append(
-                f":{param.description_keyword} {param.client_name}: {param.description}"
-            )
+            retval.append(f":{param.description_keyword} {param.client_name}: {param.description}")
             retval.append(
                 f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
             )
@@ -102,26 +96,18 @@ class ClientSerializer:
 
     @property
     def should_init_super(self) -> bool:
-        return any(
-            og
-            for og in self.client.operation_groups
-            if og.is_mixin and og.has_abstract_operations
-        )
+        return any(og for og in self.client.operation_groups if og.is_mixin and og.has_abstract_operations)
 
     def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
-        endpoint_name = (
-            "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
-        )
+        endpoint_name = "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
         params = {
             endpoint_name: self.host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:
-            result.append(
-                f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"'
-            )
+            result.append(f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"')
         policies = build_policies(
             self.client.code_model.options["azure_arm"],
             async_mode,
@@ -152,33 +138,23 @@ class ClientSerializer:
             add_private_models = len(self.client.code_model.model_types) != len(
                 self.client.code_model.public_model_types
             )
-            model_dict_name = (
-                f"_models.{self.client.code_model.models_filename}"
-                if add_private_models
-                else "_models"
-            )
+            model_dict_name = f"_models.{self.client.code_model.models_filename}" if add_private_models else "_models"
             retval.append(
                 f"client_models{': Dict[str, Any]' if not self.client.code_model.model_types else ''}"
                 f" = {_get_client_models_value(model_dict_name)}"
             )
             if add_private_models and self.client.code_model.model_types:
-                update_dict = (
-                    "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
-                )
+                update_dict = "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
                 retval.append(f"client_models.update({update_dict})")
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
         if not self.client.code_model.options["client_side_validation"]:
             retval.append("self._serialize.client_side_validation = False")
-        operation_groups = [
-            og for og in self.client.operation_groups if not og.is_mixin
-        ]
+        operation_groups = [og for og in self.client.operation_groups if not og.is_mixin]
         for og in operation_groups:
             if og.code_model.options["multiapi"]:
-                api_version = (
-                    f", '{og.api_versions[0]}'" if og.api_versions else ", None"
-                )
+                api_version = f", '{og.api_versions[0]}'" if og.api_versions else ", None"
             else:
                 api_version = ""
             retval.extend(
@@ -201,22 +177,16 @@ class ClientSerializer:
             method_param_signatures=send_request_signature,
         )
 
-    def send_request_signature_and_response_type_annotation(
-        self, async_mode: bool
-    ) -> str:
+    def send_request_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         send_request_signature = self._send_request_signature()
         return utils.method_signature_and_response_type_annotation_template(
             method_signature=send_request_signature,
-            response_type_annotation=(
-                "Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse"
-            ),
+            response_type_annotation=("Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse"),
         )
 
     def _example_make_call(self, async_mode: bool) -> List[str]:
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval = [
-            f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"
-        ]
+        retval = [f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"]
         retval.append(f"<{http_response}: 200 OK>")
         return retval
 
@@ -225,36 +195,26 @@ class ClientSerializer:
             "We have helper methods to create requests specific to this service in "
             + f"`{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}`."
         ]
-        retval.append(
-            "Use these helper methods to create the request you pass to this method."
-        )
+        retval.append("Use these helper methods to create the request you pass to this method.")
         retval.append("")
 
         request_builder = self.client.request_builders[0]
         request_builder_signature = ", ".join(request_builder.parameters.call)
         if request_builder.group_name:
             rest_imported = request_builder.group_name
-            request_builder_name = (
-                f"{request_builder.group_name}.{request_builder.name}"
-            )
+            request_builder_name = f"{request_builder.group_name}.{request_builder.name}"
         else:
             rest_imported = request_builder.name
             request_builder_name = request_builder.name
         full_path = f"{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}"
         retval.append(f">>> from {full_path} import {rest_imported}")
-        retval.append(
-            f">>> request = {request_builder_name}({request_builder_signature})"
-        )
-        retval.append(
-            f"<HttpRequest [{request_builder.method}], url: '{request_builder.url}'>"
-        )
+        retval.append(f">>> request = {request_builder_name}({request_builder_signature})")
+        retval.append(f"<HttpRequest [{request_builder.method}], url: '{request_builder.url}'>")
         retval.extend(self._example_make_call(async_mode))
         return retval
 
     def _rest_request_example(self, async_mode: bool) -> List[str]:
-        retval = [
-            f">>> from {self.client.code_model.core_library}.rest import HttpRequest"
-        ]
+        retval = [f">>> from {self.client.code_model.core_library}.rest import HttpRequest"]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
@@ -269,27 +229,19 @@ class ClientSerializer:
         else:
             retval.extend(self._rest_request_example(async_mode))
         retval.append("")
-        retval.append(
-            "For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request"
-        )
+        retval.append("For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request")
         retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
         retval.append(f":type request: ~{rest_library}.HttpRequest")
-        retval.append(
-            ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
-        )
-        retval.append(
-            ":return: The response of your network call. Does not do error handling on your response."
-        )
+        retval.append(":keyword bool stream: Whether the response payload will be streamed. Defaults to False.")
+        retval.append(":return: The response of your network call. Does not do error handling on your response.")
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
         retval.append(f":rtype: ~{rest_library}.{http_response}")
         retval.append('"""')
         return retval
 
     def serialize_path(self) -> List[str]:
-        return self.parameter_serializer.serialize_path(
-            self.client.parameters.path, "self._serialize"
-        )
+        return self.parameter_serializer.serialize_path(self.client.parameters.path, "self._serialize")
 
 
 class ConfigSerializer:
@@ -302,9 +254,7 @@ class ConfigSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.client.config.parameters.method_signature(
-                async_mode
-            ),
+            method_param_signatures=self.client.config.parameters.method_signature(async_mode),
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
@@ -331,8 +281,7 @@ class ConfigSerializer:
 
     def check_required_parameters(self) -> List[str]:
         return [
-            f"if {p.client_name} is None:\n"
-            f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
+            f"if {p.client_name} is None:\n" f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
             for p in self.client.config.parameters.method
             if not (p.optional or p.constant)
         ]
@@ -341,8 +290,6 @@ class ConfigSerializer:
         retval: List[str] = []
         for p in self.client.config.parameters.method:
             retval.append(f":{p.description_keyword} {p.client_name}: {p.description}")
-            retval.append(
-                f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}"
-            )
+            retval.append(f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}")
         retval.append('"""')
         return retval

package/autorest/codegen/serializers/enum_serializer.py

@@ -12,6 +12,4 @@ class EnumSerializer(BaseSerializer):
     def serialize(self) -> str:
         # Generate the enum file
         template = self.env.get_template("enum_container.py.jinja2")
-        return template.render(
-            code_model=self.code_model, file_import=FileImport(self.code_model)
-        )
+        return template.render(code_model=self.code_model, file_import=FileImport(self.code_model))

package/autorest/codegen/serializers/general_serializer.py

@@ -35,9 +35,7 @@ class GeneralSerializer(BaseSerializer):
         template = self.env.get_template(template_name)
         package_parts = (self.code_model.options["package_name"] or "").split("-")[:-1]
         token_credential = any(
-            c
-            for c in self.code_model.clients
-            if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
+            c for c in self.code_model.clients if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
         )
         version = self.code_model.options["package_version"]
         if any(x in version for x in ["a", "b", "rc"]) or version[0] == "0":
@@ -48,13 +46,8 @@ class GeneralSerializer(BaseSerializer):
             "code_model": self.code_model,
             "dev_status": dev_status,
             "token_credential": token_credential,
-            "pkgutil_names": [
-                ".".join(package_parts[: i + 1]) for i in range(len(package_parts))
-            ],
-            "init_names": [
-                "/".join(package_parts[: i + 1]) + "/__init__.py"
-                for i in range(len(package_parts))
-            ],
+            "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
+            "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
             "client_name": self.code_model.clients[0].name,
             "namespace": self.code_model.namespace,
         }
@@ -131,10 +124,7 @@ class GeneralSerializer(BaseSerializer):
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
-        if (
-            self.code_model.has_form_data
-            and self.code_model.options["models_mode"] == "dpg"
-        ):
+        if self.code_model.has_form_data and self.code_model.options["models_mode"] == "dpg" and not self.async_mode:
             file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
@@ -190,9 +180,7 @@ class GeneralSerializer(BaseSerializer):
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
-        return template.render(
-            code_model=self.code_model, file_import=FileImport(self.code_model)
-        )
+        return template.render(code_model=self.code_model, file_import=FileImport(self.code_model))
 
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")
@@ -213,11 +201,7 @@ class GeneralSerializer(BaseSerializer):
             {
                 (
                     f"{self.code_model.namespace}.{client.name}."
-                    + (
-                        ""
-                        if operation_group.is_mixin
-                        else f"{operation_group.property_name}."
-                    )
+                    + ("" if operation_group.is_mixin else f"{operation_group.property_name}.")
                     + f"{operation.name}"
                 ): operation.cross_language_definition_id
                 for client in self.code_model.clients

package/autorest/codegen/serializers/import_serializer.py

@@ -17,15 +17,12 @@ from ..models.imports import (
 def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
     buffer = []
     if any(i for i in imports if i.submodule_name is None):
-        buffer.append(
-            f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}"
-        )
+        buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
     else:
         import_str = ", ".join(
             sorted(
                 set(
-                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name  # type: ignore
-                    for i in imports
+                    f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports  # type: ignore
                 )
             )
         )
@@ -38,9 +35,7 @@ def _serialize_versioned_package(i: ImportModel, delimiter: str) -> str:
         return ""
     buffer = []
     for n, (version, module_name, comment) in enumerate(i.version_modules):
-        buffer.append(
-            "{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version)
-        )
+        buffer.append("{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version))
         buffer.append(
             f"    from {module_name} import {i.submodule_name}{f' as {i.alias}' if i.alias else ''}"
             f"{f' # {comment}' if comment else ''}"
@@ -57,12 +52,8 @@ def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
     """Serialize a given import type."""
     import_list = []
     for module_name in sorted(set(i.module_name for i in imports)):
-        normal_imports = [
-            i for i in imports if i.module_name == module_name and not i.version_modules
-        ]
-        versioned_imports = [
-            i for i in imports if i.module_name == module_name and i.version_modules
-        ]
+        normal_imports = [i for i in imports if i.module_name == module_name and not i.version_modules]
+        versioned_imports = [i for i in imports if i.module_name == module_name and i.version_modules]
         if normal_imports:
             import_list.append(_serialize_package(normal_imports, delimiter))
         for i in versioned_imports:
@@ -75,9 +66,7 @@ def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]
     for import_type in ImportType:
         imports_with_import_type = [i for i in imports if i.import_type == import_type]
         if imports_with_import_type:
-            import_clause.append(
-                _serialize_import_type(imports_with_import_type, delimiter)
-            )
+            import_clause.append(_serialize_import_type(imports_with_import_type, delimiter))
     return import_clause
 
 
@@ -86,15 +75,11 @@ class FileImportSerializer:
         self.file_import = file_import
         self.async_mode = async_mode
 
-    def _get_imports_list(
-        self, baseline_typing_section: TypingSection, add_conditional_typing: bool
-    ):
+    def _get_imports_list(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 any(
-            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
-        ):
+        if add_conditional_typing and any(self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)):
             # we switch the TypingSection key for the CONDITIONAL typing imports so we can merge
             # the imports together
             for i in file_import_copy.imports:
@@ -104,20 +89,12 @@ class FileImportSerializer:
 
     def _add_type_checking_import(self):
         if any(self.file_import.get_imports_from_section(TypingSection.TYPING)):
-            self.file_import.add_submodule_import(
-                "typing", "TYPE_CHECKING", ImportType.STDLIB
-            )
+            self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def get_typing_definitions(self) -> str:
-        def declare_definition(
-            type_name: str, type_definition: TypeDefinition
-        ) -> List[str]:
+        def declare_definition(type_name: str, type_definition: TypeDefinition) -> List[str]:
             ret: List[str] = []
-            definition_value = (
-                type_definition.async_definition
-                if self.async_mode
-                else type_definition.sync_definition
-            )
+            definition_value = type_definition.async_definition if self.async_mode else type_definition.sync_definition
             ret.append("{} = {}".format(type_name, definition_value))
             return ret
 
@@ -137,9 +114,7 @@ class FileImportSerializer:
         )
 
         if regular_imports_list:
-            regular_imports = "\n\n".join(
-                _get_import_clauses(regular_imports_list, "\n")
-            )
+            regular_imports = "\n\n".join(_get_import_clauses(regular_imports_list, "\n"))
 
         typing_imports = ""
         typing_imports_list = self._get_imports_list(
@@ -148,7 +123,5 @@ class FileImportSerializer:
         )
         if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(
-                _get_import_clauses(typing_imports_list, "\n    ")
-            )
+            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_list, "\n    "))
         return regular_imports + typing_imports + self.get_typing_definitions()

package/autorest/codegen/serializers/metadata_serializer.py

@@ -87,9 +87,7 @@ def _mixin_imports(
     sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
     async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
 
-    return _json_serialize_imports(
-        sync_mixin_imports.to_dict()
-    ), _json_serialize_imports(async_mixin_imports.to_dict())
+    return _json_serialize_imports(sync_mixin_imports.to_dict()), _json_serialize_imports(async_mixin_imports.to_dict())
 
 
 def _mixin_typing_definitions(
@@ -100,12 +98,8 @@ def _mixin_typing_definitions(
 
     sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
     async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
-    sync_mixin_typing_definitions = FileImportSerializer(
-        sync_mixin_imports, False
-    ).get_typing_definitions()
-    async_mixin_typing_definitions = FileImportSerializer(
-        async_mixin_imports, True
-    ).get_typing_definitions()
+    sync_mixin_typing_definitions = FileImportSerializer(sync_mixin_imports, False).get_typing_definitions()
+    async_mixin_typing_definitions = FileImportSerializer(async_mixin_imports, True).get_typing_definitions()
 
     return sync_mixin_typing_definitions, async_mixin_typing_definitions
 
@@ -127,9 +121,7 @@ class MetadataSerializer:
         total_api_version_list.sort()
 
         # switching ' to " so json can decode the dict we end up writing to file
-        total_api_version_list = [
-            str(api_version).replace("'", '"') for api_version in total_api_version_list
-        ]
+        total_api_version_list = [str(api_version).replace("'", '"') for api_version in total_api_version_list]
         if len(total_api_version_list) == 1:
             chosen_version = total_api_version_list[0]
         elif len(total_api_version_list) > 1:
@@ -156,9 +148,7 @@ class MetadataSerializer:
             ),
             None,
         )
-        mixin_operations = (
-            mixin_operation_group.operations if mixin_operation_group else []
-        )
+        mixin_operations = mixin_operation_group.operations if mixin_operation_group else []
         sync_mixin_imports, async_mixin_imports = _mixin_imports(mixin_operation_group)
         (
             sync_mixin_typing_definitions,
@@ -186,12 +176,8 @@ class MetadataSerializer:
             async_mixin_imports=async_mixin_imports,
             sync_mixin_typing_definitions=sync_mixin_typing_definitions,
             async_mixin_typing_definitions=async_mixin_typing_definitions,
-            sync_client_imports=_json_serialize_imports(
-                self.client.imports_for_multiapi(async_mode=False).to_dict()
-            ),
-            async_client_imports=_json_serialize_imports(
-                self.client.imports_for_multiapi(async_mode=True).to_dict()
-            ),
+            sync_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=False).to_dict()),
+            async_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=True).to_dict()),
             sync_config_imports=_json_serialize_imports(
                 self.client.config.imports_for_multiapi(async_mode=False).to_dict()
             ),

package/autorest/codegen/serializers/model_init_serializer.py

@@ -15,11 +15,7 @@ class ModelInitSerializer:
     def serialize(self) -> str:
         schemas = [s.name for s in self.code_model.public_model_types]
         schemas.sort()
-        enums = (
-            [e.name for e in self.code_model.enums if not e.internal]
-            if self.code_model.enums
-            else None
-        )
+        enums = [e.name for e in self.code_model.enums if not e.internal] if self.code_model.enums else None
 
         if enums:
             enums.sort()

package/autorest/codegen/serializers/model_serializer.py

@@ -12,16 +12,12 @@ from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
 
 
-def _documentation_string(
-    prop: Property, description_keyword: str, docstring_type_keyword: str
-) -> List[str]:
+def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> List[str]:
     retval: List[str] = []
     sphinx_prefix = f":{description_keyword} {prop.client_name}:"
     description = prop.description(is_operation_file=False).replace("\\", "\\\\")
     retval.append(f"{sphinx_prefix} {description}" if description else sphinx_prefix)
-    retval.append(
-        f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}"
-    )
+    retval.append(f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}")
     return retval
 
 
@@ -60,9 +56,7 @@ class _ModelSerializer(BaseSerializer, ABC):
 
     @staticmethod
     def initialize_discriminator_property(model: ModelType, prop: Property) -> str:
-        discriminator_value = (
-            f"'{model.discriminator_value}'" if model.discriminator_value else None
-        )
+        discriminator_value = f"'{model.discriminator_value}'" if model.discriminator_value else None
         if not discriminator_value:
             typing = "Optional[str]"
         else:
@@ -87,11 +81,7 @@ class _ModelSerializer(BaseSerializer, ABC):
 
     @staticmethod
     def _init_line_parameters(model: ModelType):
-        return [
-            p
-            for p in model.properties
-            if not p.readonly and not p.is_discriminator and not p.constant
-        ]
+        return [p for p in model.properties if not p.readonly and not p.is_discriminator and not p.constant]
 
     def init_line(self, model: ModelType) -> List[str]:
         init_properties_declaration = []
@@ -109,15 +99,8 @@ class _ModelSerializer(BaseSerializer, ABC):
         properties_to_pass_to_super = []
         for parent in model.parents:
             for prop in model.properties:
-                if (
-                    prop in parent.properties
-                    and not prop.is_discriminator
-                    and not prop.constant
-                    and not prop.readonly
-                ):
-                    properties_to_pass_to_super.append(
-                        f"{prop.client_name}={prop.client_name}"
-                    )
+                if prop in parent.properties and not prop.is_discriminator and not prop.constant and not prop.readonly:
+                    properties_to_pass_to_super.append(f"{prop.client_name}={prop.client_name}")
         properties_to_pass_to_super.append("**kwargs")
         return ", ".join(properties_to_pass_to_super)
 
@@ -176,9 +159,7 @@ class MsrestModelSerializer(_ModelSerializer):
     @staticmethod
     def declare_property(prop: Property) -> str:
         if prop.flattened_names:
-            attribute_key = ".".join(
-                _ModelSerializer.escape_dot(n) for n in prop.flattened_names
-            )
+            attribute_key = ".".join(_ModelSerializer.escape_dot(n) for n in prop.flattened_names)
         else:
             attribute_key = _ModelSerializer.escape_dot(prop.wire_name)
         if prop.type.xml_serialization_ctxt:
@@ -219,9 +200,7 @@ class DpgModelSerializer(_ModelSerializer):
             if model.is_polymorphic:
                 file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             if not model.internal and self.init_line(model):
-                file_import.add_submodule_import(
-                    "typing", "overload", ImportType.STDLIB
-                )
+                file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
         return file_import
@@ -271,11 +250,7 @@ class DpgModelSerializer(_ModelSerializer):
             args.append(f'format="{prop.type.encode}"')  # type: ignore
 
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
-        type_ignore = (
-            prop.is_discriminator
-            and isinstance(prop.type, (ConstantType, EnumValue))
-            and prop.type.value
-        )
+        type_ignore = prop.is_discriminator and isinstance(prop.type, (ConstantType, EnumValue)) and prop.type.value
         return (
             f"{prop.client_name}: {prop.type_annotation()} ="
             f' {field}({", ".join(args)}){"  # type: ignore" if type_ignore else ""}'
@@ -285,10 +260,7 @@ class DpgModelSerializer(_ModelSerializer):
         init_args = []
         for prop in self.get_properties_to_declare(model):
             if prop.constant and not prop.is_base_discriminator:
-                init_args.append(
-                    f"self.{prop.client_name}: {prop.type_annotation()} = "
-                    f"{prop.get_declaration()}"
-                )
+                init_args.append(f"self.{prop.client_name}: {prop.type_annotation()} = " f"{prop.get_declaration()}")
         return init_args
 
     @staticmethod
@@ -296,10 +268,7 @@ class DpgModelSerializer(_ModelSerializer):
         return [
             p
             for p in model.properties
-            if p.is_base_discriminator
-            or not p.is_discriminator
-            and not p.constant
-            and p.visibility != ["read"]
+            if p.is_base_discriminator or not p.is_discriminator and not p.constant and p.visibility != ["read"]
         ]
 
     @staticmethod
@@ -308,18 +277,11 @@ class DpgModelSerializer(_ModelSerializer):
         for parent in model.parents:
             for prop in model.properties:
                 if (
-                    prop.client_name
-                    in [
-                        prop.client_name
-                        for prop in parent.properties
-                        if prop.is_base_discriminator
-                    ]
+                    prop.client_name in [prop.client_name for prop in parent.properties if prop.is_base_discriminator]
                     and prop.is_discriminator
                     and not prop.constant
                     and not prop.readonly
                 ):
-                    properties_to_pass_to_super.append(
-                        f"{prop.client_name}={prop.get_declaration()}"
-                    )
+                    properties_to_pass_to_super.append(f"{prop.client_name}={prop.get_declaration()}")
         properties_to_pass_to_super.append("**kwargs")
         return ", ".join(properties_to_pass_to_super)

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -66,9 +66,7 @@ class OperationGroupsSerializer(BaseSerializer):
                 )
             )
 
-        template = self.env.get_or_select_template(
-            "operation_groups_container.py.jinja2"
-        )
+        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
 
         return template.render(
             code_model=self.code_model,