schemathesis 4.0.0a11__py3-none-any.whl → 4.0.0b1__py3-none-any.whl

schemathesis/specs/openapi/negative/__init__.py

@@ -28,16 +28,17 @@ class CacheKey:
     operation_name: str
     location: str
     schema: Schema
+    validator_cls: type[jsonschema.Validator]
 
     def __hash__(self) -> int:
         return hash((self.operation_name, self.location))
 
 
 @lru_cache
-def get_validator(cache_key: CacheKey) -> jsonschema.Draft4Validator:
+def get_validator(cache_key: CacheKey) -> jsonschema.Validator:
     """Get JSON Schema validator for the given schema."""
     # Each operation / location combo has only a single schema, therefore could be cached
-    return jsonschema.Draft4Validator(cache_key.schema)
+    return cache_key.validator_cls(cache_key.schema)
 
 
 @lru_cache
@@ -63,6 +64,7 @@ def negative_schema(
     generation_config: GenerationConfig,
     *,
     custom_formats: dict[str, st.SearchStrategy[str]],
+    validator_cls: type[jsonschema.Validator],
 ) -> st.SearchStrategy:
     """A strategy for instances that DO NOT match the input schema.
 
@@ -70,7 +72,7 @@ def negative_schema(
     """
     # The mutated schema is passed to `from_schema` and guarded against producing instances valid against
     # the original schema.
-    cache_key = CacheKey(operation_name, location, schema)
+    cache_key = CacheKey(operation_name, location, schema, validator_cls)
     validator = get_validator(cache_key)
     keywords, non_keywords = split_schema(cache_key)
 

schemathesis/specs/openapi/negative/mutations.py

@@ -402,8 +402,8 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
                 if key in DEPENDENCIES:
                     # If this keyword has a dependency, then it should be also negated
                     dependency = DEPENDENCIES[key]
-                    if dependency not in negated:
-                        negated[dependency] = copied[dependency]  # Assuming the schema is valid
+                    if dependency not in negated and dependency in copied:
+                        negated[dependency] = copied[dependency]
         else:
             schema[key] = value
     if is_negated:

schemathesis/specs/openapi/parameters.py

@@ -314,9 +314,6 @@ def parameters_to_json_schema(
 ) -> 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
-        them are expected to have the same "in" value.
-
     For each input parameter, there will be a property in the output schema.
 
     This:

schemathesis/specs/openapi/schemas.py

@@ -39,7 +39,6 @@ from schemathesis.core.transport import Response
 from schemathesis.core.validation import INVALID_HEADER_RE
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import CaseMetadata
-from schemathesis.generation.overrides import Override, OverrideMark, check_no_override_mark
 from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
 from schemathesis.specs.openapi.stateful import links
 
@@ -120,13 +119,18 @@ class BaseOpenAPISchema(BaseSchema):
         if map is not None:
             return map
         path_item = self.raw_schema.get("paths", {})[path]
-        scope, path_item = self._resolve_path_item(path_item)
+        with in_scope(self.resolver, self.location or ""):
+            scope, path_item = self._resolve_path_item(path_item)
         self.dispatch_hook("before_process_path", HookContext(), path, path_item)
         map = APIOperationMap(self, {})
         map._data = MethodMap(map, scope, path, CaseInsensitiveDict(path_item))
         cache.insert_map(path, map)
         return map
 
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        method, path = label.split(" ", maxsplit=1)
+        return self[path][method]
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         matches = get_close_matches(item, list(self))
         self._on_missing_operation(item, exc, matches)
@@ -254,26 +258,6 @@ class BaseOpenAPISchema(BaseSchema):
                 # Ignore errors
                 continue
 
