schemathesis 4.0.0a3__py3-none-any.whl → 4.0.0a5__py3-none-any.whl

schemathesis/pytest/plugin.py

@@ -108,7 +108,7 @@ class SchemathesisCase(PyCollector):
         This implementation is based on the original one in pytest, but with slight adjustments
         to produce tests out of hypothesis ones.
         """
-        from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, create_test
+        from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode, create_test
 
         is_trio_test = False
         for mark in getattr(self.test_function, "pytestmark", []):
@@ -133,6 +133,7 @@ class SchemathesisCase(PyCollector):
                     operation=operation,
                     test_func=self.test_function,
                     config=HypothesisTestConfig(
+                        modes=list(HypothesisTestMode),
                         given_kwargs=self.given_kwargs,
                         generation=self.schema.generation_config,
                         as_strategy_kwargs=as_strategy_kwargs,
@@ -149,11 +150,10 @@ class SchemathesisCase(PyCollector):
             error = result.err()
             funcobj = error.as_failing_test_function()
             name = self.name
-            # `full_path` is always available in this case
             if error.method:
-                name += f"[{error.method.upper()} {error.full_path}]"
+                name += f"[{error.method.upper()} {error.path}]"
             else:
-                name += f"[{error.full_path}]"
+                name += f"[{error.path}]"
 
         cls = self._get_class_parent()
         definition: FunctionDefinition = FunctionDefinition.from_parent(

schemathesis/schemas.py

@@ -619,7 +619,7 @@ class APIOperation(Generic[P]):
 
     def __post_init__(self) -> None:
         if self.label is None:
-            self.label = f"{self.method.upper()} {self.full_path}"  # type: ignore
+            self.label = f"{self.method.upper()} {self.path}"  # type: ignore
 
     @property
     def full_path(self) -> str:

schemathesis/specs/openapi/checks.py

@@ -41,11 +41,20 @@ if TYPE_CHECKING:
     from ...schemas import APIOperation
 
 
+def is_unexpected_http_status_case(case: Case) -> bool:
+    # Skip checks for requests using HTTP methods not defined in the API spec
+    return bool(
+        case.meta
+        and isinstance(case.meta.phase.data, CoveragePhaseData)
+        and case.meta.phase.data.description.startswith("Unspecified HTTP method")
+    )
+
+
 @schemathesis.check
 def status_code_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     responses = case.operation.definition.raw.get("responses", {})
     # "default" can be used as the default response object for all HTTP codes that are not covered individually
@@ -74,7 +83,7 @@ def _expand_responses(responses: dict[str | int, Any]) -> Generator[int, None, N
 def content_type_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     documented_content_types = case.operation.schema.get_content_types(case.operation, response)
     if not documented_content_types:
@@ -128,7 +137,7 @@ def response_headers_conformance(ctx: CheckContext, response: Response, case: Ca
     from .parameters import OpenAPI20Parameter, OpenAPI30Parameter
     from .schemas import BaseOpenAPISchema, OpenApi30, _maybe_raise_one_or_more
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     resolved = case.operation.schema.get_headers(case.operation, response)
     if not resolved:
@@ -208,7 +217,7 @@ def _coerce_header_value(value: str, schema: dict[str, Any]) -> str | int | floa
 def response_schema_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     return case.operation.validate_response(response)
 
@@ -217,7 +226,11 @@ def response_schema_conformance(ctx: CheckContext, response: Response, case: Cas
 def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema) or case.meta is None:
+    if (
+        not isinstance(case.operation.schema, BaseOpenAPISchema)
+        or case.meta is None
+        or is_unexpected_http_status_case(case)
+    ):
         return True
 
     config = ctx.config.get(negative_data_rejection, NegativeDataRejectionConfig())
@@ -241,7 +254,11 @@ def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -
 def positive_data_acceptance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema) or case.meta is None:
+    if (
+        not isinstance(case.operation.schema, BaseOpenAPISchema)
+        or case.meta is None
+        or is_unexpected_http_status_case(case)
+    ):
         return True
 
     config = ctx.config.get(positive_data_acceptance, PositiveDataAcceptanceConfig())
@@ -260,7 +277,7 @@ def positive_data_acceptance(ctx: CheckContext, response: Response, case: Case)
 def missing_required_header(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     # NOTE: This check is intentionally not registered with `@schemathesis.check` because it is experimental
     meta = case.meta
-    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData):
+    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData) or is_unexpected_http_status_case(case):
         return None
     data = meta.phase.data
     if (
@@ -282,7 +299,7 @@ def missing_required_header(ctx: CheckContext, response: Response, case: Case) -
 
 def unsupported_method(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     meta = case.meta
-    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData):
+    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData) or response.request.method == "OPTIONS":
         return None
     data = meta.phase.data
     if data.description and data.description.startswith("Unspecified HTTP method:"):
@@ -332,7 +349,7 @@ def has_only_additional_properties_in_non_body_parameters(case: Case) -> bool:
 def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     if response.status_code == 404 or response.status_code >= 500:
         return None
@@ -373,7 +390,7 @@ def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool |
 def ensure_resource_availability(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
 
     # First, check if this is a 4XX response
@@ -453,7 +470,7 @@ def ignored_auth(ctx: CheckContext, response: Response, case: Case) -> bool | No
     """Check if an operation declares authentication as a requirement but does not actually enforce it."""
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful

schemathesis/specs/openapi/examples.py

@@ -16,6 +16,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import examples
 from schemathesis.generation.meta import TestPhase
 from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
 from ._hypothesis import get_default_format_strategies, openapi_cases
 from .constants import LOCATION_TO_CONTAINER
@@ -50,11 +51,7 @@ def get_strategies_from_examples(
     operation: APIOperation[OpenAPIParameter], **kwargs: Any
 ) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
-    maps = {}
-    for location, container in LOCATION_TO_CONTAINER.items():
-        serializer = operation.get_parameter_serializer(location)
-        if serializer is not None:
-            maps[container] = serializer
+    maps = get_serializers_for_operation(operation)
 
     def serialize_components(case: Case) -> Case:
         """Applies special serialization rules for case components.

