@autorest/python 6.13.16 → 6.13.18

package/autorest/codegen/models/parameter_list.py

@@ -33,12 +33,8 @@ from .parameter import (
     ConfigParameter,
 )
 
-ParameterType = TypeVar(
-    "ParameterType", bound=Union[Parameter, RequestBuilderParameter]
-)
-BodyParameterType = TypeVar(
-    "BodyParameterType", bound=Union[BodyParameter, RequestBuilderBodyParameter]
-)
+ParameterType = TypeVar("ParameterType", bound=Union[Parameter, RequestBuilderParameter])
+BodyParameterType = TypeVar("BodyParameterType", bound=Union[BodyParameter, RequestBuilderBodyParameter])
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -52,17 +48,13 @@ class ParameterImplementation(Enum):
 _LOGGER = logging.getLogger(__name__)
 
 
-def method_signature_helper(
-    positional: List[str], keyword_only: Optional[List[str]], kwarg_params: List[str]
-):
+def method_signature_helper(positional: List[str], keyword_only: Optional[List[str]], kwarg_params: List[str]):
     keyword_only = keyword_only or []
     return positional + keyword_only + kwarg_params
 
 
 def _sort(params):
-    return sorted(
-        params, key=lambda x: not (x.client_default_value or x.optional), reverse=True
-    )
+    return sorted(params, key=lambda x: not (x.client_default_value or x.optional), reverse=True)
 
 
 class _ParameterListBase(
@@ -110,17 +102,13 @@ class _ParameterListBase(
 
     @staticmethod
     @abstractmethod
-    def body_parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], BodyParameterType]
-    ):
+    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameterType]:
         """Callable for creating body parameters"""
 
     @property
     def grouped(self) -> List[Union[ParameterType, BodyParameterType]]:
         """All parameters that are inside a parameter group"""
-        params: List[Union[ParameterType, BodyParameterType]] = [
-            p for p in self.parameters if p.grouped_by
-        ]
+        params: List[Union[ParameterType, BodyParameterType]] = [p for p in self.parameters if p.grouped_by]
         if self.has_body and self.body_parameter.grouped_by:
             params.append(self.body_parameter)
         return params
