schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/specs/openapi/loaders.py

@@ -1,37 +1,41 @@
 from __future__ import annotations
+
 import io
 import json
 import pathlib
 import re
-from typing import IO, Any, Callable, cast, TYPE_CHECKING
+from typing import IO, TYPE_CHECKING, Any, Callable, cast
 from urllib.parse import urljoin
 
 from ... import experimental, fixups
 from ...code_samples import CodeSampleStyle
+from ...constants import DEFAULT_RESPONSE_TIMEOUT, NOT_SET, WAIT_FOR_SCHEMA_INTERVAL
+from ...exceptions import SchemaError, SchemaErrorType
+from ...filters import filter_set_from_components
 from ...generation import (
     DEFAULT_DATA_GENERATION_METHODS,
-    DataGenerationMethodInput,
     DataGenerationMethod,
+    DataGenerationMethodInput,
     GenerationConfig,
 )
-from ...constants import WAIT_FOR_SCHEMA_INTERVAL
-from ...exceptions import SchemaError, SchemaErrorType
 from ...hooks import HookContext, dispatch
+from ...internal.deprecation import warn_filtration_arguments
+from ...internal.output import OutputConfig
+from ...internal.validation import require_relative_url
 from ...loaders import load_schema_from_url, load_yaml
 from ...throttling import build_limiter
-from ...types import Filter, NotSet, PathLike
 from ...transports.content_types import is_json_media_type, is_yaml_media_type
 from ...transports.headers import setup_default_headers
-from ...internal.validation import require_relative_url
-from ...constants import NOT_SET
+from ...types import Filter, NotSet, PathLike, Specification
 from . import definitions, validation
 
 if TYPE_CHECKING:
-    from .schemas import BaseOpenAPISchema
-    from ...transports.responses import GenericResponse
     import jsonschema
     from pyrate_limiter import Limiter
+
     from ...lazy import LazySchema
+    from ...transports.responses import GenericResponse
+    from .schemas import BaseOpenAPISchema
 
 
 def _is_json_response(response: GenericResponse) -> bool:
@@ -73,11 +77,12 @@ def from_path(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     encoding: str = "utf8",
@@ -102,6 +107,7 @@ def from_path(
             force_schema_version=force_schema_version,
             data_generation_methods=data_generation_methods,
             generation_config=generation_config,
+            output_config=output_config,
             code_sample_style=code_sample_style,
             location=pathlib.Path(path).absolute().as_uri(),
             rate_limit=rate_limit,
@@ -121,11 +127,12 @@ def from_uri(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     wait_for_schema: float | None = None,
     rate_limit: str | None = None,
@@ -156,11 +163,12 @@ def from_uri(
             interval=WAIT_FOR_SCHEMA_INTERVAL,
         )
         def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
-            return requests.get(_uri, **kwargs)
+            return requests.get(_uri, **_kwargs)
 
     else:
         _load_schema = requests.get
 
+    kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
     response = load_schema_from_url(lambda: _load_schema(uri, **kwargs))
     return from_file(
         response.text,
@@ -175,6 +183,7 @@ def from_uri(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=uri,
         rate_limit=rate_limit,
@@ -215,11 +224,12 @@ def from_file(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: str | None = None,
     rate_limit: str | None = None,
@@ -266,6 +276,7 @@ def from_file(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=location,
         rate_limit=rate_limit,
@@ -289,11 +300,12 @@ def from_dict(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: str | None = None,
     rate_limit: str | None = None,
@@ -303,6 +315,7 @@ def from_dict(
 
     :param dict raw_schema: A schema to load.
     """
+    from ... import transports
     from .schemas import OpenApi30, SwaggerV20
 
     if not isinstance(raw_schema, dict):
@@ -320,24 +333,36 @@ def from_dict(
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
 
+    for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+        value = locals()[name]
+        if value is not None:
+            warn_filtration_arguments(name)
+    filter_set = filter_set_from_components(
+        include=True,
+        method=method,
+        endpoint=endpoint,
+        tag=tag,
+        operation_id=operation_id,
+        skip_deprecated_operations=skip_deprecated_operations,
+    )
+
     def init_openapi_2() -> SwaggerV20:
         _maybe_validate_schema(raw_schema, definitions.SWAGGER_20_VALIDATOR, validate_schema)
         instance = SwaggerV20(
             raw_schema,
+            specification=Specification.OPENAPI,
             app=app,
             base_url=base_url,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
+            filter_set=filter_set,
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),
+            output_config=output_config or OutputConfig(),
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
             sanitize_output=sanitize_output,
+            transport=transports.get(app),
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -365,20 +390,19 @@ def from_dict(
         _maybe_validate_schema(raw_schema, validator, validate_schema)
         instance = OpenApi30(
             raw_schema,
+            specification=Specification.OPENAPI,
             app=app,
             base_url=base_url,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
+            filter_set=filter_set,
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),
+            output_config=output_config or OutputConfig(),
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
             sanitize_output=sanitize_output,
+            transport=transports.get(app),
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -418,7 +442,7 @@ def _format_status_codes(status_codes: list[tuple[int, list[str | int]]]) -> str
     for status_code, path in status_codes:
         buffer.write(f" - {status_code} at schema['paths']")
         for chunk in path:
-            buffer.write(f"[{repr(chunk)}]")
+            buffer.write(f"[{chunk!r}]")
         buffer.write("['responses']\n")
     return buffer.getvalue().rstrip()
 
@@ -459,10 +483,11 @@ def from_pytest_fixture(
     endpoint: Filter | None = NOT_SET,
     tag: Filter | None = NOT_SET,
     operation_id: Filter | None = NOT_SET,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
     generation_config: GenerationConfig | NotSet = NOT_SET,
+    output_config: OutputConfig | NotSet = NOT_SET,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -488,18 +513,27 @@ def from_pytest_fixture(
     rate_limiter: Limiter | None = None
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
-    return LazySchema(
-        fixture_name,
-        app=app,
-        base_url=base_url,
+    for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+        value = locals()[name]
+        if value is not None:
+            warn_filtration_arguments(name)
+    filter_set = filter_set_from_components(
+        include=True,
         method=method,
         endpoint=endpoint,
         tag=tag,
         operation_id=operation_id,
         skip_deprecated_operations=skip_deprecated_operations,
+    )
+    return LazySchema(
+        fixture_name,
+        app=app,
+        base_url=base_url,
+        filter_set=filter_set,
         validate_schema=validate_schema,
         data_generation_methods=_data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
@@ -515,11 +549,12 @@ def from_wsgi(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -530,9 +565,10 @@ def from_wsgi(
     :param str schema_path: An in-app relative URL to the schema.
     :param app: A WSGI app instance.
     """
-    from ...transports.responses import WSGIResponse
     from werkzeug.test import Client
 
+    from ...transports.responses import WSGIResponse
+
     require_relative_url(schema_path)
     setup_default_headers(kwargs)
     client = Client(app, WSGIResponse)
@@ -550,6 +586,7 @@ def from_wsgi(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,
@@ -559,9 +596,9 @@ def from_wsgi(
 
 
 def get_loader_for_app(app: Any) -> Callable:
-    from starlette.applications import Starlette
+    from ...transports.asgi import is_asgi_app
 
-    if isinstance(app, Starlette):
+    if is_asgi_app(app):
         return from_asgi
     if app.__class__.__module__.startswith("aiohttp."):
         return from_aiohttp
@@ -577,11 +614,12 @@ def from_aiohttp(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -609,6 +647,7 @@ def from_aiohttp(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
@@ -625,11 +664,12 @@ def from_asgi(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -659,6 +699,7 @@ def from_asgi(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,

schemathesis/specs/openapi/media_types.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Collection
+
+if TYPE_CHECKING:
+    from hypothesis import strategies as st
+
+
+MEDIA_TYPES: dict[str, st.SearchStrategy[bytes]] = {}
+
+
+def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliases: Collection[str] = ()) -> None:
+    """Register a strategy for the given media type."""
+    from ...serializers import SerializerContext, register
+
+    @register(name, aliases=aliases)
+    class MediaTypeSerializer:
+        def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
+            return {"data": value}
+
+        def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
+            return {"data": value}
+
+    MEDIA_TYPES[name] = strategy
+    for alias in aliases:
+        MEDIA_TYPES[alias] = strategy
+
+
+def unregister_all() -> None:
+    from ...serializers import unregister
+
+    for media_type in MEDIA_TYPES:
+        unregister(media_type)
+    MEDIA_TYPES.clear()

schemathesis/specs/openapi/negative/__init__.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urlencode
 
 import jsonschema
@@ -10,8 +11,10 @@ from hypothesis_jsonschema import from_schema
 
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
-from .types import Draw, Schema
-from ....generation import GenerationConfig
+
+if TYPE_CHECKING:
+    from ....generation import GenerationConfig
+    from .types import Draw, Schema
 
 
 @dataclass

schemathesis/specs/openapi/negative/mutations.py

@@ -1,5 +1,7 @@
 """Schema mutations."""
+
 from __future__ import annotations
+
 import enum
 from dataclasses import dataclass
 from functools import wraps
@@ -79,6 +81,10 @@ class MutationContext:
     def is_path_location(self) -> bool:
         return self.location == "path"
 
+    @property
+    def is_query_location(self) -> bool:
+        return self.location == "query"
+
     def mutate(self, draw: Draw) -> Schema:
         # On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
         # taken as-is. Therefore, we can only apply mutations that won't change the Open API semantics of the schema.
@@ -173,7 +179,7 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     else:
         candidate = draw(st.sampled_from(sorted(required)))
         enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))  # type: ignore
-        candidates = [candidate] + sorted([prop for prop in required if enabled_properties.is_enabled(prop)])
+        candidates = [candidate, *sorted([prop for prop in required if enabled_properties.is_enabled(prop)])]
         property_name = draw(st.sampled_from(candidates))
     required.remove(property_name)
     if not required:
@@ -201,8 +207,11 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     if context.media_type == "application/x-www-form-urlencoded":
         # Form data should be an object, do not change it
         return MutationResult.FAILURE
-    # Headers are always strings, can't negate this
-    if context.is_header_location:
+    # For headers, query and path parameters, if the current type is string, then it already
+    # includes all possible values as those parameters will be stringified before sending,
+    # therefore it can't be negated.
+    types = get_type(schema)
+    if "string" in types and (context.is_header_location or context.is_path_location or context.is_query_location):
         return MutationResult.FAILURE
     candidates = _get_type_candidates(context, schema)
     if not candidates:
@@ -217,9 +226,10 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     candidate = draw(st.sampled_from(sorted(candidates)))
     candidates.remove(candidate)
     enabled_types = draw(st.shared(FeatureStrategy(), key="types"))  # type: ignore
-    remaining_candidates = [candidate] + sorted(
-        [candidate for candidate in candidates if enabled_types.is_enabled(candidate)]
-    )
+    remaining_candidates = [
+        candidate,
+        *sorted([candidate for candidate in candidates if enabled_types.is_enabled(candidate)]),
+    ]
     new_type = draw(st.sampled_from(remaining_candidates))
     schema["type"] = new_type
     prevent_unsatisfiable_schema(schema, new_type)
@@ -362,6 +372,11 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
         # Should we negate this key?
         if k == "required":
             return v != []
+        if k in ("example", "examples"):
+            return False
+        if context.is_path_location and k == "minLength" and v == 1:
+            # Empty path parameter will be filtered out
+            return False
         return not (
             k in ("type", "properties", "items", "minItems")
             or (k == "additionalProperties" and context.is_header_location)

schemathesis/specs/openapi/parameters.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
+
 import json
 from dataclasses import dataclass
-from typing import Any, ClassVar, Iterable
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 
 from ...exceptions import OperationSchemaError
-from ...models import APIOperation
 from ...parameters import Parameter
 from .converter import to_json_schema_recursive
 
+if TYPE_CHECKING:
+    from ...models import APIOperation
+
 
 @dataclass(eq=False)
 class OpenAPIParameter(Parameter):
@@ -18,6 +21,7 @@ class OpenAPIParameter(Parameter):
     nullable_field: ClassVar[str]
     supported_jsonschema_keywords: ClassVar[tuple[str, ...]]
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
     @property
     def description(self) -> str | None:
         """A brief parameter description."""
@@ -47,16 +51,26 @@ class OpenAPIParameter(Parameter):
 
     @property
     def is_header(self) -> bool:
-        raise NotImplementedError
+        return self.location in ("header", "cookie")
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert parameter's definition to JSON Schema."""
+        # JSON Schema allows `examples` as an array
+        examples = []
+        if self.examples_field in self.definition:
+            examples.extend(
+                [example["value"] for example in self.definition[self.examples_field].values() if "value" in example]
+            )
+        if self.example_field in self.definition:
+            examples.append(self.definition[self.example_field])
         schema = self.from_open_api_to_json_schema(operation, self.definition)
-        return self.transform_keywords(schema)
+        if examples:
+            schema["examples"] = examples
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
-    def transform_keywords(self, schema: dict[str, Any]) -> dict[str, Any]:
+    def transform_keywords(self, schema: dict[str, Any], *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Transform Open API specific keywords into JSON Schema compatible form."""
-        definition = to_json_schema_recursive(schema, self.nullable_field)
+        definition = to_json_schema_recursive(schema, self.nullable_field, update_quantifiers=update_quantifiers)
         # Headers are strings, but it is not always explicitly defined in the schema. By preparing them properly, we
         # can achieve significant performance improvements for such cases.
         # For reference (my machine) - running a single test with 100 examples with the resulting strategy:
@@ -116,12 +130,10 @@ class OpenAPI20Parameter(OpenAPIParameter):
         "uniqueItems",
         "enum",
         "multipleOf",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location == "header"
-
 
 @dataclass(eq=False)
 class OpenAPI30Parameter(OpenAPIParameter):
@@ -162,12 +174,10 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "properties",
         "additionalProperties",
         "format",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location in ("header", "cookie")
-
     def from_open_api_to_json_schema(self, operation: APIOperation, open_api_schema: dict[str, Any]) -> dict[str, Any]:
         open_api_schema = get_parameter_schema(operation, open_api_schema)
         return super().from_open_api_to_json_schema(operation, open_api_schema)
@@ -216,15 +226,17 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
         "allOf",
         "properties",
         "additionalProperties",
+        "example",
+        "examples",
     )
     # NOTE. For Open API 2.0 bodies, we still give `x-example` precedence over the schema-level `example` field to keep
     # the precedence rules consistent.
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert body definition to JSON Schema."""
         # `schema` is required in Open API 2.0 when the `in` keyword is `body`
         schema = self.definition["schema"]
-        return self.transform_keywords(schema)
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
 
 FORM_MEDIA_TYPES = ("multipart/form-data", "application/x-www-form-urlencoded")
@@ -243,13 +255,13 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
     required: bool = False
     description: str | None = None
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert body definition to JSON Schema."""
         schema = get_media_type_schema(self.definition)
-        return self.transform_keywords(schema)
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
-    def transform_keywords(self, schema: dict[str, Any]) -> dict[str, Any]:
-        definition = super().transform_keywords(schema)
+    def transform_keywords(self, schema: dict[str, Any], *, update_quantifiers: bool = True) -> dict[str, Any]:
+        definition = super().transform_keywords(schema, update_quantifiers=update_quantifiers)
         if self.is_form:
             # It significantly reduces the "filtering" part of data generation.
             definition.setdefault("type", "object")
@@ -287,12 +299,14 @@ class OpenAPI20CompositeBody(OpenAPIBody, OpenAPI20Parameter):
         # We generate an object for formData - it is always required.
         return bool(self.definition)
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """The composite body is transformed into an "object" JSON Schema."""
-        return parameters_to_json_schema(operation, self.definition)
+        return parameters_to_json_schema(operation, self.definition, update_quantifiers=update_quantifiers)
 
 
-def parameters_to_json_schema(operation: APIOperation, parameters: Iterable[OpenAPIParameter]) -> dict[str, Any]:
+def parameters_to_json_schema(
+    operation: APIOperation, parameters: Iterable[OpenAPIParameter], *, update_quantifiers: bool = True
+) -> dict[str, Any]:
     """Create an "object" JSON schema from a list of Open API parameters.
 
     :param List[OpenAPIParameter] parameters: A list of Open API parameters related to the same location. All of
@@ -332,7 +346,7 @@ def parameters_to_json_schema(operation: APIOperation, parameters: Iterable[Open
     required = []
     for parameter in parameters:
         name = parameter.name
-        properties[name] = parameter.as_json_schema(operation)
+        properties[name] = parameter.as_json_schema(operation, update_quantifiers=update_quantifiers)
         # If parameter names are duplicated, we need to avoid duplicate entries in `required` anyway
         if parameter.is_required and name not in required:
             required.append(name)