schemathesis/specs/openapi/expressions/__init__.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable
 from schemathesis.generation.stateful.state_machine import StepOutput
 
 from . import lexer, nodes, parser
@@ -25,21 +26,36 @@ def evaluate(expr: Any, output: StepOutput, evaluate_nested: bool = False) -> An
     parts = [node.evaluate(output) for node in parser.parse(expr)]
     if len(parts) == 1:
         return parts[0]  # keep the return type the same as the internal value type
-    # otherwise, concatenate into a string
+    if any(isinstance(part, Unresolvable) for part in parts):
+        return UNRESOLVABLE
     return "".join(str(part) for part in parts if part is not None)
 
 
 def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
     if isinstance(expr, dict):
-        return {
-            _evaluate_object_key(key, output): evaluate(value, output, evaluate_nested=True)
-            for key, value in expr.items()
-        }
-    return [evaluate(item, output, evaluate_nested=True) for item in expr]
+        result_dict = {}
+        for key, value in expr.items():
+            new_key = _evaluate_object_key(key, output)
+            if new_key is UNRESOLVABLE:
+                return new_key
+            new_value = evaluate(value, output, evaluate_nested=True)
+            if new_value is UNRESOLVABLE:
+                return new_value
+            result_dict[new_key] = new_value
+        return result_dict
+    result_list = []
+    for item in expr:
+        new_value = evaluate(item, output, evaluate_nested=True)
+        if new_value is UNRESOLVABLE:
+            return new_value
+        result_list.append(new_value)
+    return result_list
 
 
 def _evaluate_object_key(key: str, output: StepOutput) -> Any:
     evaluated = evaluate(key, output)
+    if evaluated is UNRESOLVABLE:
+        return evaluated
     if isinstance(evaluated, str):
         return evaluated
     if isinstance(evaluated, bool):

schemathesis/specs/openapi/expressions/nodes.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, cast
 
 from requests.structures import CaseInsensitiveDict
 
-from schemathesis.core.transforms import UNRESOLVABLE, resolve_pointer
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable, resolve_pointer
 from schemathesis.generation.stateful.state_machine import StepOutput
 from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         raise NotImplementedError
 
 
@@ -39,7 +39,7 @@ class String(Node):
 
     value: str
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -53,7 +53,7 @@ class String(Node):
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         import requests
 
         base_url = output.case.operation.base_url or "http://127.0.0.1"