@@ -137,11 +125,7 @@ class _ParameterListBase(
     @property
     def path(self) -> List[ParameterType]:
         """All path parameters"""
-        return [
-            p
-            for p in self.parameters
-            if p.location in (ParameterLocation.PATH, ParameterLocation.ENDPOINT_PATH)
-        ]
+        return [p for p in self.parameters if p.location in (ParameterLocation.PATH, ParameterLocation.ENDPOINT_PATH)]
 
     @property
     def query(self) -> List[ParameterType]:
@@ -162,34 +146,20 @@ class _ParameterListBase(
     def positional(self) -> List[Union[ParameterType, BodyParameterType]]:
         """All positional parameters"""
         return _sort(
-            [
-                p
-                for p in self.unsorted_method_params
-                if p.method_location == ParameterMethodLocation.POSITIONAL
-            ]
+            [p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.POSITIONAL]
         )
 
     @property
     def keyword_only(self) -> List[Union[ParameterType, BodyParameterType]]:
         """All keyword only parameters"""
         return _sort(
-            [
-                p
-                for p in self.unsorted_method_params
-                if p.method_location == ParameterMethodLocation.KEYWORD_ONLY
-            ]
+            [p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.KEYWORD_ONLY]
         )
 
     @property
     def kwarg(self) -> List[Union[ParameterType, BodyParameterType]]:
         """All kwargs"""
-        return _sort(
-            [
-                p
-                for p in self.unsorted_method_params
-                if p.method_location == ParameterMethodLocation.KWARG
-            ]
-        )
+        return _sort([p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.KWARG])
 
     @property
     def body_parameter(self) -> BodyParameterType:
@@ -261,20 +231,12 @@ class _ParameterListBase(
         """Method kwargs we want to pop"""
         # don't want to pop bodies unless it's a constant
         kwargs_to_pop = self.kwarg
-        return [
-            k
-            for k in kwargs_to_pop
-            if k.location != ParameterLocation.BODY or k.constant
-        ]
+        return [k for k in kwargs_to_pop if k.location != ParameterLocation.BODY or k.constant]
 
     @property
     def call(self) -> List[str]:
         """How to pass in parameters to call the operation"""
-        retval = [
-            p.client_name
-            for p in self.method
-            if p.method_location == ParameterMethodLocation.POSITIONAL
-        ]
+        retval = [p.client_name for p in self.method if p.method_location == ParameterMethodLocation.POSITIONAL]
         retval.extend(
             [
                 f"{p.client_name}={p.client_name}"
@@ -287,15 +249,10 @@ class _ParameterListBase(
 
     @classmethod
     def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
-        parameters = [
-            cls.parameter_creator()(parameter, code_model)
-            for parameter in yaml_data["parameters"]
-        ]
+        parameters = [cls.parameter_creator()(parameter, code_model) for parameter in yaml_data["parameters"]]
         body_parameter = None
         if yaml_data.get("bodyParameter"):
-            body_parameter = cls.body_parameter_creator()(
-                yaml_data["bodyParameter"], code_model
-            )
+            body_parameter = cls.body_parameter_creator()(yaml_data["bodyParameter"], code_model)
         return cls(
             yaml_data,
             code_model,
@@ -304,11 +261,7 @@ class _ParameterListBase(
         )
 
 
-class _ParameterList(
-    _ParameterListBase[  # pylint: disable=unsubscriptable-object
-        Parameter, BodyParameter
-    ]
-):
+class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):  # pylint: disable=unsubscriptable-object
     """Base Parameter class for the two operation ParameterLists"""
 
     @staticmethod
@@ -316,9 +269,7 @@ class _ParameterList(
         return Parameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], BodyParameter]
-    ):
+    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameter]:
         return BodyParameter.from_yaml
 
     @property
@@ -327,9 +278,7 @@ class _ParameterList(
 
     @property
     def path(self) -> List[Parameter]:
-        return [
-            k for k in super().path if k.location == ParameterLocation.ENDPOINT_PATH
-        ]
+        return [k for k in super().path if k.location == ParameterLocation.ENDPOINT_PATH]
 
 
 class ParameterList(_ParameterList):
@@ -337,22 +286,16 @@ class ParameterList(_ParameterList):
 
 
 class _RequestBuilderParameterList(
-    _ParameterListBase[  # pylint: disable=unsubscriptable-object
-        RequestBuilderParameter, RequestBuilderBodyParameter
-    ]
+    _ParameterListBase[RequestBuilderParameter, RequestBuilderBodyParameter]  # pylint: disable=unsubscriptable-object
 ):
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod
-    def parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameter]
-    ):
+    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameter]:
         return RequestBuilderParameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameter]
-    ):
+    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameter]:
         return RequestBuilderBodyParameter.from_yaml
 
     @property