-    def override(
-        self,
-        *,
-        query: dict[str, str] | None = None,
-        headers: dict[str, str] | None = None,
-        cookies: dict[str, str] | None = None,
-        path_parameters: dict[str, str] | None = None,
-    ) -> Callable[[Callable], Callable]:
-        """Override Open API parameters with fixed values."""
-
-        def _add_override(test: Callable) -> Callable:
-            check_no_override_mark(test)
-            override = Override(
-                query=query or {}, headers=headers or {}, cookies=cookies or {}, path_parameters=path_parameters or {}
-            )
-            OverrideMark.set(test, override)
-            return test
-
-        return _add_override
-
     def _resolve_until_no_references(self, value: dict[str, Any]) -> dict[str, Any]:
         while "$ref" in value:
             _, value = self.resolver.resolve(value["$ref"])
@@ -536,7 +520,7 @@ class BaseOpenAPISchema(BaseSchema):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         return openapi_cases(
@@ -591,52 +575,6 @@ class BaseOpenAPISchema(BaseSchema):
     def as_state_machine(self) -> type[APIStateMachine]:
         return create_state_machine(self)
 
-    def add_link(
-        self,
-        source: APIOperation,
-        target: str | APIOperation,
-        status_code: str | int,
-        parameters: dict[str, str] | None = None,
-        request_body: Any = None,
-        name: str | None = None,
-    ) -> None:
-        """Add a new Open API link to the schema definition.
-
-        :param APIOperation source: This operation is the source of data
-        :param target: This operation will receive the data from this link.
-            Can be an ``APIOperation`` instance or a reference like this - ``#/paths/~1users~1{userId}/get``
-        :param str status_code: The link is triggered when the source API operation responds with this status code.
-        :param parameters: A dictionary that describes how parameters should be extracted from the matched response.
-            The key represents the parameter name in the target API operation, and the value is a runtime
-            expression string.
-        :param request_body: A literal value or runtime expression to use as a request body when
-            calling the target operation.
-        :param str name: Explicit link name.
-
-        .. code-block:: python
-
-            schema = schemathesis.openapi.from_url("http://0.0.0.0/schema.yaml")
-
-            schema.add_link(
-                source=schema["/users/"]["POST"],
-                target=schema["/users/{userId}"]["GET"],
-                status_code="201",
-                parameters={"userId": "$response.body#/id"},
-            )
-        """
-        if parameters is None and request_body is None:
-            raise ValueError("You need to provide `parameters` or `request_body`.")
-        links.add_link(
-            resolver=self.resolver,
-            responses=self[source.path][source.method].definition.raw["responses"],
-            links_field=self.links_field,
-            parameters=parameters,
-            request_body=request_body,
-            status_code=status_code,
-            target=target,
-            name=name,
-        )
-
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
         result: dict[str, dict[str, Any]] = defaultdict(dict)
         for status_code, link in links.get_all_links(operation):
@@ -658,6 +596,7 @@ class BaseOpenAPISchema(BaseSchema):
         return jsonschema.Draft4Validator
 
     def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
+        __tracebackhide__ = True
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
         status_code = str(response.status_code)
         if status_code in responses:
@@ -903,7 +842,7 @@ class MethodMap(Mapping):
         try:
             return self._init_operation(item)
         except LookupError as exc:
-            available_methods = ", ".join(map(str.upper, self))
+            available_methods = ", ".join(key.upper() for key in self if key in HTTP_METHODS)
             message = f"Method `{item.upper()}` not found."
             if available_methods:
                 message += f" Available methods: {available_methods}"
@@ -1001,12 +940,6 @@ class SwaggerV20(BaseOpenAPISchema):
     def prepare_multipart(
         self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
-        """Prepare form data for sending with `requests`.
-
-        :param form_data: Raw generated data as a dictionary.
-        :param operation: The tested API operation for which the data was generated.
-        :return: `files` and `data` values for `requests.request`.
-        """
         files, data = [], {}
         # If there is no content types specified for the request or "application/x-www-form-urlencoded" is specified
         # explicitly, then use it., but if "multipart/form-data" is specified, then use it
@@ -1050,7 +983,7 @@ class SwaggerV20(BaseOpenAPISchema):
         method: str | None = None,
         path: str | None = None,
         path_parameters: dict[str, Any] | None = None,
-        headers: dict[str, Any] | None = None,
+        headers: dict[str, Any] | CaseInsensitiveDict | None = None,
         cookies: dict[str, Any] | None = None,
         query: dict[str, Any] | None = None,
         body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET,
@@ -1063,22 +996,16 @@ class SwaggerV20(BaseOpenAPISchema):
             operation=operation,
             method=method or operation.method.upper(),
             path=path or operation.path,
-            path_parameters=path_parameters,
-            headers=CaseInsensitiveDict(headers) if headers is not None else headers,
-            cookies=cookies,
-            query=query,
+            path_parameters=path_parameters or {},
+            headers=CaseInsensitiveDict() if headers is None else CaseInsensitiveDict(headers),
+            cookies=cookies or {},
+            query=query or {},
             body=body,
             media_type=media_type,
             meta=meta,
         )
 
     def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:
-        """Get the `consumes` value for the given API operation.
-
-        :param definition: Raw API operation definition.
-        :return: A list of media-types for this operation.
-        :rtype: List[str]
-        """
         global_consumes = self.raw_schema.get("consumes", [])
         consumes = definition.get("consumes", [])
         if not consumes:
@@ -1177,12 +1104,6 @@ class OpenApi30(SwaggerV20):
     def prepare_multipart(
         self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
-        """Prepare form data for sending with `requests`.
-
-        :param form_data: Raw generated data as a dictionary.
-        :param operation: The tested API operation for which the data was generated.
-        :return: `files` and `data` values for `requests.request`.
-        """
         files = []
         definition = operation.definition.raw
         if "$ref" in definition["requestBody"]:

schemathesis/specs/openapi/stateful/__init__.py

@@ -14,6 +14,7 @@ from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
+from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi.stateful.control import TransitionController
@@ -32,7 +33,7 @@ class OpenAPIStateMachine(APIStateMachine):
     _transitions: ApiTransitions
 
     def __init__(self) -> None:
-        self.recorder = ScenarioRecorder(label="Stateful tests")
+        self.recorder = ScenarioRecorder(label=STATEFUL_TESTS_LABEL)
         self.control = TransitionController(self._transitions)
         super().__init__()
 

schemathesis/specs/openapi/stateful/links.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Callable, Generator, Literal, Union, cast
+from typing import Any, Callable, Generator, Literal, cast
 
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
@@ -13,10 +13,6 @@ from schemathesis.specs.openapi import expressions
 from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 from schemathesis.specs.openapi.references import RECURSION_DEPTH_LIMIT
 
-if TYPE_CHECKING:
-    from jsonschema import RefResolver
-
-
 SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
 ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
 
@@ -211,61 +207,3 @@ def get_all_links(
                 yield status_code, Ok(link)
             except InvalidTransition as exc:
                 yield status_code, Err(exc)
-
-
-StatusCode = Union[str, int]
-
-
-def _get_response_by_status_code(responses: dict[StatusCode, dict[str, Any]], status_code: str | int) -> dict:
-    if isinstance(status_code, int):
-        # Invalid schemas may contain status codes as integers
-        if status_code in responses:
-            return responses[status_code]
-        # Passed here as an integer, but there is no such status code as int
-        # We cast it to a string because it is either there already and we'll get relevant responses, otherwise
-        # a new dict will be created because there is no such status code in the schema (as an int or a string)
-        return responses.setdefault(str(status_code), {})
-    if status_code.isnumeric():
-        # Invalid schema but the status code is passed as a string
-        numeric_status_code = int(status_code)
-        if numeric_status_code in responses:
-            return responses[numeric_status_code]
-    # All status codes as strings, including `default` and patterned values like `5XX`
-    return responses.setdefault(status_code, {})
-
-
-def add_link(
-    resolver: RefResolver,
-    responses: dict[StatusCode, dict[str, Any]],
-    links_field: str,
-    parameters: dict[str, str] | None,
-    request_body: Any,
-    status_code: StatusCode,
-    target: str | APIOperation,
-    name: str | None = None,
-) -> None:
-    response = _get_response_by_status_code(responses, status_code)
-    if "$ref" in response:
-        _, response = resolver.resolve(response["$ref"])
-    links_definition = response.setdefault(links_field, {})
-    new_link: dict[str, str | dict[str, str]] = {}
-    if parameters is not None:
-        new_link["parameters"] = parameters
-    if request_body is not None:
-        new_link["requestBody"] = request_body
-    if isinstance(target, str):
-        name = name or target
-        new_link["operationRef"] = target
-    else:
-        name = name or f"{target.method.upper()} {target.path}"
-        # operationId is a dict lookup which is more efficient than using `operationRef`, since it
-        # doesn't involve reference resolving when we will look up for this target during testing.
-        if "operationId" in target.definition.raw:
-            new_link["operationId"] = target.definition.raw["operationId"]
-        else:
-            new_link["operationRef"] = target.operation_reference
-    # The name is arbitrary, so we don't really case what it is,
-    # but it should not override existing links
-    while name in links_definition:
-        name += "_new"
-    links_definition[name] = new_link

schemathesis/transport/__init__.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from inspect import iscoroutinefunction
-from typing import Any, Callable, Generic, Iterator, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Generic, Iterator, TypeVar, Union
 
 from schemathesis.core import media_types
 from schemathesis.core.errors import SerializationNotPossible
 
+if TYPE_CHECKING:
+    from schemathesis.core.transport import Response
+    from schemathesis.generation.case import Case
+
 
 def get(app: Any) -> BaseTransport:
     """Get transport to send the data to the application."""
@@ -23,41 +27,43 @@ def get(app: Any) -> BaseTransport:
     return WSGI_TRANSPORT
 
 
-C = TypeVar("C", contravariant=True)
-R = TypeVar("R", covariant=True)
 S = TypeVar("S", contravariant=True)
 
 
 @dataclass
-class SerializationContext(Generic[C]):
-    """Generic context for serialization process."""
+class SerializationContext:
+    """Context object passed to serializer functions.
+
+    It provides access to the generated test case and any related metadata.
+    """
 
-    case: C
+    case: Case
+    """The generated test case."""
 
     __slots__ = ("case",)
 
 
-Serializer = Callable[[SerializationContext[C], Any], Any]
+Serializer = Callable[[SerializationContext, Any], Any]
 
 
-class BaseTransport(Generic[C, R, S]):
+class BaseTransport(Generic[S]):
     """Base implementation with serializer registration."""
 
     def __init__(self) -> None:
-        self._serializers: dict[str, Serializer[C]] = {}
+        self._serializers: dict[str, Serializer] = {}
 
-    def serialize_case(self, case: C, **kwargs: Any) -> dict[str, Any]:
+    def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
         """Prepare the case for sending."""
         raise NotImplementedError
 
-    def send(self, case: C, *, session: S | None = None, **kwargs: Any) -> R:
+    def send(self, case: Case, *, session: S | None = None, **kwargs: Any) -> Response:
         """Send the case using this transport."""
         raise NotImplementedError
 
-    def serializer(self, *media_types: str) -> Callable[[Serializer[C]], Serializer[C]]:
+    def serializer(self, *media_types: str) -> Callable[[Serializer], Serializer]:
         """Register a serializer for given media types."""
 
-        def decorator(func: Serializer[C]) -> Serializer[C]:
+        def decorator(func: Serializer) -> Serializer:
             for media_type in media_types:
                 self._serializers[media_type] = func
             return func
@@ -71,10 +77,10 @@ class BaseTransport(Generic[C, R, S]):
     def _copy_serializers_from(self, transport: BaseTransport) -> None:
         self._serializers.update(transport._serializers)
 
-    def get_first_matching_media_type(self, media_type: str) -> tuple[str, Serializer[C]] | None:
+    def get_first_matching_media_type(self, media_type: str) -> tuple[str, Serializer] | None:
         return next(self.get_matching_media_types(media_type), None)
 
-    def get_matching_media_types(self, media_type: str) -> Iterator[tuple[str, Serializer[C]]]:
+    def get_matching_media_types(self, media_type: str) -> Iterator[tuple[str, Serializer]]:
         """Get all registered media types matching the given media type."""
         if media_type == "*/*":
             # Shortcut to avoid comparing all values
@@ -96,9 +102,41 @@ class BaseTransport(Generic[C, R, S]):
                     if main in ("*", target_main) and sub in ("*", target_sub):
                         yield registered_media_type, serializer
 
-    def _get_serializer(self, input_media_type: str) -> Serializer[C]:
+    def _get_serializer(self, input_media_type: str) -> Serializer:
         pair = self.get_first_matching_media_type(input_media_type)
         if pair is None:
             # This media type is set manually. Otherwise, it should have been rejected during the data generation
             raise SerializationNotPossible.for_media_type(input_media_type)
         return pair[1]
+
+
+_Serializer = Callable[[SerializationContext, Any], Union[bytes, None]]
+
+
+def serializer(*media_types: str) -> Callable[[_Serializer], None]:
+    """Register a serializer for specified media types on HTTP, ASGI, and WSGI transports.
+
+    Args:
+        *media_types: One or more MIME types (e.g., "application/json") this serializer handles.
+
+    Returns:
+        A decorator that wraps a function taking `(ctx: SerializationContext, value: Any)` and returning `bytes` for serialized body and `None` for omitting request body.
+
+    """
+
+    def register(func: _Serializer) -> None:
+        from schemathesis.transport.asgi import ASGI_TRANSPORT
+        from schemathesis.transport.requests import REQUESTS_TRANSPORT
+        from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+        @ASGI_TRANSPORT.serializer(*media_types)
+        @REQUESTS_TRANSPORT.serializer(*media_types)
+        @WSGI_TRANSPORT.serializer(*media_types)
+        def inner(ctx: SerializationContext, value: Any) -> dict[str, bytes]:
+            result = {}
+            serialized = func(ctx, value)
+            if serialized is not None:
+                result["data"] = serialized
+            return result
+
+    return register

schemathesis/transport/prepare.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Mapping, cast
 from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
@@ -8,6 +9,7 @@ from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER, NotSet
 from schemathesis.core.errors import InvalidSchema
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
 from schemathesis.core.transport import USER_AGENT
+from schemathesis.generation.meta import CoveragePhaseData
 
 if TYPE_CHECKING:
     from requests import PreparedRequest
@@ -16,15 +18,37 @@ if TYPE_CHECKING:
     from schemathesis.generation.case import Case
 
 
-def prepare_headers(case: Case, headers: dict[str, str] | None = None) -> CaseInsensitiveDict:
-    from requests.structures import CaseInsensitiveDict
+@lru_cache()
+def get_default_headers() -> CaseInsensitiveDict:
+    from requests.utils import default_headers
+
+    headers = default_headers()
+    headers["User-Agent"] = USER_AGENT
+    return headers
 
-    final_headers = case.headers.copy() if case.headers is not None else CaseInsensitiveDict()
+
+def prepare_headers(case: Case, headers: dict[str, str] | None = None) -> CaseInsensitiveDict:
+    default_headers = get_default_headers().copy()
+    if case.headers:
+        default_headers.update(case.headers)
+    default_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, case.id)
     if headers:
-        final_headers.update(headers)
-    final_headers.setdefault("User-Agent", USER_AGENT)
-    final_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, case.id)
-    return final_headers
+        default_headers.update(headers)
+    for header in get_exclude_headers(case):
+        default_headers.pop(header, None)
+    return default_headers
+
+
+def get_exclude_headers(case: Case) -> list[str]:
+    if (
+        case.meta is not None
+        and isinstance(case.meta.phase.data, CoveragePhaseData)
+        and case.meta.phase.data.description.startswith("Missing")
+        and case.meta.phase.data.description.endswith("at header")
+        and case.meta.phase.data.parameter is not None
+    ):
+        return [case.meta.phase.data.parameter]
+    return []
 
 
 def prepare_url(case: Case, base_url: str | None) -> str:

schemathesis/transport/requests.py

@@ -11,6 +11,7 @@ from schemathesis.core import NotSet
 from schemathesis.core.rate_limit import ratelimit
 from schemathesis.core.transforms import deepclone, merge_at
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT, Response
+from schemathesis.generation.overrides import Override
 from schemathesis.transport import BaseTransport, SerializationContext
 from schemathesis.transport.prepare import prepare_body, prepare_headers, prepare_url
 from schemathesis.transport.serialization import Binary, serialize_binary, serialize_json, serialize_xml, serialize_yaml
@@ -21,7 +22,7 @@ if TYPE_CHECKING:
     from schemathesis.generation.case import Case
 
 
-class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
+class RequestsTransport(BaseTransport["requests.Session"]):
     def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
         base_url = kwargs.get("base_url")
         headers = kwargs.get("headers")
@@ -92,6 +93,7 @@ class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
         if session is None:
             validate_vanilla_requests_kwargs(data)
             session = requests.Session()
+            session.headers = {}
             close_session = True
         else:
             close_session = False
@@ -103,7 +105,17 @@ class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
             rate_limit = config.rate_limit_for(operation=case.operation)
             with ratelimit(rate_limit, config.base_url):
                 response = session.request(**data)  # type: ignore
-            return Response.from_requests(response, verify=verify)
+            return Response.from_requests(
+                response,
+                verify=verify,
+                _override=Override(
+                    query=kwargs.get("params") or {},
+                    headers=kwargs.get("headers") or {},
+                    cookies=kwargs.get("cookies") or {},
+                    path_parameters={},
+                ),
+            )
+
         finally:
             if close_session:
                 session.close()
@@ -135,14 +147,14 @@ REQUESTS_TRANSPORT = RequestsTransport()
 
 
 @REQUESTS_TRANSPORT.serializer("application/json", "text/json")
-def json_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def json_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_json(value)
 
 
 @REQUESTS_TRANSPORT.serializer(
     "text/yaml", "text/x-yaml", "text/vnd.yaml", "text/yml", "application/yaml", "application/x-yaml"
 )
-def yaml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def yaml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_yaml(value)
 
 
@@ -188,7 +200,7 @@ def _encode_multipart(value: Any, boundary: str) -> bytes:
 
 
 @REQUESTS_TRANSPORT.serializer("multipart/form-data", "multipart/mixed")
-def multipart_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         return {"data": value}
     if isinstance(value, dict):
@@ -204,7 +216,7 @@ def multipart_serializer(ctx: SerializationContext[Case], value: Any) -> dict[st
 
 
 @REQUESTS_TRANSPORT.serializer("application/xml", "text/xml")
-def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     media_type = ctx.case.media_type
 
     assert media_type is not None
@@ -216,17 +228,17 @@ def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any
 
 
 @REQUESTS_TRANSPORT.serializer("application/x-www-form-urlencoded")
-def urlencoded_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def urlencoded_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": value}
 
 
 @REQUESTS_TRANSPORT.serializer("text/plain")
-def text_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def text_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         return {"data": value}
     return {"data": str(value).encode("utf8")}
 
 
 @REQUESTS_TRANSPORT.serializer("application/octet-stream")
-def binary_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def binary_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": serialize_binary(value)}

schemathesis/transport/serialization.py

@@ -82,10 +82,6 @@ def serialize_xml(
     """Serialize a generated Python object as an XML string.
 
     Schemas may contain additional information for fine-tuned XML serialization.
-
-    :param value: Generated value
-    :param raw_schema: The payload definition with not resolved references.
-    :param resolved_schema: The payload definition with all references resolved.
     """
     if isinstance(value, (bytes, str)):
         return {"data": value}