@@ -66,7 +66,7 @@ class URL(Node):
 class Method(Node):
     """A node for `$method` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         return output.case.operation.method.upper()
 
 
@@ -74,7 +74,7 @@ class Method(Node):
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         return str(output.response.status_code)
 
 
@@ -86,7 +86,7 @@ class NonBodyRequest(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         container: dict | CaseInsensitiveDict = {
             "query": output.case.query,
             "path": output.case.path_parameters,
@@ -96,9 +96,9 @@ class NonBodyRequest(Node):
             container = CaseInsensitiveDict(container)
         value = container.get(self.parameter)
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value) or ""
+            return self.extractor.extract(value) or UNRESOLVABLE
         return value
 
 
@@ -108,14 +108,11 @@ class BodyRequest(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, output: StepOutput) -> Any:
+    def evaluate(self, output: StepOutput) -> Any | Unresolvable:
         document = output.case.body
         if self.pointer is None:
             return document
-        resolved = resolve_pointer(document, self.pointer[1:])
-        if resolved is UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])
 
 
 @dataclass
@@ -125,12 +122,12 @@ class HeaderResponse(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         value = output.response.headers.get(self.parameter.lower())
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value[0]) or ""
+            return self.extractor.extract(value[0]) or UNRESOLVABLE
         return value[0]
 
 
@@ -145,7 +142,4 @@ class BodyResponse(Node):
         if self.pointer is None:
             # We need the parsed document - data will be serialized before sending to the application
             return document
-        resolved = resolve_pointer(document, self.pointer[1:])
-        if resolved is UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])

schemathesis/specs/openapi/expressions/parser.py

@@ -46,7 +46,7 @@ def _parse_variable(tokens: lexer.TokenGenerator, token: lexer.Token, expr: str)
     elif token.value == nodes.NodeType.RESPONSE.value:
         yield _parse_response(tokens, expr)
     else:
-        raise UnknownToken(token.value)
+        raise UnknownToken(f"Invalid expression `{expr}`. Unknown token: `{token.value}`")
 
 
 def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> nodes.BodyRequest | nodes.NonBodyRequest:

schemathesis/specs/openapi/parameters.py

@@ -376,7 +376,6 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
                 ),
                 path=operation.path,
                 method=operation.method,
-                full_path=operation.full_path,
             )
         return data["schema"]
     # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#fixed-fields-10
@@ -388,7 +387,6 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,
-            full_path=operation.full_path,
         ) from exc
     options = iter(content.values())
     media_type_object = next(options)

schemathesis/specs/openapi/patterns.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import re
 from functools import lru_cache
 
+from schemathesis.core.errors import InternalError
+
 try:  # pragma: no cover
     import re._constants as sre
     import re._parser as sre_parse
@@ -29,7 +31,15 @@ def update_quantifier(pattern: str, min_length: int | None, max_length: int | No
 
     try:
         parsed = sre_parse.parse(pattern)
-        return _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+        updated = _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+        try:
+            re.compile(updated)
+        except re.error as exc:
+            raise InternalError(
+                f"The combination of min_length={min_length} and max_length={max_length} applied to the original pattern '{pattern}' resulted in an invalid regex: '{updated}'. "
+                "This indicates a bug in the regex quantifier merging logic"
+            ) from exc
+        return updated
     except re.error:
         # Invalid pattern
         return pattern
@@ -261,13 +271,18 @@ def _handle_repeat_quantifier(
     min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
     if min_length > max_length:
         return pattern
-    return f"({_strip_quantifier(pattern).strip(')(')})" + _build_quantifier(min_length, max_length)
+    inner = _strip_quantifier(pattern)
+    if inner.startswith("(") and inner.endswith(")"):
+        inner = inner[1:-1]
+    return f"({inner})" + _build_quantifier(min_length, max_length)
 
 
 def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Handle literal or character class quantifiers."""
     min_length = 1 if min_length is None else max(min_length, 1)
-    return f"({pattern.strip(')(')})" + _build_quantifier(min_length, max_length)
+    if pattern.startswith("(") and pattern.endswith(")"):
+        pattern = pattern[1:-1]
+    return f"({pattern})" + _build_quantifier(min_length, max_length)
 
 
 def _build_quantifier(minimum: int | None, maximum: int | None) -> str:
@@ -294,10 +309,12 @@ def _build_size(min_repeat: int, max_repeat: int, min_length: int | None, max_le
 def _strip_quantifier(pattern: str) -> str:
     """Remove quantifier from the pattern."""
     # Lazy & posessive quantifiers
-    if pattern.endswith(("*?", "+?", "??", "*+", "?+", "++")):
-        return pattern[:-2]
-    if pattern.endswith(("?", "*", "+")):
-        pattern = pattern[:-1]
+    for marker in ("*?", "+?", "??", "*+", "?+", "++"):
+        if pattern.endswith(marker) and not pattern.endswith(rf"\{marker}"):
+            return pattern[:-2]
+    for marker in ("?", "*", "+"):
+        if pattern.endswith(marker) and not pattern.endswith(rf"\{marker}"):
+            pattern = pattern[:-1]
     if pattern.endswith("}") and "{" in pattern:
         # Find the start of the exact quantifier and drop everything since that index
         idx = pattern.rfind("{")

schemathesis/specs/openapi/schemas.py

@@ -41,11 +41,12 @@ 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
 
 from ...generation import GenerationConfig, GenerationMode
 from ...hooks import HookContext, HookDispatcher
 from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
-from . import links, serialization
+from . import serialization
 from ._cache import OperationCache
 from ._hypothesis import openapi_cases
 from .converter import to_json_schema, to_json_schema_recursive
@@ -155,7 +156,6 @@ class BaseOpenAPISchema(BaseSchema):
             return True
         if self.filter_set.is_empty():
             return False
-        path = self.get_full_path(path)
         # Attribute assignment is way faster than creating a new namespace every time
         operation = _ctx_cache.operation
         operation.method = method
@@ -365,28 +365,24 @@ class BaseOpenAPISchema(BaseSchema):
     def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[InvalidSchema]:
         __tracebackhide__ = True
         try:
-            full_path = self.get_full_path(path) if isinstance(path, str) else None
-            self._raise_invalid_schema(error, full_path, path, method)
+            self._raise_invalid_schema(error, path, method)
         except InvalidSchema as exc:
             return Err(exc)
 
     def _raise_invalid_schema(
         self,
         error: Exception,
-        full_path: str | None = None,
         path: str | None = None,
         method: str | None = None,
     ) -> NoReturn:
         __tracebackhide__ = True
         if isinstance(error, RefResolutionError):
-            raise InvalidSchema.from_reference_resolution_error(
-                error, path=path, method=method, full_path=full_path
-            ) from None
+            raise InvalidSchema.from_reference_resolution_error(error, path=path, method=method) from None
         try:
             self.validate()
         except jsonschema.ValidationError as exc:
-            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method, full_path=full_path) from None
-        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
+            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method) from None
+        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method) from error
 
     def validate(self) -> None:
         with suppress(TypeError):
@@ -584,8 +580,7 @@ class BaseOpenAPISchema(BaseSchema):
             responses = operation.definition.raw["responses"]
         except KeyError as exc:
             path = operation.path
-            full_path = self.get_full_path(path) if isinstance(path, str) else None
-            self._raise_invalid_schema(exc, full_path, path, operation.method)
+            self._raise_invalid_schema(exc, path, operation.method)
         status_code = str(response.status_code)
         if status_code in responses:
             return self.resolver.resolve_in_scope(responses[status_code], operation.definition.scope)
@@ -654,7 +649,12 @@ class BaseOpenAPISchema(BaseSchema):
     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):
-            result[status_code][link.name] = link
+            if isinstance(link, Ok):
+                name = link.ok().name
+            else:
+                name = link.err().name
+            result[status_code][name] = link
+
         return result
 
     def get_tags(self, operation: APIOperation) -> list[str] | None:

schemathesis/specs/openapi/serialization.py

@@ -3,12 +3,24 @@ from __future__ import annotations
 import json
 from typing import Any, Callable, Dict, Generator, List
 
+from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
 Generated = Dict[str, Any]
 Definition = Dict[str, Any]
 DefinitionList = List[Definition]
 MapFunction = Callable[[Generated], Generated]
 
 
+def get_serializers_for_operation(operation: APIOperation) -> dict[str, Callable]:
+    serializers = {}
+    for location, container in LOCATION_TO_CONTAINER.items():
+        serializer = operation.get_parameter_serializer(location)
+        if serializer is not None:
+            serializers[container] = serializer
+    return serializers
+
+
 def make_serializer(
     func: Callable[[DefinitionList], Generator[Callable | None, None, None]],
 ) -> Callable[[DefinitionList], Callable | None]:
@@ -16,6 +28,8 @@ def make_serializer(
 
     def _wrapper(definitions: DefinitionList) -> Callable | None:
         functions = list(func(definitions))
+        if not functions:
+            return None
 
         def composed(x: Any) -> Any:
             result = x