@@ -367,34 +310,21 @@ class _RequestBuilderParameterList(
         retval = [
             p
             for p in super().unsorted_method_params
-            if not (
-                p.location == ParameterLocation.BODY
-                and cast(RequestBuilderBodyParameter, p).is_partial_body
-            )
+            if not (p.location == ParameterLocation.BODY and cast(RequestBuilderBodyParameter, p).is_partial_body)
         ]
-        retval.extend(
-            [
-                p
-                for p in self.parameters
-                if p.implementation == "Client" and p.in_method_signature
-            ]
-        )
+        retval.extend([p for p in self.parameters if p.implementation == "Client" and p.in_method_signature])
         return retval
 
     @property
     def path(self) -> List[RequestBuilderParameter]:
-        return [
-            p for p in super().path if p.location != ParameterLocation.ENDPOINT_PATH
-        ]
+        return [p for p in super().path if p.location != ParameterLocation.ENDPOINT_PATH]
 
     @property
     def constant(
         self,
     ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
         """All constant parameters"""
-        return [
-            p for p in super().constant if p.location != ParameterLocation.ENDPOINT_PATH
-        ]
+        return [p for p in super().constant if p.location != ParameterLocation.ENDPOINT_PATH]
 
 
 class RequestBuilderParameterList(_RequestBuilderParameterList):
@@ -405,15 +335,11 @@ class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
     """Parameter list for OverloadedRequestBuilder"""
 
 
-class _ClientGlobalParameterList(  # pylint: disable=abstract-method
-    _ParameterListBase[ParameterType, BodyParameter]
-):
+class _ClientGlobalParameterList(_ParameterListBase[ParameterType, BodyParameter]):  # pylint: disable=abstract-method
     """Base parameter list for client and config classes"""
 
     @staticmethod
-    def body_parameter_creator() -> (
-        Callable[[Dict[str, Any], "CodeModel"], BodyParameter]
-    ):
+    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameter]:
         return BodyParameter.from_yaml
 
     @property
@@ -429,9 +355,7 @@ class _ClientGlobalParameterList(  # pylint: disable=abstract-method
 
     @property
     def path(self) -> List[ParameterType]:
-        return [
-            p for p in super().path if p.location == ParameterLocation.ENDPOINT_PATH
-        ]
+        return [p for p in super().path if p.location == ParameterLocation.ENDPOINT_PATH]
 
 
 class ClientGlobalParameterList(_ClientGlobalParameterList[ClientParameter]):

package/autorest/codegen/models/primitive_types.py

@@ -24,9 +24,7 @@ class RawString(object):
 
 
 class PrimitiveType(BaseType):  # pylint: disable=abstract-method
-    def description(
-        self, *, is_operation_file: bool  # pylint: disable=unused-argument
-    ) -> str:
+    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
         return ""
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -46,25 +44,18 @@ class PrimitiveType(BaseType):  # pylint: disable=abstract-method
         if optional:
             comment = add_to_description(comment, "Optional.")
         if self.client_default_value is not None:
-            client_default_value_declaration = (
-                client_default_value_declaration
-                or self.get_declaration(self.client_default_value)
+            client_default_value_declaration = client_default_value_declaration or self.get_declaration(
+                self.client_default_value
             )
         if client_default_value_declaration:
-            comment = add_to_description(
-                comment, f"Default value is {client_default_value_declaration}."
-            )
+            comment = add_to_description(comment, f"Default value is {client_default_value_declaration}.")
         else:
-            client_default_value_declaration = (
-                self.default_template_representation_declaration
-            )
+            client_default_value_declaration = self.default_template_representation_declaration
         if description:
             comment = add_to_description(comment, description)
         if comment:
             comment = f"# {comment}"
-        return client_default_value_declaration + (
-            "" if self.code_model.for_test else comment
-        )
+        return client_default_value_declaration + ("" if self.code_model.for_test else comment)
 
     @property
     def default_template_representation_declaration(self) -> str:
@@ -149,9 +140,7 @@ class BinaryIteratorType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "typing", self._iterator_name(**kwargs), ImportType.STDLIB
-        )
+        file_import.add_submodule_import("typing", self._iterator_name(**kwargs), ImportType.STDLIB)
         return file_import
 
     @property
@@ -176,16 +165,12 @@ class AnyType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
     @property
     def instance_check_template(self) -> str:
-        raise ValueError(
-            "Shouldn't do instance check on an anytype, it can be anything"
-        )
+        raise ValueError("Shouldn't do instance check on an anytype, it can be anything")
 
 
 class AnyObjectType(PrimitiveType):
@@ -230,26 +215,10 @@ class NumberType(PrimitiveType):  # pylint: disable=abstract-method
     @property
     def serialization_constraints(self) -> List[str]:
         validation_constraints = [
-            (
-                f"maximum_ex={self.maximum}"
-                if self.maximum is not None and self.exclusive_maximum
-                else None
-            ),
-            (
-                f"maximum={self.maximum}"
-                if self.maximum is not None and not self.exclusive_maximum
-                else None
-            ),
-            (
-                f"minimum_ex={self.minimum}"
-                if self.minimum is not None and self.exclusive_minimum
-                else None
-            ),
-            (
-                f"minimum={self.minimum}"
-                if self.minimum is not None and not self.exclusive_minimum
-                else None
-            ),
+            (f"maximum_ex={self.maximum}" if self.maximum is not None and self.exclusive_maximum else None),
+            (f"maximum={self.maximum}" if self.maximum is not None and not self.exclusive_maximum else None),
+            (f"minimum_ex={self.minimum}" if self.minimum is not None and self.exclusive_minimum else None),
+            (f"minimum={self.minimum}" if self.minimum is not None and not self.exclusive_minimum else None),
             f"multiple={self.multiple}" if self.multiple else None,
         ]
         return [x for x in validation_constraints if x is not None]
@@ -353,9 +322,7 @@ class StringType(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length: Optional[int] = yaml_data.get("maxLength")
         self.min_length: Optional[int] = (
-            yaml_data.get("minLength", 0)
-            if yaml_data.get("maxLength")
-            else yaml_data.get("minLength")
+            yaml_data.get("minLength", 0) if yaml_data.get("maxLength") else yaml_data.get("minLength")
         )
         self.pattern: Optional[str] = yaml_data.get("pattern")
 
@@ -400,8 +367,7 @@ class DatetimeType(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = (
             "rfc3339"
-            if yaml_data.get("encode", "date-time") == "date-time"
-            or yaml_data.get("encode", "date-time") == "rfc3339"
+            if yaml_data.get("encode", "date-time") == "date-time" or yaml_data.get("encode", "date-time") == "rfc3339"
             else "rfc7231"
         )
 

package/autorest/codegen/models/property.py

@@ -37,12 +37,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.client_default_value is None:
             self.client_default_value = self.type.client_default_value
         self.flattened_names: List[str] = yaml_data.get("flattenedNames", [])
-        self.is_multipart_file_input: bool = yaml_data.get(
-            "isMultipartFileInput", False
-        )
-        self.flatten = self.yaml_data.get("flatten", False) and not getattr(
-            self.type, "flattened_property", False
-        )
+        self.is_multipart_file_input: bool = yaml_data.get("isMultipartFileInput", False)
+        self.flatten = self.yaml_data.get("flatten", False) and not getattr(self.type, "flattened_property", False)
 
     @property
     def pylint_disable(self) -> str:
@@ -59,9 +55,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             description = add_to_description(description, "Required.")
         # don't want model type documentation as part of property doc
         type_description = (
-            ""
-            if isinstance(self.type, ModelType)
-            else self.type.description(is_operation_file=is_operation_file)
+            "" if isinstance(self.type, ModelType) else self.type.description(is_operation_file=is_operation_file)
         )
         return add_to_description(description, type_description)
 
@@ -77,11 +71,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def constant(self) -> bool:
         # this bool doesn't consider you to be constant if you are a discriminator
         # you also have to be required to be considered a constant
-        return (
-            isinstance(self.type, ConstantType)
-            and not self.optional
-            and not self.is_discriminator
-        )
+        return isinstance(self.type, ConstantType) and not self.optional and not self.is_discriminator
 
     @property
     def is_input(self):
@@ -104,16 +94,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         """If this discriminator is on the base model for polymorphic inheritance"""
         if self.is_enum_discriminator:
             return self.is_polymorphic and self.client_default_value is None
-        return (
-            self.is_discriminator
-            and self.is_polymorphic
-            and cast(ConstantType, self.type).value is None
-        )
+        return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
 
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        types_type_annotation = self.type.type_annotation(
-            is_operation_file=is_operation_file
-        )
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
         if self.is_multipart_file_input:
             # we only support FileType or list of FileType
             types_type_annotation = types_type_annotation.replace("bytes", "FileType")
@@ -137,9 +121,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             file_type_str = '"filetype"' if self.code_model.for_test else "filetype"
             return f"[{file_type_str}]" if self.type.type == "list" else file_type_str
         if self.client_default_value:
-            client_default_value_declaration = self.get_declaration(
-                self.client_default_value
-            )
+            client_default_value_declaration = self.get_declaration(self.client_default_value)
         if self.description(is_operation_file=True):
             description = self.description(is_operation_file=True)
         # make sure there is no \n otherwise the json template will be invalid
@@ -172,9 +154,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         file_import = FileImport(self.code_model)
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
-        file_import.merge(
-            self.type.imports(**kwargs, relative_path="..", model_typing=True)
-        )
+        file_import.merge(self.type.imports(**kwargs, relative_path="..", model_typing=True))
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":

package/autorest/codegen/models/request_builder.py

@@ -87,19 +87,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)
         relative_path = ".."
-        if (
-            not self.code_model.options["builders_visibility"] == "embedded"
-            and self.group_name
-        ):
+        if not self.code_model.options["builders_visibility"] == "embedded" and self.group_name:
             relative_path = "..." if self.group_name else ".."
         if self.abstract:
             return file_import
         for parameter in self.parameters.method:
-            file_import.merge(
-                parameter.imports(
-                    async_mode=False, relative_path=relative_path, operation=self
-                )
-            )
+            file_import.merge(parameter.imports(async_mode=False, relative_path=relative_path, operation=self))
 
         file_import.add_submodule_import(
             "rest",
@@ -113,33 +106,23 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )
-        file_import.add_submodule_import(
-            "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
-        )
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL)
         file_import.add_msrest_import(
             relative_path=(
                 "..."
-                if (
-                    not self.code_model.options["builders_visibility"] == "embedded"
-                    and self.group_name
-                )
+                if (not self.code_model.options["builders_visibility"] == "embedded" and self.group_name)
                 else ".."
             ),
             msrest_import_type=MsrestImportType.Serializer,
             typing_section=TypingSection.REGULAR,
         )
-        if (
-            self.overloads
-            and self.code_model.options["builders_visibility"] != "embedded"
-        ):
+        if self.overloads and self.code_model.options["builders_visibility"] != "embedded":
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
 
     @staticmethod
     @abstractmethod
-    def parameter_list_type() -> (
-        Callable[[Dict[str, Any], "CodeModel"], ParameterListType]
-    ): ...
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], ParameterListType]: ...
 
     @classmethod
     def get_name(
@@ -150,13 +133,8 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
         client: "Client",
     ) -> str:
         additional_mark = ""
