@autorest/python 6.13.16 → 6.13.17

package/autorest/codegen/serializers/builder_serializer.py

@@ -86,9 +86,7 @@ def _escape_str(input_str: str) -> str:
 def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[str]:
     retval: List[str] = []
     retval.append("")
-    retval.append(
-        f'# JSON input template for discriminator value "{polymorphic_subtype.discriminator_value}":'
-    )
+    retval.append(f'# JSON input template for discriminator value "{polymorphic_subtype.discriminator_value}":')
     subtype_template = utils.json_dumps_template(
         polymorphic_subtype.get_json_template_representation(),
     )
@@ -99,18 +97,14 @@ def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[st
         if not polymorphic_subtype:
             return None
         try:
-            return next(
-                p for p in polymorphic_subtype.parents if p.discriminated_subtypes
-            )
+            return next(p for p in polymorphic_subtype.parents if p.discriminated_subtypes)
         except StopIteration:
             return None
 
     polymorphic_parent = _get_polymorphic_parent(polymorphic_subtype)
     while _get_polymorphic_parent(polymorphic_parent):
         polymorphic_parent = _get_polymorphic_parent(polymorphic_parent)
-    retval.extend(
-        f"{cast(ModelType, polymorphic_parent).snake_case_name} = {subtype_template}".splitlines()
-    )
+    retval.extend(f"{cast(ModelType, polymorphic_parent).snake_case_name} = {subtype_template}".splitlines())
     return retval
 
 
@@ -133,55 +127,37 @@ def _serialize_grouped_body(builder: BuilderType) -> List[str]:
 def _serialize_flattened_body(body_parameter: BodyParameter) -> List[str]:
     retval: List[str] = []
     if not body_parameter.property_to_parameter_name:
-        raise ValueError(
-            "This method can't be called if the operation doesn't need parameter flattening"
-        )
+        raise ValueError("This method can't be called if the operation doesn't need parameter flattening")
 
     parameter_string = ", ".join(
         f"{property_name}={parameter_name}"
         for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
     )
     model_type = cast(ModelType, body_parameter.type)
-    retval.append(
-        f"{body_parameter.client_name} = _models.{model_type.name}({parameter_string})"
-    )
+    retval.append(f"{body_parameter.client_name} = _models.{model_type.name}({parameter_string})")
     return retval
 
 
-def _serialize_json_model_body(
-    body_parameter: BodyParameter, parameters: List[ParameterType]
-) -> List[str]:
+def _serialize_json_model_body(body_parameter: BodyParameter, parameters: List[ParameterType]) -> List[str]:
     retval: List[str] = []
     if not body_parameter.property_to_parameter_name:
-        raise ValueError(
-            "This method can't be called if the operation doesn't need parameter flattening"
-        )
+        raise ValueError("This method can't be called if the operation doesn't need parameter flattening")
 
     retval.append(f"if {body_parameter.client_name} is _Unset:")
     for p in parameters:
-        if (
-            p.client_default_value is None
-            and not p.optional
-            and p.default_to_unset_sentinel
-        ):
+        if p.client_default_value is None and not p.optional and p.default_to_unset_sentinel:
             retval.append(f"    if {p.client_name} is _Unset:")
-            retval.append(
-                f"            raise TypeError('missing required argument: {p.client_name}')"
-            )
+            retval.append(f"            raise TypeError('missing required argument: {p.client_name}')")
     parameter_string = ", \n".join(
         f'"{property_name}": {parameter_name}'
         for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
     )
     model_type = cast(ModelType, body_parameter.type)
-    if isinstance(model_type, CombinedType) and model_type.target_model_subtype(
-        (JSONModelType,)
-    ):
+    if isinstance(model_type, CombinedType) and model_type.target_model_subtype((JSONModelType,)):
         model_type = model_type.target_model_subtype((JSONModelType,))
     retval.append(f"    {body_parameter.client_name} = {{{parameter_string}}}")
     retval.append(f"    {body_parameter.client_name} =  {{")
-    retval.append(
-        f"        k: v for k, v in {body_parameter.client_name}.items() if v is not None"
-    )
+    retval.append(f"        k: v for k, v in {body_parameter.client_name}.items() if v is not None")
     retval.append("    }")
     return retval
 
@@ -286,27 +262,20 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
     def method_signature_and_response_type_annotation(
         self, builder: BuilderType, *, want_decorators: Optional[bool] = True
     ) -> str:
-        response_type_annotation = builder.response_type_annotation(
-            async_mode=self.async_mode
-        )
+        response_type_annotation = builder.response_type_annotation(async_mode=self.async_mode)
         method_signature = self._method_signature(builder)
         decorators = self.decorators(builder)
         decorators_str = ""
         if decorators and want_decorators:
             decorators_str = "\n".join(decorators) + "\n"
-        return (
-            decorators_str
-            + utils.method_signature_and_response_type_annotation_template(
-                method_signature=method_signature,
-                response_type_annotation=response_type_annotation,
-            )
+        return decorators_str + utils.method_signature_and_response_type_annotation_template(
+            method_signature=method_signature,
+            response_type_annotation=response_type_annotation,
         )
 
     def description_and_summary(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
-        description_list.append(
-            f"{builder.summary.strip() if builder.summary else builder.description.strip()}"
-        )
+        description_list.append(f"{builder.summary.strip() if builder.summary else builder.description.strip()}")
         if builder.summary and builder.description:
             description_list.append("")
             description_list.append(builder.description.strip())
@@ -336,23 +305,17 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             ):
                 continue
             description_list.extend(
-                f":{param.description_keyword} {param.client_name}: {param.description}".replace(
-                    "\n", "\n "
-                ).split(
+                f":{param.description_keyword} {param.client_name}: {param.description}".replace("\n", "\n ").split(
                     "\n"
                 )
             )
             docstring_type = param.docstring_type(
                 async_mode=self.async_mode,
             )
-            description_list.append(
-                f":{param.docstring_type_keyword} {param.client_name}: {docstring_type}"
-            )
+            description_list.append(f":{param.docstring_type_keyword} {param.client_name}: {docstring_type}")
         return description_list
 
-    def param_description_and_response_docstring(
-        self, builder: BuilderType
-    ) -> List[str]:
+    def param_description_and_response_docstring(self, builder: BuilderType) -> List[str]:
         if builder.abstract:
             return []
         return self.param_description(builder) + self.response_docstring(builder)
@@ -363,17 +326,12 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     def _json_input_example_template(self, builder: BuilderType) -> List[str]:
         template: List[str] = []
-        if (
-            not builder.parameters.has_body
-            or builder.parameters.body_parameter.flattened
-        ):
+        if not builder.parameters.has_body or builder.parameters.body_parameter.flattened:
             # No input template if now body parameter
             return template
 
         body_param = builder.parameters.body_parameter
-        if not isinstance(
-            body_param.type, (ListType, DictionaryType, ModelType, CombinedType)
-        ):
+        if not isinstance(body_param.type, (ListType, DictionaryType, ModelType, CombinedType)):
             return template
 
         if (
@@ -387,9 +345,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
         json_type = body_param.type
         if isinstance(body_param.type, CombinedType):
-            target_model_type = body_param.type.target_model_subtype(
-                (JSONModelType, DPGModelType)
-            )
+            target_model_type = body_param.type.target_model_subtype((JSONModelType, DPGModelType))
             if target_model_type is None:
                 return template
             json_type = target_model_type
@@ -398,9 +354,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         json_type.get_polymorphic_subtypes(polymorphic_subtypes)
         if polymorphic_subtypes:
             # we just assume one kind of polymorphic body for input
-            discriminator_name = cast(
-                Property, polymorphic_subtypes[0].discriminator
-            ).wire_name
+            discriminator_name = cast(Property, polymorphic_subtypes[0].discriminator).wire_name
             template.append(
                 "# The input is polymorphic. The following are possible polymorphic "
                 f'inputs based off discriminator "{discriminator_name}":'
@@ -411,25 +365,17 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
                     len(polymorphic_subtypes),
                 )
             ):
-                template.extend(
-                    _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
-                )
+                template.extend(_get_polymorphic_subtype_template(polymorphic_subtypes[idx]))
             template.append("")
-        template.append(
-            "# JSON input template you can fill out and use as your body input."
-        )
+        template.append("# JSON input template you can fill out and use as your body input.")
         json_template = utils.json_dumps_template(
             json_type.get_json_template_representation(),
         )
-        template.extend(
-            f"{builder.parameters.body_parameter.client_name} = {json_template}".splitlines()
-        )
+        template.extend(f"{builder.parameters.body_parameter.client_name} = {json_template}".splitlines())
         return template
 
     def serialize_path(self, builder: BuilderType) -> List[str]:
-        return self.parameter_serializer.serialize_path(
-            builder.parameters.path, self.serializer_name
-        )
+        return self.parameter_serializer.serialize_path(builder.parameters.path, self.serializer_name)
 
     @property
     def pipeline_name(self) -> str:
@@ -439,9 +385,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 ############################## REQUEST BUILDERS ##############################
 
 
-class RequestBuilderSerializer(
-    _BuilderBaseSerializer[RequestBuilderType]
-):  # pylint: disable=abstract-method
+class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # pylint: disable=abstract-method
     def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
@@ -467,21 +411,11 @@ class RequestBuilderSerializer(
     def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
         def _get_value(param):
             if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
-                kwarg_dict = (
-                    "headers"
-                    if param.location == ParameterLocation.HEADER
-                    else "params"
-                )
-                return (
-                    f"_{kwarg_dict}.pop('{param.wire_name}', {param.get_declaration()})"
-                )
+                kwarg_dict = "headers" if param.location == ParameterLocation.HEADER else "params"
+                return f"_{kwarg_dict}.pop('{param.wire_name}', {param.get_declaration()})"
             return f"{param.get_declaration()}"
 
-        return [
-            f"{p.client_name} = {_get_value(p)}"
-            for p in builder.parameters.constant
-            if not p.in_method_signature
-        ]
+        return [f"{p.client_name} = {_get_value(p)}" for p in builder.parameters.constant if not p.in_method_signature]
 
     @property
     def _function_def(self) -> str:
@@ -505,16 +439,8 @@ class RequestBuilderSerializer(
         return self.parameter_serializer.pop_kwargs_from_signature(
             builder.parameters.kwargs_to_pop,
             check_kwarg_dict=True,
-            pop_headers_kwarg=(
-                PopKwargType.CASE_INSENSITIVE
-                if bool(builder.parameters.headers)
-                else PopKwargType.NO
-            ),
-            pop_params_kwarg=(
-                PopKwargType.CASE_INSENSITIVE
-                if bool(builder.parameters.query)
-                else PopKwargType.NO
-            ),
+            pop_headers_kwarg=(PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.headers) else PopKwargType.NO),
+            pop_params_kwarg=(PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.query) else PopKwargType.NO),
         )
 
     @staticmethod
@@ -526,15 +452,9 @@ class RequestBuilderSerializer(
             retval.append("    params=_params,")
         if builder.parameters.headers:
             retval.append("    headers=_headers,")
-        if (
-            builder.parameters.has_body
-            and builder.parameters.body_parameter.in_method_signature
-        ):
+        if builder.parameters.has_body and builder.parameters.body_parameter.in_method_signature:
             body_param = builder.parameters.body_parameter
-            if (
-                body_param.constant
-                or body_param.method_location != ParameterMethodLocation.KWARG
-            ):
+            if body_param.constant or body_param.method_location != ParameterMethodLocation.KWARG:
                 # we only need to pass it through if it's not a kwarg or it's a popped kwarg
                 retval.append(
                     f"    {builder.parameters.body_parameter.client_name}="
@@ -576,11 +496,7 @@ class RequestBuilderSerializer(
         return retval
 
     def construct_url(self, builder: RequestBuilderType) -> str:
-        if any(
-            o
-            for o in ["low_level_client", "version_tolerant"]
-            if self.code_model.options.get(o)
-        ):
+        if any(o for o in ["low_level_client", "version_tolerant"] if self.code_model.options.get(o)):
             url_value = _escape_str(builder.url)
         else:
             url_value = f'kwargs.pop("template_url", {_escape_str(builder.url)})'
@@ -590,9 +506,7 @@ class RequestBuilderSerializer(
 ############################## NORMAL OPERATIONS ##############################
 
 
-class _OperationSerializer(
-    _BuilderBaseSerializer[OperationType]
-):  # pylint: disable=abstract-method
+class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: disable=abstract-method
     def description_and_summary(self, builder: OperationType) -> List[str]:
         retval = super().description_and_summary(builder)
         if builder.deprecated:
@@ -620,9 +534,7 @@ class _OperationSerializer(
             response.get_polymorphic_subtypes(polymorphic_subtypes)
             if polymorphic_subtypes:
                 # we just assume one kind of polymorphic body for input
-                discriminator_name = cast(
-                    Property, polymorphic_subtypes[0].discriminator
-                ).wire_name
+                discriminator_name = cast(Property, polymorphic_subtypes[0].discriminator).wire_name
                 retval.append("")
                 retval.append(
                     "# The response is polymorphic. The following are possible polymorphic "
@@ -634,9 +546,7 @@ class _OperationSerializer(
                         len(polymorphic_subtypes),
                     )
                 ):
-                    retval.extend(
-                        _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
-                    )
+                    retval.extend(_get_polymorphic_subtype_template(polymorphic_subtypes[idx]))
 
         if _get_json_response_template_to_status_codes(builder):
             retval.append("")
@@ -644,14 +554,8 @@ class _OperationSerializer(
                 response_body,
                 status_codes,
             ) in _get_json_response_template_to_status_codes(builder).items():
-                retval.append(
-                    "# response body for status code(s): {}".format(
-                        ", ".join(status_codes)
-                    )
-                )
-                retval.extend(
-                    f"{self._json_response_template_name} == {response_body}".splitlines()
-                )
+                retval.append("# response body for status code(s): {}".format(", ".join(status_codes)))
+                retval.extend(f"{self._json_response_template_name} == {response_body}".splitlines())
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
@@ -697,16 +601,12 @@ class _OperationSerializer(
             check_kwarg_dict=True,
             pop_headers_kwarg=(
                 PopKwargType.CASE_INSENSITIVE
-                if builder.has_kwargs_to_pop_with_default(
-                    kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
-                )
+                if builder.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.HEADER)  # type: ignore
                 else PopKwargType.SIMPLE
             ),
             pop_params_kwarg=(
                 PopKwargType.CASE_INSENSITIVE
-                if builder.has_kwargs_to_pop_with_default(
-                    kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
-                )
+                if builder.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.QUERY)  # type: ignore
                 else PopKwargType.SIMPLE
             ),
             check_client_input=not self.code_model.options["multiapi"],
@@ -719,18 +619,12 @@ class _OperationSerializer(
         pylint_disable = ""
         if any(x.startswith("_") for x in cls_annotation.split(".")):
             pylint_disable = "  # pylint: disable=protected-access"
-        kwargs.append(
-            f"cls: {cls_annotation} = kwargs.pop({pylint_disable}\n    'cls', None\n)"
-        )
+        kwargs.append(f"cls: {cls_annotation} = kwargs.pop({pylint_disable}\n    'cls', None\n)")
         return kwargs
 
     def response_docstring(self, builder: OperationType) -> List[str]:
-        response_str = (
-            f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
-        )
-        rtype_str = (
-            f":rtype: {builder.response_docstring_type(async_mode=self.async_mode)}"
-        )
+        response_str = f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
+        rtype_str = f":rtype: {builder.response_docstring_type(async_mode=self.async_mode)}"
         return [
             response_str,
             rtype_str,
@@ -753,14 +647,8 @@ class _OperationSerializer(
                     else body_param.type
                 ),
             )
-            file_fields = [
-                p.wire_name for p in model_type.properties if p.is_multipart_file_input
-            ]
-            data_fields = [
-                p.wire_name
-                for p in model_type.properties
-                if not p.is_multipart_file_input
-            ]
+            file_fields = [p.wire_name for p in model_type.properties if p.is_multipart_file_input]
+            data_fields = [p.wire_name for p in model_type.properties if not p.is_multipart_file_input]
             retval.extend(
                 [
                     "_body = (",
@@ -777,19 +665,13 @@ class _OperationSerializer(
 
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         send_xml = builder.parameters.body_parameter.type.is_xml
-        xml_serialization_ctxt = (
-            body_param.type.xml_serialization_ctxt if send_xml else None
-        )
+        xml_serialization_ctxt = body_param.type.xml_serialization_ctxt if send_xml else None
         ser_ctxt_name = "serialization_ctxt"
         if xml_serialization_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
         if self.code_model.options["models_mode"] == "msrest":
-            is_xml_cmd = _xml_config(
-                send_xml, builder.parameters.body_parameter.content_types
-            )
-            serialization_ctxt_cmd = (
-                f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
-            )
+            is_xml_cmd = _xml_config(send_xml, builder.parameters.body_parameter.content_types)
+            serialization_ctxt_cmd = f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
             create_body_call = (
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
@@ -832,17 +714,12 @@ class _OperationSerializer(
         body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
         body_param_type = body_param.type
         if isinstance(body_param_type, BinaryType) or (
-            isinstance(body_param.type, ByteArraySchema)
-            and body_param.default_content_type != "application/json"
+            isinstance(body_param.type, ByteArraySchema) and body_param.default_content_type != "application/json"
         ):
             retval.append(f"_{body_kwarg_name} = {body_param.client_name}")
             if (
                 not body_param.default_content_type
-                and not next(
-                    p
-                    for p in builder.parameters
-                    if p.wire_name.lower() == "content-type"
-                ).optional
+                and not next(p for p in builder.parameters if p.wire_name.lower() == "content-type").optional
             ):
                 content_types = "'" + "', '".join(body_param.content_types) + "'"
                 retval.extend(
@@ -856,30 +733,17 @@ class _OperationSerializer(
             retval.extend(self._serialize_body_parameter(builder))
         return retval
 
-    def _initialize_overloads(
-        self, builder: OperationType, is_paging: bool = False
-    ) -> List[str]:
+    def _initialize_overloads(self, builder: OperationType, is_paging: bool = False) -> List[str]:
         retval: List[str] = []
         # For paging, we put body parameter in local place outside `prepare_request`
         if is_paging:
             return retval
-        same_content_type = (
-            len(
-                set(
-                    o.parameters.body_parameter.default_content_type
-                    for o in builder.overloads
-                )
-            )
-            == 1
-        )
+        same_content_type = len(set(o.parameters.body_parameter.default_content_type for o in builder.overloads)) == 1
         if same_content_type:
-            default_content_type = builder.overloads[
-                0
-            ].parameters.body_parameter.default_content_type
+            default_content_type = builder.overloads[0].parameters.body_parameter.default_content_type
             retval.append(f'content_type = content_type or "{default_content_type}"')
         client_names = [
-            overload.request_builder.parameters.body_parameter.client_name
-            for overload in builder.overloads
+            overload.request_builder.parameters.body_parameter.client_name for overload in builder.overloads
         ]
         for v in sorted(set(client_names), key=client_names.index):
             retval.append(f"_{v} = None")
@@ -887,43 +751,20 @@ class _OperationSerializer(
             # if there is a binary overload, we do a binary check first.
             binary_overload = cast(
                 OperationType,
-                next(
-                    (
-                        o
-                        for o in builder.overloads
-                        if isinstance(o.parameters.body_parameter.type, BinaryType)
-                    )
-                ),
+                next((o for o in builder.overloads if isinstance(o.parameters.body_parameter.type, BinaryType))),
             )
             binary_body_param = binary_overload.parameters.body_parameter
-            retval.append(
-                f"if {binary_body_param.type.instance_check_template.format(binary_body_param.client_name)}:"
-            )
+            retval.append(f"if {binary_body_param.type.instance_check_template.format(binary_body_param.client_name)}:")
             if binary_body_param.default_content_type and not same_content_type:
-                retval.append(
-                    f'    content_type = content_type or "{binary_body_param.default_content_type}"'
-                )
-            retval.extend(
-                f"    {l}" for l in self._create_body_parameter(binary_overload)
-            )
+                retval.append(f'    content_type = content_type or "{binary_body_param.default_content_type}"')
+            retval.extend(f"    {l}" for l in self._create_body_parameter(binary_overload))
             retval.append("else:")
             other_overload = cast(
                 OperationType,
-                next(
-                    (
-                        o
-                        for o in builder.overloads
-                        if not isinstance(o.parameters.body_parameter.type, BinaryType)
-                    )
-                ),
-            )
-            retval.extend(
-                f"    {l}" for l in self._create_body_parameter(other_overload)
+                next((o for o in builder.overloads if not isinstance(o.parameters.body_parameter.type, BinaryType))),
             )
-            if (
-                other_overload.parameters.body_parameter.default_content_type
-                and not same_content_type
-            ):
+            retval.extend(f"    {l}" for l in self._create_body_parameter(other_overload))
+            if other_overload.parameters.body_parameter.default_content_type and not same_content_type:
                 retval.append(
                     "    content_type = content_type or "
                     f'"{other_overload.parameters.body_parameter.default_content_type}"'
@@ -936,13 +777,8 @@ class _OperationSerializer(
                     f"{if_statement} {body_param.type.instance_check_template.format(body_param.client_name)}:"
                 )
                 if body_param.default_content_type and not same_content_type:
-                    retval.append(
-                        f'    content_type = content_type or "{body_param.default_content_type}"'
-                    )
-                retval.extend(
-                    f"    {l}"
-                    for l in self._create_body_parameter(cast(OperationType, overload))
-                )
+                    retval.append(f'    content_type = content_type or "{body_param.default_content_type}"')
+                retval.extend(f"    {l}" for l in self._create_body_parameter(cast(OperationType, overload)))
         return retval
 
     def _create_request_builder_call(
@@ -978,11 +814,7 @@ class _OperationSerializer(
             type_ignore = (
                 parameter.grouped_by
                 and parameter.client_default_value is not None
-                and next(
-                    p
-                    for p in builder.parameters
-                    if p.grouper and p.client_name == parameter.grouped_by
-                ).optional
+                and next(p for p in builder.parameters if p.grouper and p.client_name == parameter.grouped_by).optional
             )
             retval.append(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
@@ -998,38 +830,25 @@ class _OperationSerializer(
         elif request_builder.overloads:
             seen_body_params = set()
             for overload in request_builder.overloads:
-                body_param = cast(
-                    RequestBuilderBodyParameter, overload.parameters.body_parameter
-                )
+                body_param = cast(RequestBuilderBodyParameter, overload.parameters.body_parameter)
                 if body_param.client_name in seen_body_params:
                     continue
                 seen_body_params.add(body_param.client_name)
 
-                retval.append(
-                    f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
-                )
+                retval.append(f"    {body_param.client_name}={body_param.name_in_high_level_operation},")
         elif request_builder.parameters.has_body:
-            body_param = cast(
-                RequestBuilderBodyParameter, request_builder.parameters.body_parameter
-            )
-            retval.append(
-                f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
-            )
+            body_param = cast(RequestBuilderBodyParameter, request_builder.parameters.body_parameter)
+            retval.append(f"    {body_param.client_name}={body_param.name_in_high_level_operation},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
         retval.append(")")
         return retval
 
-    def _postprocess_http_request(
-        self, builder: OperationType, template_url: Optional[str] = None
-    ) -> List[str]:
+    def _postprocess_http_request(self, builder: OperationType, template_url: Optional[str] = None) -> List[str]:
         retval: List[str] = []
         if not self.code_model.options["version_tolerant"]:
             pass_files = ""
-            if (
-                builder.parameters.has_body
-                and builder.parameters.body_parameter.client_name == "files"
-            ):
+            if builder.parameters.has_body and builder.parameters.body_parameter.client_name == "files":
                 pass_files = ", _files"
             retval.append(f"_request = _convert_request(_request{pass_files})")
         if builder.parameters.path:
@@ -1061,11 +880,7 @@ class _OperationSerializer(
             # unflatten before passing to request builder as well
             retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
         if is_json_model_type(builder.parameters):
-            retval.extend(
-                _serialize_json_model_body(
-                    builder.parameters.body_parameter, builder.parameters.parameters
-                )
-            )
+            retval.extend(_serialize_json_model_body(builder.parameters.body_parameter, builder.parameters.parameters))
         if builder.has_form_data_body:
             retval.extend(self._create_body_parameter(builder))
         elif builder.overloads:
@@ -1075,18 +890,12 @@ class _OperationSerializer(
             # non-overloaded body
             retval.extend(self._create_body_parameter(builder))
         retval.append("")
-        retval.extend(
-            self._create_request_builder_call(builder, request_builder, is_next_request)
-        )
+        retval.extend(self._create_request_builder_call(builder, request_builder, is_next_request))
         retval.extend(self._postprocess_http_request(builder, template_url))
         return retval
 
-    def call_request_builder(
-        self, builder: OperationType, is_paging: bool = False
-    ) -> List[str]:
-        return self._call_request_builder_helper(
-            builder, builder.request_builder, is_paging=is_paging
-        )
+    def call_request_builder(self, builder: OperationType, is_paging: bool = False) -> List[str]:
+        return self._call_request_builder_helper(builder, builder.request_builder, is_paging=is_paging)
 
     def response_headers_and_deserialization(
         self,
@@ -1112,9 +921,7 @@ class _OperationSerializer(
                 if self.code_model.options["version_tolerant"]:
                     deserialized = "response.iter_bytes()"
                 else:
-                    deserialized = (
-                        f"response.stream_download(self._client.{self.pipeline_name})"
-                    )
+                    deserialized = f"response.stream_download(self._client.{self.pipeline_name})"
             deserialize_code.append(f"deserialized = {deserialized}")
         elif response.type:
             pylint_disable = ""
@@ -1122,9 +929,7 @@ class _OperationSerializer(
                 pylint_disable = "  # pylint: disable=protected-access"
             if self.code_model.options["models_mode"] == "msrest":
                 deserialize_code.append("deserialized = self._deserialize(")
-                deserialize_code.append(
-                    f"    '{response.serialization_type}',{pylint_disable}"
-                )
+                deserialize_code.append(f"    '{response.serialization_type}',{pylint_disable}")
                 deserialize_code.append("    pipeline_response")
                 deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
@@ -1137,26 +942,16 @@ class _OperationSerializer(
                         and response.default_content_type == "application/json"
                         else ""
                     )
-                    response_attr = (
-                        "json"
-                        if _json_serializable(str(response.default_content_type))
-                        else "text"
-                    )
+                    response_attr = "json" if _json_serializable(str(response.default_content_type)) else "text"
                     deserialize_code.append("deserialized = _deserialize(")
                     deserialize_code.append(
                         f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
                     )
-                    deserialize_code.append(
-                        f"    response.{response_attr}(){response.result_property}{format_filed}"
-                    )
+                    deserialize_code.append(f"    response.{response_attr}(){response.result_property}{format_filed}")
                     deserialize_code.append(")")
 
             else:
-                deserialized_value = (
-                    "ET.fromstring(response.text())"
-                    if response.type.is_xml
-                    else "response.json()"
-                )
+                deserialized_value = "ET.fromstring(response.text())" if response.type.is_xml else "response.json()"
                 deserialize_code.append("if response.content:")
                 deserialize_code.append(f"    deserialized = {deserialized_value}")
                 deserialize_code.append("else:")
@@ -1173,9 +968,7 @@ class _OperationSerializer(
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
         async_await = "await " if self.async_mode else ""
-        retval = [
-            f"if response.status_code not in {str(builder.success_status_codes)}:"
-        ]
+        retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
         if not self.code_model.need_request_converter:
             retval.extend(
                 [
@@ -1188,14 +981,9 @@ class _OperationSerializer(
             f"    map_error(status_code=response.status_code, response=response, error_map=error_map){type_ignore}"
         )
         error_model = ""
-        if (
-            builder.default_error_deserialization
-            and self.code_model.options["models_mode"]
-        ):
+        if builder.default_error_deserialization and self.code_model.options["models_mode"]:
             if self.code_model.options["models_mode"] == "dpg":
-                retval.append(
-                    f"    error = _deserialize({builder.default_error_deserialization},  response.json())"
-                )
+                retval.append(f"    error = _deserialize({builder.default_error_deserialization},  response.json())")
             else:
                 retval.append(
                     f"    error = self._deserialize.failsafe_deserialize({builder.default_error_deserialization}, "
@@ -1205,11 +993,7 @@ class _OperationSerializer(
         retval.append(
             "    raise HttpResponseError(response=response{}{})".format(
                 error_model,
-                (
-                    ", error_format=ARMErrorFormat"
-                    if self.code_model.options["azure_arm"]
-                    else ""
-                ),
+                (", error_format=ARMErrorFormat" if self.code_model.options["azure_arm"] else ""),
             )
         )
         return retval
@@ -1230,20 +1014,11 @@ class _OperationSerializer(
                     if response.headers or response.type:
                         retval.append(f"if response.status_code == {status_code}:")
                         retval.extend(
-                            [
-                                f"    {line}"
-                                for line in self.response_headers_and_deserialization(
-                                    builder, response
-                                )
-                            ]
+                            [f"    {line}" for line in self.response_headers_and_deserialization(builder, response)]
                         )
                         retval.append("")
             else:
-                retval.extend(
-                    self.response_headers_and_deserialization(
-                        builder, builder.responses[0]
-                    )
-                )
+                retval.extend(self.response_headers_and_deserialization(builder, builder.responses[0]))
                 retval.append("")
         if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
@@ -1258,15 +1033,11 @@ class _OperationSerializer(
             )
         )
         if builder.has_response_body and any(
-            response.is_stream_response or response.type
-            for response in builder.responses
+            response.is_stream_response or response.type for response in builder.responses
         ):
             retval.append("")
             retval.append(f"return {deserialized}  # type: ignore")
-        if (
-            builder.request_builder.method == "HEAD"
-            and self.code_model.options["head_as_boolean"]
-        ):
+        if builder.request_builder.method == "HEAD" and self.code_model.options["head_as_boolean"]:
             retval.append("return 200 <= response.status_code <= 299")
         return retval
 
@@ -1286,16 +1057,11 @@ class _OperationSerializer(
                 if isinstance(excep.type, ModelType):
                     if self.code_model.options["models_mode"] == "msrest":
                         error_model_str = (
-                            f", model=self._deserialize("
-                            f"_models.{excep.type.serialization_type}, response)"
+                            f", model=self._deserialize(" f"_models.{excep.type.serialization_type}, response)"
                         )
                     elif self.code_model.options["models_mode"] == "dpg":
                         error_model_str = f", model=_deserialize(_models.{excep.type.name}, response.json())"
-                error_format_str = (
-                    ", error_format=ARMErrorFormat"
-                    if self.code_model.options["azure_arm"]
-                    else ""
-                )
+                error_format_str = ", error_format=ARMErrorFormat" if self.code_model.options["azure_arm"] else ""
                 for status_code in excep.status_codes:
                     if status_code == 401:
                         retval.append(
@@ -1359,14 +1125,10 @@ class OperationSerializer(_OperationSerializer[Operation]): ...
 
 ############################## PAGING OPERATIONS ##############################
 
-PagingOperationType = TypeVar(
-    "PagingOperationType", bound=Union[PagingOperation, LROPagingOperation]
-)
+PagingOperationType = TypeVar("PagingOperationType", bound=Union[PagingOperation, LROPagingOperation])
 
 
-class _PagingOperationSerializer(
-    _OperationSerializer[PagingOperationType]
-):  # pylint: disable=abstract-method
+class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):  # pylint: disable=abstract-method
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
@@ -1376,9 +1138,7 @@ class _PagingOperationSerializer(
         self.parameter_serializer = ParameterSerializer()
 
     def serialize_path(self, builder: PagingOperationType) -> List[str]:
-        return self.parameter_serializer.serialize_path(
-            builder.parameters.path, self.serializer_name
-        )
+        return self.parameter_serializer.serialize_path(builder.parameters.path, self.serializer_name)
 
     def decorators(self, builder: PagingOperationType) -> List[str]:
         """Decorators for the method"""
@@ -1412,9 +1172,7 @@ class _PagingOperationSerializer(
         next_link_str = "next_link"
         try:
             api_version_param = next(
-                p
-                for p in builder.client.parameters
-                if p.is_api_version and p.location == ParameterLocation.QUERY
+                p for p in builder.client.parameters if p.is_api_version and p.location == ParameterLocation.QUERY
             )
             retval.append("# make call to next link with the client's api-version")
             retval.append("_parsed_next_link = urllib.parse.urlparse(next_link)")
@@ -1446,17 +1204,10 @@ class _PagingOperationSerializer(
         retval = self._initialize_overloads(builder)
         retval.append("def prepare_request(next_link=None):")
         retval.append("    if not next_link:")
-        retval.extend(
-            [
-                f"        {line}"
-                for line in self.call_request_builder(builder, is_paging=True)
-            ]
-        )
+        retval.extend([f"        {line}" for line in self.call_request_builder(builder, is_paging=True)])
         retval.append("")
         retval.append("    else:")
-        retval.extend(
-            [f"        {line}" for line in self.call_next_link_request_builder(builder)]
-        )
+        retval.extend([f"        {line}" for line in self.call_next_link_request_builder(builder)])
         if not builder.next_request_builder and self.code_model.is_legacy:
             retval.append('        _request.method = "GET"')
         else:
@@ -1469,9 +1220,7 @@ class _PagingOperationSerializer(
         return "def"
 
     def _extract_data_callback(self, builder: PagingOperationType) -> List[str]:
-        retval = [
-            f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"
-        ]
+        retval = [f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"]
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
         if self.code_model.options["models_mode"] == "msrest":
@@ -1488,17 +1237,11 @@ class _PagingOperationSerializer(
         else:
             retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
-        access = (
-            f".{item_name}"
-            if self.code_model.options["models_mode"] == "msrest"
-            else f'["{item_name}"]'
-        )
+        access = f".{item_name}" if self.code_model.options["models_mode"] == "msrest" else f'["{item_name}"]'
         list_of_elem_deserialized = ""
         if self.code_model.options["models_mode"] == "dpg":
             item_type = builder.item_type.type_annotation(is_operation_file=True)
-            list_of_elem_deserialized = (
-                f"_deserialize({item_type}, deserialized{access})"
-            )
+            list_of_elem_deserialized = f"_deserialize({item_type}, deserialized{access})"
         else:
             list_of_elem_deserialized = f"deserialized{access}"
         retval.append(f"    list_of_elem = {list_of_elem_deserialized}")
@@ -1511,9 +1254,7 @@ class _PagingOperationSerializer(
         elif self.code_model.options["models_mode"] == "msrest":
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
-            cont_token_property = (
-                f'deserialized.get("{continuation_token_name}") or None'
-            )
+            cont_token_property = f'deserialized.get("{continuation_token_name}") or None'
         list_type = "AsyncList" if self.async_mode else "iter"
         retval.append(f"    return {cont_token_property}, {list_type}(list_of_elem)")
         return retval
@@ -1546,9 +1287,7 @@ class PagingOperationSerializer(_PagingOperationSerializer[PagingOperation]): ..
 
 ############################## LRO OPERATIONS ##############################
 
-LROOperationType = TypeVar(
-    "LROOperationType", bound=Union[LROOperation, LROPagingOperation]
-)
+LROOperationType = TypeVar("LROOperationType", bound=Union[LROOperation, LROPagingOperation])
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
@@ -1561,9 +1300,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         self.parameter_serializer = ParameterSerializer()
 
     def serialize_path(self, builder: LROOperationType) -> List[str]:
-        return self.parameter_serializer.serialize_path(
-            builder.parameters.path, self.serializer_name
-        )
+        return self.parameter_serializer.serialize_path(builder.parameters.path, self.serializer_name)
 
     def initial_call(self, builder: LROOperationType) -> List[str]:
         retval = [
@@ -1573,19 +1310,14 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("    'polling_interval',")
         retval.append("    self._config.polling_interval")
         retval.append(")")
-        retval.append(
-            "cont_token: Optional[str] = kwargs.pop('continuation_token', None)"
-        )
+        retval.append("cont_token: Optional[str] = kwargs.pop('continuation_token', None)")
         retval.append("if cont_token is None:")
         retval.append(
             f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
             f"{'' if any(rsp.type for rsp in builder.initial_operation.responses) else '  # type: ignore'}"
         )
         retval.extend(
-            [
-                f"        {parameter.client_name}={parameter.client_name},"
-                for parameter in builder.parameters.method
-            ]
+            [f"        {parameter.client_name}={parameter.client_name}," for parameter in builder.parameters.method]
         )
         retval.append("        cls=lambda x,y,z: x,")
         retval.append("        headers=_headers,")
@@ -1598,9 +1330,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
     def return_lro_poller(self, builder: LROOperationType) -> List[str]:
         retval = []
         lro_options_str = (
-            "lro_options={'final-state-via': '"
-            + builder.lro_options["final-state-via"]
-            + "'},"
+            "lro_options={'final-state-via': '" + builder.lro_options["final-state-via"] + "'},"
             if builder.lro_options
             else ""
         )
@@ -1628,20 +1358,14 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         )
         retval.append("else: polling_method = polling")
         retval.append("if cont_token:")
-        retval.append(
-            f"    return {builder.get_poller_with_response_type(self.async_mode)}.from_continuation_token("
-        )
+        retval.append(f"    return {builder.get_poller_with_response_type(self.async_mode)}.from_continuation_token(")
         retval.append("        polling_method=polling_method,")
         retval.append("        continuation_token=cont_token,")
         retval.append("        client=self._client,")
         retval.append("        deserialization_callback=get_long_running_output")
         retval.append("    )")
-        retval.append(
-            f"return {builder.get_poller_with_response_type(self.async_mode)}("
-        )
-        retval.append(
-            "    self._client, raw_result, get_long_running_output, polling_method  # type: ignore"
-        )
+        retval.append(f"return {builder.get_poller_with_response_type(self.async_mode)}(")
+        retval.append("    self._client, raw_result, get_long_running_output, polling_method  # type: ignore")
         retval.append("    )")
         return retval
 
@@ -1660,26 +1384,13 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             ):
                 retval.append("    response = pipeline_response.http_response")
             retval.extend(
-                [
-                    f"    {line}"
-                    for line in self.response_headers_and_deserialization(
-                        builder, builder.lro_response
-                    )
-                ]
+                [f"    {line}" for line in self.response_headers_and_deserialization(builder, builder.lro_response)]
             )
         retval.append("    if cls:")
         retval.append(
             "        return cls(pipeline_response, {}, {}){}".format(
-                (
-                    "deserialized"
-                    if builder.lro_response and builder.lro_response.type
-                    else "None"
-                ),
-                (
-                    "response_headers"
-                    if builder.lro_response and builder.lro_response.headers
-                    else "{}"
-                ),
+                ("deserialized" if builder.lro_response and builder.lro_response.type else "None"),
+                ("response_headers" if builder.lro_response and builder.lro_response.headers else "{}"),
                 " # type: ignore",
             )
         )