-        if (
-            code_model.options["combine_operation_files"]
-            and code_model.options["builders_visibility"] == "embedded"
-        ):
-            additional_mark = (
-                yaml_data["groupName"] or client.yaml_data["builderPadName"]
-            )
+        if code_model.options["combine_operation_files"] and code_model.options["builders_visibility"] == "embedded":
+            additional_mark = yaml_data["groupName"] or client.yaml_data["builderPadName"]
         names = [
             "build",
             additional_mark,
@@ -193,19 +171,13 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
 
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> (
-        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]
-    ):
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]:
         return RequestBuilderParameterList.from_yaml
 
 
-class OverloadedRequestBuilder(
-    RequestBuilderBase[OverloadedRequestBuilderParameterList]
-):
+class OverloadedRequestBuilder(RequestBuilderBase[OverloadedRequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> (
-        Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]
-    ):
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]:
         return OverloadedRequestBuilderParameterList.from_yaml
 
 

package/autorest/codegen/models/request_builder_parameter.py

@@ -40,9 +40,7 @@ class RequestBuilderBodyParameter(BodyParameter):
     @property
     def in_method_signature(self) -> bool:
         return (
-            super().in_method_signature
-            and not self.is_partial_body
-            and self.code_model.options["models_mode"] != "dpg"
+            super().in_method_signature and not self.is_partial_body and self.code_model.options["models_mode"] != "dpg"
         )
 
     @property
@@ -54,9 +52,7 @@ class RequestBuilderBodyParameter(BodyParameter):
         )
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "RequestBuilderBodyParameter":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "RequestBuilderBodyParameter":
         return super().from_yaml(yaml_data, code_model)  # type: ignore
 
     @property
@@ -92,9 +88,7 @@ class RequestBuilderParameter(Parameter):
         if self.grouped_by and not self.in_flattened_body:
             return True
         return super().in_method_signature and not (
-            self.location == ParameterLocation.ENDPOINT_PATH
-            or self.in_flattened_body
-            or self.grouper
+            self.location == ParameterLocation.ENDPOINT_PATH or self.in_flattened_body or self.grouper
         )
 
     @property
@@ -106,10 +100,7 @@ class RequestBuilderParameter(Parameter):
         super_method_location = super().method_location
         if super_method_location == ParameterMethodLocation.KWARG:
             return super_method_location
-        if (
-            self.in_overriden
-            and super_method_location == ParameterMethodLocation.KEYWORD_ONLY
-        ):
+        if self.in_overriden and super_method_location == ParameterMethodLocation.KEYWORD_ONLY:
             return ParameterMethodLocation.KWARG
         if self.location != ParameterLocation.PATH:
             return ParameterMethodLocation.KEYWORD_ONLY