schemathesis 4.3.10__py3-none-any.whl → 4.3.12__py3-none-any.whl

schemathesis/cli/commands/__init__.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
+import sys
 from dataclasses import dataclass
 from typing import Any
 
 import click
-from tomli import TOMLDecodeError
 
 from schemathesis.cli.commands.data import Data
 from schemathesis.cli.commands.run import run as run_command
@@ -16,6 +16,11 @@ from schemathesis.config import ConfigError, SchemathesisConfig
 from schemathesis.core.errors import HookError, format_exception
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 
+if sys.version_info < (3, 11):
+    from tomli import TOMLDecodeError
+else:
+    from tomllib import TOMLDecodeError
+
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
 

schemathesis/cli/commands/run/loaders.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import os
 import warnings
+from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any, Callable
 
 from schemathesis import graphql, openapi
@@ -35,7 +36,10 @@ def should_try_more(exc: LoaderError) -> bool:
     import requests
     from yaml.reader import ReaderError
 
-    if isinstance(exc.__cause__, ReaderError) and "characters are not allowed" in str(exc.__cause__):
+    if (isinstance(exc.__cause__, ReaderError) and "characters are not allowed" in str(exc.__cause__)) or (
+        isinstance(exc.__cause__, JSONDecodeError)
+        and ('"swagger"' in exc.__cause__.doc or '"openapi"' in exc.__cause__.doc)
+    ):
         return False
 
     # We should not try other loaders for cases when we can't even establish connection

schemathesis/config/__init__.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import os
+import sys
 from dataclasses import dataclass
 from os import PathLike
 from random import Random
 
-import tomli
-
 from schemathesis.config._checks import (
     CheckConfig,
     ChecksConfig,
@@ -29,6 +28,11 @@ from schemathesis.config._phases import (
 from schemathesis.config._projects import ProjectConfig, ProjectsConfig, SchemathesisWarning, get_workers_count
 from schemathesis.config._report import DEFAULT_REPORT_DIRECTORY, ReportConfig, ReportFormat, ReportsConfig
 
+if sys.version_info < (3, 11):
+    import tomli
+else:
+    import tomllib as tomli
+
 __all__ = [
     "SchemathesisConfig",
     "ConfigError",

schemathesis/generation/coverage.py

@@ -9,7 +9,6 @@ from itertools import combinations
 
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
 from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
-from schemathesis.generation.hypothesis.strategies import combine
 
 try:
     from json.encoder import _make_iterencode  # type: ignore[attr-defined]
@@ -81,7 +80,7 @@ STRATEGIES_FOR_TYPE = {
 def get_strategy_for_type(ty: str | list[str]) -> st.SearchStrategy:
     if isinstance(ty, str):
         return STRATEGIES_FOR_TYPE[ty]
-    return combine([STRATEGIES_FOR_TYPE[t] for t in ty if t in STRATEGIES_FOR_TYPE])
+    return st.one_of(STRATEGIES_FOR_TYPE[t] for t in ty if t in STRATEGIES_FOR_TYPE)
 
 
 FORMAT_STRATEGIES = {**BUILT_IN_STRING_FORMATS, **get_default_format_strategies(), **STRING_FORMATS}

schemathesis/generation/hypothesis/builder.py

@@ -35,7 +35,7 @@ from schemathesis.core.transport import prepare_urlencoded
 from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
 from schemathesis.generation import GenerationMode, coverage
 from schemathesis.generation.case import Case
-from schemathesis.generation.hypothesis import examples, setup, strategies
+from schemathesis.generation.hypothesis import examples, setup
 from schemathesis.generation.hypothesis.examples import add_single_example
 from schemathesis.generation.hypothesis.given import GivenInput
 from schemathesis.generation.meta import (
@@ -112,9 +112,7 @@ def create_test(
         **config.as_strategy_kwargs,
     }
     generation = config.project.generation_for(operation=operation)
-    strategy = strategies.combine(
-        [operation.as_strategy(generation_mode=mode, **strategy_kwargs) for mode in generation.modes]
-    )
+    strategy = st.one_of(operation.as_strategy(generation_mode=mode, **strategy_kwargs) for mode in generation.modes)
 
     hypothesis_test = create_base_test(
         test_function=test_func,

schemathesis/generation/stateful/state_machine.py

@@ -37,16 +37,20 @@ class StepInput:
 
     case: Case
     transition: Transition | None  # None for initial steps
-    # Whether this transition was actually applied
+    # What parameters were actually applied
     # Data extraction failures can prevent it, as well as transitions can be skipped in some cases
     # to improve discovery of bugs triggered by non-stateful inputs during stateful testing
-    is_applied: bool
+    applied_parameters: list[str]
 
-    __slots__ = ("case", "transition", "is_applied")
+    __slots__ = ("case", "transition", "applied_parameters")
 
     @classmethod
     def initial(cls, case: Case) -> StepInput:
-        return cls(case=case, transition=None, is_applied=False)
+        return cls(case=case, transition=None, applied_parameters=[])
+
+    @property
+    def is_applied(self) -> bool:
+        return bool(self.applied_parameters)
 
 
 @dataclass
@@ -69,8 +73,9 @@ class ExtractedParam:
 
     definition: Any
     value: Result[Any, Exception]
+    is_required: bool
 
-    __slots__ = ("definition", "value")
+    __slots__ = ("definition", "value", "is_required")
 
 
 @dataclass

schemathesis/openapi/loaders.py

@@ -303,10 +303,11 @@ def _load_yaml(content: str) -> dict[str, Any]:
     try:
         return deserialize_yaml(content)
     except yaml.YAMLError as exc:
-        kind = LoaderErrorKind.SYNTAX_ERROR
-        message = SCHEMA_SYNTAX_ERROR
-        extras = [entry for entry in str(exc).splitlines() if entry]
-        raise LoaderError(kind, message, extras=extras) from exc
+        raise LoaderError(
+            LoaderErrorKind.SYNTAX_ERROR,
+            SCHEMA_SYNTAX_ERROR,
+            extras=[entry for entry in str(exc).splitlines() if entry],
+        ) from exc
 
 
 SCHEMA_INVALID_ERROR = "The provided API schema does not appear to be a valid OpenAPI schema"

schemathesis/schemas.py

@@ -16,6 +16,8 @@ from typing import (
 )
 from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
+from hypothesis import strategies as st
+
 from schemathesis import transport
 from schemathesis.config import ProjectConfig
 from schemathesis.core import NOT_SET, NotSet, media_types
@@ -25,7 +27,6 @@ from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import Response
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
-from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
 from schemathesis.generation.meta import CaseMetadata
 from schemathesis.hooks import HookDispatcherMark, _should_skip_hook
@@ -458,7 +459,7 @@ class BaseSchema(Mapping):
             for operation in self.get_all_operations()
             if isinstance(operation, Ok)
         ]
-        return strategies.combine(_strategies)
+        return st.one_of(_strategies)
 
     def find_operation_by_label(self, label: str) -> APIOperation | None:
         raise NotImplementedError
@@ -500,7 +501,7 @@ class APIOperationMap(Mapping):
         _strategies = [
             operation.as_strategy(generation_mode=generation_mode, **kwargs) for operation in self._data.values()
         ]
-        return strategies.combine(_strategies)
+        return st.one_of(_strategies)
 
 
 P = TypeVar("P", bound=OperationParameter)

schemathesis/specs/openapi/adapter/security.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
     from schemathesis.core.compat import RefResolver
     from schemathesis.specs.openapi.adapter.protocol import SpecificationAdapter
 
-ORIGINAL_SECURITY_TYPE_KEY = "x-original-securuty-type"
+ORIGINAL_SECURITY_TYPE_KEY = "x-original-security-type"
 
 
 @dataclass

schemathesis/specs/openapi/examples.py

@@ -12,7 +12,6 @@ from hypothesis_jsonschema import from_schema
 from schemathesis.config import GenerationConfig
 from schemathesis.core.compat import RefResolutionError, RefResolver
 from schemathesis.core.errors import InfiniteRecursiveReference, UnresolvableReference
-from schemathesis.core.jsonschema import references
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
@@ -216,11 +215,11 @@ def _resolve_bundled(
         if isinstance(reference, str):
             # Check if this reference is already in the current path
             if reference in reference_path:
-                # Try to remove recursive references to avoid infinite recursion
-                remaining_references = references.sanitize(schema)
-                if reference in remaining_references:
-                    cycle = list(reference_path[reference_path.index(reference) :])
-                    raise InfiniteRecursiveReference(reference, cycle)
+                # Real infinite recursive references are caught at the bundling stage.
+                # This recursion happens because of how the example phase generates data - it explores everything,
+                # so it is the easiest way to break such cycles
+                cycle = list(reference_path[reference_path.index(reference) :])
+                raise InfiniteRecursiveReference(reference, cycle)
 
             new_path = reference_path + (reference,)
 
@@ -238,7 +237,11 @@ def _expand_subschemas(
     *, schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
 ) -> Generator[tuple[dict[str, Any] | bool, tuple[str, ...]], None, None]:
     """Expand schema and all its subschemas."""
-    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    try:
+        schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    except InfiniteRecursiveReference:
+        return
+
     yield (schema, current_path)
 
     if isinstance(schema, dict):
@@ -250,13 +253,19 @@ def _expand_subschemas(
                     yield (subschema, current_path)
 
         # For allOf, merge all alternatives
-        if "allOf" in schema:
+        if "allOf" in schema and schema["allOf"]:
             subschema = deepclone(schema["allOf"][0])
-            subschema, _ = _resolve_bundled(subschema, resolver, current_path)
+            try:
+                subschema, expanded_path = _resolve_bundled(subschema, resolver, current_path)
+            except InfiniteRecursiveReference:
+                return
 
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
-                    sub, _ = _resolve_bundled(sub, resolver, current_path)
+                    try:
+                        sub, _ = _resolve_bundled(sub, resolver, current_path)
+                    except InfiniteRecursiveReference:
+                        return
                     for key, value in sub.items():
                         if key == "properties":
                             subschema.setdefault("properties", {}).update(value)
@@ -269,7 +278,7 @@ def _expand_subschemas(
                         else:
                             subschema[key] = value
 
-            yield (subschema, current_path)
+            yield (subschema, expanded_path)
 
 
 def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:
@@ -353,7 +362,10 @@ def extract_from_schema(
 ) -> Generator[Any, None, None]:
     """Extract all examples from a single schema definition."""
     # This implementation supports only `properties` and `items`
-    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    try:
+        schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    except InfiniteRecursiveReference:
+        return
 
     if "properties" in schema:
         variants = {}

schemathesis/specs/openapi/stateful/__init__.py

@@ -8,6 +8,7 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
+from schemathesis.core import NOT_SET
 from schemathesis.core.errors import InvalidStateMachine, InvalidTransition
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Ok
@@ -15,7 +16,6 @@ from schemathesis.core.transforms import UNRESOLVABLE
 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.meta import ComponentInfo, TestPhase
 from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
@@ -50,7 +50,7 @@ class OpenAPIStateMachine(APIStateMachine):
 # The proportion of negative tests generated for "root" transitions
 NEGATIVE_TEST_CASES_THRESHOLD = 10
 # How often some transition is skipped
-USE_TRANSITION_THRESHOLD = 85
+BASE_EXPLORATION_RATE = 0.15
 
 
 @dataclass
@@ -163,6 +163,7 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     for target in operations:
         if target.label in transitions.operations:
             incoming = transitions.operations[target.label].incoming
+            config = schema.config.generation_for(operation=target, phase="stateful")
             if incoming:
                 for link in incoming:
                     bundle_name = f"{link.source.label} -> {link.status_code}"
@@ -170,7 +171,6 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                         f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
                     )
                     assert name not in rules, name
-                    config = schema.config.generation_for(operation=target, phase="stateful")
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
@@ -182,7 +182,6 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                     )
             if target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
                 name = _normalize_name(f"RANDOM -> {target.label}")
-                config = schema.config.generation_for(operation=target, phase="stateful")
                 if len(config.modes) == 1:
                     case_strategy = target.as_strategy(generation_mode=config.modes[0], phase=TestPhase.STATEFUL)
                 else:
@@ -250,50 +249,97 @@ def is_likely_root_transition(operation: APIOperation) -> bool:
 
 
 def into_step_input(
-    target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
+    *, target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
 ) -> Callable[[StepOutput], st.SearchStrategy[StepInput]]:
+    """A single transition between API operations."""
+
     def builder(_output: StepOutput) -> st.SearchStrategy[StepInput]:
         @st.composite  # type: ignore[misc]
         def inner(draw: st.DrawFn, output: StepOutput) -> StepInput:
+            random = draw(st.randoms(use_true_random=True))
+
+            def biased_coin(p: float) -> bool:
+                return random.random() < p
+
+            # Extract transition data from previous operation's output
             transition = link.extract(output)
 
-            kwargs: dict[str, Any] = {
-                container: {
-                    name: extracted.value.ok()
-                    for name, extracted in data.items()
-                    if isinstance(extracted.value, Ok) and extracted.value.ok() not in (None, UNRESOLVABLE)
-                }
-                for container, data in transition.parameters.items()
-            }
+            overrides: dict[str, Any] = {}
+            applied_parameters = []
+            for container, data in transition.parameters.items():
+                overrides[container] = {}
 
-            if (
-                transition.request_body is not None
-                and isinstance(transition.request_body.value, Ok)
-                and transition.request_body.value.ok() is not UNRESOLVABLE
-                and not link.merge_body
-                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
-            ):
-                kwargs["body"] = transition.request_body.value.ok()
+                for name, extracted in data.items():
+                    # Skip if extraction failed or returned unusable value
+                    if not isinstance(extracted.value, Ok) or extracted.value.ok() in (None, UNRESOLVABLE):
+                        continue
 
-            is_applied = bool(kwargs)
+                    param_key = f"{container}.{name}"
 
-            cases = strategies.combine(
-                [target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **kwargs) for mode in modes]
-            )
-            case = draw(cases)
+                    # Calculate exploration rate based on parameter characteristics
+                    exploration_rate = BASE_EXPLORATION_RATE
+
+                    # Path parameters are critical for routing - use link values more often
+                    if container == "path_parameters":
+                        exploration_rate *= 0.5
+
+                    # Required parameters should follow links more often, optional ones explored more
+                    # Path params are always required, so they get both multipliers
+                    if extracted.is_required:
+                        exploration_rate *= 0.5
+                    else:
+                        # Explore optional parameters more to avoid only testing link-provided values
+                        exploration_rate *= 3.0
+
+                    if biased_coin(1 - exploration_rate):
+                        overrides[container][name] = extracted.value.ok()
+                        applied_parameters.append(param_key)
+
+            # Get the extracted body value
             if (
                 transition.request_body is not None
                 and isinstance(transition.request_body.value, Ok)
                 and transition.request_body.value.ok() is not UNRESOLVABLE
-                and link.merge_body
-                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
             ):
-                new = transition.request_body.value.ok()
-                if isinstance(case.body, dict) and isinstance(new, dict):
-                    case.body = {**case.body, **new}
+                request_body = transition.request_body.value.ok()
+            else:
+                request_body = NOT_SET
+
+            # Link suppose to replace the entire extracted body
+            if request_body is not NOT_SET and not link.merge_body and biased_coin(1 - BASE_EXPLORATION_RATE):
+                overrides["body"] = request_body
+                if isinstance(overrides["body"], dict):
+                    applied_parameters.extend(f"body.{field}" for field in overrides["body"])
                 else:
-                    case.body = new
-                is_applied = True
+                    applied_parameters.append("body")
+
+            cases = st.one_of(
+                [target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **overrides) for mode in modes]
+            )
+            case = draw(cases)
+            if request_body is not NOT_SET and link.merge_body:
+                if isinstance(request_body, dict):
+                    selected_fields = {}
+
+                    for field_name, field_value in request_body.items():
+                        if field_value is UNRESOLVABLE:
+                            continue
+
+                        if biased_coin(1 - BASE_EXPLORATION_RATE):
+                            selected_fields[field_name] = field_value
+                            applied_parameters.append(f"body.{field_name}")
+
+                    if selected_fields:
+                        if isinstance(case.body, dict):
+                            case.body = {**case.body, **selected_fields}
+                        else:
+                            # Can't merge into non-dict, replace entirely
+                            case.body = selected_fields
+                elif biased_coin(1 - BASE_EXPLORATION_RATE):
+                    case.body = request_body
+                    applied_parameters.append("body")
+
+                # Re-validate generation mode after merging body
                 if case.meta and case.meta.generation.mode == GenerationMode.NEGATIVE:
                     # It is possible that the new body is now valid and the whole test case could be valid too
                     for alternative in case.operation.body:
@@ -305,7 +351,7 @@ def into_step_input(
                                 )
                                 if all(info.mode == GenerationMode.POSITIVE for info in case.meta.components.values()):
                                     case.meta.generation.mode = GenerationMode.POSITIVE
-            return StepInput(case=case, transition=transition, is_applied=is_applied)
+            return StepInput(case=case, transition=transition, applied_parameters=applied_parameters)
 
         return inner(output=_output)
 

schemathesis/specs/openapi/stateful/dependencies/__init__.py

@@ -10,7 +10,11 @@ from typing import TYPE_CHECKING, Any
 from schemathesis.core import NOT_SET
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.result import Ok
-from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
+from schemathesis.specs.openapi.stateful.dependencies.inputs import (
+    extract_inputs,
+    merge_related_resources,
+    update_input_field_bindings,
+)
 from schemathesis.specs.openapi.stateful.dependencies.models import (
     CanonicalizationCache,
     Cardinality,
@@ -25,6 +29,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     ResourceMap,
 )
 from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
+from schemathesis.specs.openapi.stateful.dependencies.resources import remove_unused_resources
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -88,6 +93,12 @@ def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
     for resource in updated_resources:
         update_input_field_bindings(resource, operations)
 
+    # Merge parameter-inferred resources with schema-defined ones
+    merge_related_resources(operations, resources)
+
+    # Clean up orphaned resources
+    remove_unused_resources(operations, resources)
+
     return DependencyGraph(operations=operations, resources=resources)
 
 

schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -14,6 +14,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     DefinitionSource,
     InputSlot,
     OperationMap,
+    OutputSlot,
     ResourceDefinition,
     ResourceMap,
 )
@@ -39,7 +40,7 @@ def extract_inputs(
     creating placeholder resources if not yet discovered from their schemas.
     """
     known_dependencies = set()
-    for param in operation.path_parameters:
+    for param in operation.iter_parameters():
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
             parameter_location=param.location,
@@ -310,3 +311,118 @@ def update_input_field_bindings(resource_name: str, operations: OperationMap) ->
             )
             if new_field is not None:
                 input_slot.resource_field = new_field
+
+
+def merge_related_resources(operations: OperationMap, resources: ResourceMap) -> None:
+    """Merge parameter-inferred resources with schema-defined resources from related operations."""
+    candidates = find_producer_consumer_candidates(operations)
+
+    for producer_name, consumer_name in candidates:
+        producer = operations[producer_name]
+        consumer = operations[consumer_name]
+
+        # Try to upgrade each input slot
+        for input_slot in consumer.inputs:
+            result = try_merge_input_resource(input_slot, producer.outputs, resources)
+
+            if result is not None:
+                new_resource_name, new_field_name = result
+                # Update input slot to use the better resource definition
+                input_slot.resource = resources[new_resource_name]
+                input_slot.resource_field = new_field_name
+
+
+def try_merge_input_resource(
+    input_slot: InputSlot,
+    producer_outputs: list[OutputSlot],
+    resources: ResourceMap,
+) -> tuple[str, str] | None:
+    """Try to upgrade an input's resource to a producer's resource."""
+    consumer_resource = input_slot.resource
+
+    # Only upgrade parameter-inferred resources (low confidence)
+    if consumer_resource.source != DefinitionSource.PARAMETER_INFERENCE:
+        return None
+
+    # Try each producer output
+    for output in producer_outputs:
+        producer_resource = resources[output.resource.name]
+
+        # Only merge to schema-defined resources (high confidence)
+        if producer_resource.source != DefinitionSource.SCHEMA_WITH_PROPERTIES:
+            continue
+
+        # Try to match the input parameter to producer's fields
+        param_name = input_slot.parameter_name
+        if not isinstance(param_name, str):
+            continue
+
+        for resource_name in (input_slot.resource.name, producer_resource.name):
+            matched_field = naming.find_matching_field(
+                parameter=param_name,
+                resource=resource_name,
+                fields=producer_resource.fields,
+            )
+
+            if matched_field is not None:
+                return (producer_resource.name, matched_field)
+
+    return None
+
+
+def find_producer_consumer_candidates(operations: OperationMap) -> list[tuple[str, str]]:
+    """Find operation pairs that might produce/consume the same resource via REST patterns."""
+    candidates = []
+
+    # Group by base path to reduce comparisons
+    paths: dict[str, list[str]] = {}
+    for name, node in operations.items():
+        base = _extract_base_path(node.path)
+        paths.setdefault(base, []).append(name)
+
+    # Within each path group, find POST/PUT → GET/DELETE/PATCH patterns
+    for names in paths.values():
+        for producer_name in names:
+            producer = operations[producer_name]
+            # Producer must create/update and return data
+            if producer.method not in ("post", "put") or not producer.outputs:
+                continue
+
+            for consumer_name in names:
+                consumer = operations[consumer_name]
+                # Consumer must have path parameters
+                if not consumer.inputs:
+                    continue
+                # Paths must be related (collection + item pattern)
+                if _is_collection_item_pattern(producer.path, consumer.path):
+                    candidates.append((producer_name, consumer_name))
+
+    return candidates
+
+
+def _extract_base_path(path: str) -> str:
+    """Extract collection path: /blog/posts/{id} -> /blog/posts."""
+    parts = [p for p in path.split("/") if not p.startswith("{")]
+    return "/".join(parts).rstrip("/")
+
+
+def _is_collection_item_pattern(collection_path: str, item_path: str) -> bool:
+    """Check if paths follow REST collection/item pattern."""
+    # /blog/posts + /blog/posts/{postId}
+    normalized_collection = collection_path.rstrip("/")
+    normalized_item = item_path.rstrip("/")
+
+    # Must start with collection path
+    if not normalized_item.startswith(normalized_collection + "/"):
+        return False
+
+    # Extract the segment after collection path
+    remainder = normalized_item[len(normalized_collection) + 1 :]
+
+    # Must be a single path parameter: {paramName} with no slashes
+    return (
+        remainder.startswith("{")
+        and remainder.endswith("}")
+        and len(remainder) > 2  # Not empty {}
+        and "/" not in remainder
+    )

schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -13,6 +13,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     CanonicalizationCache,
     Cardinality,
     DefinitionSource,
+    OperationMap,
     ResourceDefinition,
     ResourceMap,
     extend_pointer,
@@ -310,3 +311,18 @@ def _extract_resource_from_schema(
             resources[resource_name] = resource
 
     return resource
+
+
+def remove_unused_resources(operations: OperationMap, resources: ResourceMap) -> None:
+    """Remove resources that aren't referenced by any operation."""
+    # Collect all resource names currently in use
+    used_resources = set()
+    for operation in operations.values():
+        for input_slot in operation.inputs:
+            used_resources.add(input_slot.resource.name)
+        for output_slot in operation.outputs:
+            used_resources.add(output_slot.resource.name)
+
+    unused = set(resources.keys()) - used_resources
+    for resource_name in unused:
+        del resources[resource_name]

schemathesis/specs/openapi/stateful/links.py

@@ -23,8 +23,9 @@ class NormalizedParameter:
     name: str
     expression: str
     container_name: str
+    is_required: bool
 
-    __slots__ = ("location", "name", "expression", "container_name")
+    __slots__ = ("location", "name", "expression", "container_name", "is_required")
 
 
 @dataclass(repr=False)
@@ -131,15 +132,21 @@ class OpenApiLink:
                 except Exception as exc:
                     errors.append(TransitionValidationError(str(exc)))
 
+            is_required = False
             if hasattr(self, "target"):
                 try:
                     container_name = self._get_parameter_container(location, name)
                 except TransitionValidationError as exc:
                     errors.append(exc)
                     continue
+
+                for param in self.target.iter_parameters():
+                    if param.name == name:
+                        is_required = param.is_required
+                        break
             else:
                 continue
-            result.append(NormalizedParameter(location, name, expression, container_name))
+            result.append(NormalizedParameter(location, name, expression, container_name, is_required=is_required))
         return result
 
     def _get_parameter_container(self, location: ParameterLocation | None, name: str) -> str:
@@ -178,7 +185,9 @@ class OpenApiLink:
                 value = Ok(expressions.evaluate(parameter.expression, output))
             except Exception as exc:
                 value = Err(exc)
-            container[parameter.name] = ExtractedParam(definition=parameter.expression, value=value)
+            container[parameter.name] = ExtractedParam(
+                definition=parameter.expression, value=value, is_required=parameter.is_required
+            )
         return extracted
 
     def extract_body(self, output: StepOutput) -> ExtractedParam | None:
@@ -188,7 +197,7 @@ class OpenApiLink:
                 value = Ok(expressions.evaluate(self.body, output, evaluate_nested=True))
             except Exception as exc:
                 value = Err(exc)
-            return ExtractedParam(definition=self.body, value=value)
+            return ExtractedParam(definition=self.body, value=value, is_required=True)
         return None
 
 

{schemathesis-4.3.10.dist-info → schemathesis-4.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.10
+Version: 4.3.12
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md
@@ -46,7 +46,7 @@ Requires-Dist: pyyaml<7.0,>=5.1
 Requires-Dist: requests<3,>=2.22
 Requires-Dist: rich>=13.9.4
 Requires-Dist: starlette-testclient<1,>=0.4.1
-Requires-Dist: tomli>=2.2.1
+Requires-Dist: tomli>=2.2.1; python_version < '3.11'
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: werkzeug<4,>=0.16.0
 Provides-Extra: bench

{schemathesis-4.3.10.dist-info → schemathesis-4.3.12.dist-info}/RECORD

@@ -5,19 +5,19 @@ schemathesis/errors.py,sha256=K3irHIZkrBH2-9LIjlgXlm8RNC41Nffd39ncfwagUvw,1053
 schemathesis/filters.py,sha256=IevPA5A04GfRLLjmkFLZ0CLhjNO3RmpZq_yw6MqjLIA,13515
 schemathesis/hooks.py,sha256=q2wqYNgpMCO8ImSBkbrWDSwN0BSELelqJMgAAgGvv2M,14836
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemathesis/schemas.py,sha256=jq2KSphzfLn63FNROrc3GwukTDt4ih4-RmF0Z4WSpu8,27582
+schemathesis/schemas.py,sha256=Rn4WHRTe1dGVtoHO1c2N7K13THevuWxeAt8wyvMZmy0,27547
 schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=CVcQNHEiX-joAQmyuEVKWPOSxDHsOw_EXXZsEclzLuY,341
 schemathesis/cli/core.py,sha256=ue7YUdVo3YvuzGL4s6i62NL6YqNDeVPBSnQ1znrvG2w,480
-schemathesis/cli/commands/__init__.py,sha256=DNzKEnXu7GjGSVe0244ZErmygUBA3nGSyVY6JP3ixD0,3740
+schemathesis/cli/commands/__init__.py,sha256=cZowfGwoby-2LmOS6ViRXjSTHe--vaTLndIbXbwF188,3833
 schemathesis/cli/commands/data.py,sha256=_ALywjIeCZjuaoDQFy-Kj8RZkEGqXd-Y95O47h8Jszs,171
 schemathesis/cli/commands/run/__init__.py,sha256=_ApiSVh9q-TsJQ_-IiVBNnLCtTCDMTnOLwuJhOvbCp4,18925
 schemathesis/cli/commands/run/context.py,sha256=vej33l5yOhlJ5gLXDwat9WCW_XdhrHNc9pdIQQYddoY,9004
 schemathesis/cli/commands/run/events.py,sha256=ew0TQOc9T2YBZynYWv95k9yfAk8-hGuZDLMxjT8EhvY,1595
 schemathesis/cli/commands/run/executor.py,sha256=_koznTX0DoELPN_1mxr9K_Qg7-9MPXWdld1MFn3YG_Y,5329
 schemathesis/cli/commands/run/filters.py,sha256=pzkNRcf5vLPSsMfnvt711GNzRSBK5iZIFjPA0fiH1N4,1701
-schemathesis/cli/commands/run/loaders.py,sha256=6j0ez7wduAUYbUT28ELKxMf-dYEWr_67m_KIuTSyNGk,4358
+schemathesis/cli/commands/run/loaders.py,sha256=eRgP1ZPfhOfxR7iXQ_CfV9r_8jP1DN4tg2aORuZLmOM,4538
 schemathesis/cli/commands/run/validation.py,sha256=DQaMiBLN2tYT9hONvv8xnyPvNXZH768UlOdUxTd5kZs,9193
 schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
@@ -28,7 +28,7 @@ schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 schemathesis/cli/ext/fs.py,sha256=dHQYBjQozQmuSSfXVp-2KWFK0ESOb_w-lV2SptfMfco,461
 schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
 schemathesis/cli/ext/options.py,sha256=6yYwZNJL__FCEEL7kI3r5MbVmbp3ZeQjm7DrZ6J_h7s,3347
-schemathesis/config/__init__.py,sha256=fXE_NxvAxhyGag0_gC3xJwUrUkxZz4OKANQ1nYuGFQk,6311
+schemathesis/config/__init__.py,sha256=5jckLTurHbe8uEn656_2rVU-xLAUOUDazUwyECXaT90,6391
 schemathesis/config/_auth.py,sha256=83RLVPm97W2thbn-yi01Rt94YwOxLG_a5VoxhEfjUjs,1528
 schemathesis/config/_checks.py,sha256=F0r16eSSiICvoiTUkNNOE2PH73EGd8bikoeZdME_3Yw,10763
 schemathesis/config/_diff_base.py,sha256=U7wuE4480EjP3K16mfC528TP5q7Q5IwAZwZLqRIrS1E,4300
@@ -93,25 +93,24 @@ schemathesis/engine/phases/unit/_executor.py,sha256=YDibV3lkC2UMHLvh1FSmnlaQ-SJS
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=SLMw6zkzmeiZdaIij8_0tjTF70BrMlRSWREaqWii0uM,12508
-schemathesis/generation/coverage.py,sha256=uUUND4zF17hqs9L1VtNz41KtxcW-BB9JDsrNBA-w2-w,60813
+schemathesis/generation/coverage.py,sha256=xQSqeffVlmRGk-MZMcQZwSMhMluO8fS4d9Q7Is-viQ4,60747
 schemathesis/generation/meta.py,sha256=tXhUZBEdpQMn68uMx1SW8Vv59Uf6Wl6yzs-VB9lu_8o,2589
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
-schemathesis/generation/hypothesis/builder.py,sha256=wOCjNAScpiN-wJ4EM0QnJ_5o9nczW0WILFNfIR1qeKQ,38480
+schemathesis/generation/hypothesis/builder.py,sha256=pnPfJIXBYKyju98xiGUvavh5W2xvuO89RO_NOsvdxYQ,38443
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
-schemathesis/generation/hypothesis/strategies.py,sha256=RurE81E06d99YKG48dizy9346ayfNswYTt38zewmGgw,483
 schemathesis/generation/stateful/__init__.py,sha256=s7jiJEnguIj44IsRyMi8afs-8yjIUuBbzW58bH5CHjs,1042
-schemathesis/generation/stateful/state_machine.py,sha256=25kkYImw5byNwuTtt97aNE3kTHAF8rZ-p3ax_bmd3JI,9135
+schemathesis/generation/stateful/state_machine.py,sha256=3whIW5WDL_-IZIeZLB-qlxIr0_DNC6fb6pZ_0U7ifkE,9285
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
 schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
 schemathesis/openapi/checks.py,sha256=nrkkagRqg-HOsDCAMbJqCnHyBZEA2PpRV_AB8lI_I9c,13080
-schemathesis/openapi/loaders.py,sha256=-DSFWcvD_PmekTyy0qZrJ1YYODh9C1KuAJJIytEnS1s,10733
+schemathesis/openapi/loaders.py,sha256=aaCIf6P8R33l6DBNGD_99m_wruYOPR7ecyL5hT6UChg,10710
 schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/openapi/generation/filters.py,sha256=pY9cUZdL_kQK80Z2aylTOqqa12zmaYUlYC5BfYgeQMk,2395
 schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1ZdfQM,88
@@ -133,7 +132,7 @@ schemathesis/specs/openapi/_hypothesis.py,sha256=O8vN-koBjzBVZfpD3pmgIt6ecU4ddAP
 schemathesis/specs/openapi/checks.py,sha256=12ks0V2F8-YKPkItgAc0ZrxsHufWWlsgj-jpj-cF40A,31578
 schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
-schemathesis/specs/openapi/examples.py,sha256=moFFfOfzepjlJOrqLc60BrEmJ4oRzwJ3SM03y_nJNMU,24097
+schemathesis/specs/openapi/examples.py,sha256=uHV1HRqFhwpGNsBWHt7WmehyIyr8d-n-VeKKs4FRt2c,24475
 schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89lzMPbPzw,3975
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
@@ -146,7 +145,7 @@ schemathesis/specs/openapi/adapter/parameters.py,sha256=bVo7sgN5oCH2GVDXlqAMrwN0
 schemathesis/specs/openapi/adapter/protocol.py,sha256=VDF6COcilHEUnmw76YBVur8bFiTFQHsNvaO9pR_i_KM,2709
 schemathesis/specs/openapi/adapter/references.py,sha256=6M59pJy_U_sLh3Xzgu6-izWXtz3bjXnqJYSD65wRHtk,549
 schemathesis/specs/openapi/adapter/responses.py,sha256=UXcYb048SeS0MhydQY518IgYD0s0Q5YpLsBbdX5-5-s,13276
-schemathesis/specs/openapi/adapter/security.py,sha256=W3cqlbs80NxF9SAavOi7BhtNGzdxHO476lYxiWN0D08,4945
+schemathesis/specs/openapi/adapter/security.py,sha256=F3K3_LsdUI61O8C-tUhWd3CyBjlwZ_ujhIoUZqzb90A,4945
 schemathesis/specs/openapi/adapter/v2.py,sha256=2Rd1cTv7_I5QrBPLVfa2yD80NAErxV3tdeACjtEfXAA,1280
 schemathesis/specs/openapi/adapter/v3_0.py,sha256=8bOE9WUDrvPivGs0w-S1PP2TXgWuaoTzMdg2_WWbi-E,1272
 schemathesis/specs/openapi/adapter/v3_1.py,sha256=Hi4iMQdLDAeqSVYjafXbRb5yolWuqMz9A954tE2SCQY,1282
@@ -160,16 +159,16 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=B78vps314fJOMZwlPdv7vUHo7
 schemathesis/specs/openapi/negative/mutations.py,sha256=9U352xJsdZBR-Zfy1V7_X3a5i91LIUS9Zqotrzp3BLA,21000
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
-schemathesis/specs/openapi/stateful/__init__.py,sha256=CQx2WJ3mKn5qmYRc90DqsG9w3Gx7DrB60S9HFz81STY,16663
+schemathesis/specs/openapi/stateful/__init__.py,sha256=T-iYOxPh3GfvKUxrc2f2u_GSeO0HUYajn2qVw2F6sGA,18802
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
 schemathesis/specs/openapi/stateful/inference.py,sha256=B99jSTDVi2yKxU7-raIb91xpacOrr0nZkEZY5Ej3eCY,9783
-schemathesis/specs/openapi/stateful/links.py,sha256=SSA66mU50FFBz7e6sA37CfL-Vt0OY3gont72oFSvZYU,8163
-schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=0JM-FrY6Awv6gl-qDHaaK7pXbt_GKutBKPyIaph8apA,7842
-schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=PSactImp4OqsYMHUl2gB2pgvUlZCCKJRJKeaalclFzU,11511
+schemathesis/specs/openapi/stateful/links.py,sha256=P4CISEi-BVRtXd9cXBnHuvxInxW1LBa7DVYcnaZAhBU,8530
+schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=9FWF7tiP7GaOwapRFIYjsu16LxkosKCzBvzjkSTCsjU,8183
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=sQydINThS6vp9-OnTKCb_unoVP4m3Ho-0xTG0K7ps8Q,15915
 schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=Kl482Hwq2M8lYAdqGmf_8Yje3voSj1WLDUIujRUDWDQ,12286
 schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=NnXEFY1W3i18jEEYGgC_8oLoE7YOxdXgcMYtZvLj10w,12920
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
-schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=p58XoADpMKFAun0Bx_rul-kiUlfA9PXjxHJ97dT2tBE,11202
+schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=MLitJnn1vUihhzuCIA-l7uXG6ne3YTUlnyAAbKaz2Ls,11824
 schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=RaG1BJH4D7-o5Qs2rIRQvS8ERntMUEs2I5jXUFaKMRo,14147
 schemathesis/specs/openapi/types/__init__.py,sha256=VPsWtLJle__Kodw_QqtQ3OuvBzBcCIKsTOrXy3eA7OU,66
 schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzBXqerccLpo,1468
@@ -179,8 +178,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.10.dist-info/METADATA,sha256=BrfLLUJxe-ve_0xCRM77F5ksA27XYwnQaS_tf7pawQM,8541
-schemathesis-4.3.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.10.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.10.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.10.dist-info/RECORD,,
+schemathesis-4.3.12.dist-info/METADATA,sha256=udwQ_n-qA4_1ZwxJDDhMNe6WUrUp4LJ8mnDdbOhapFY,8566
+schemathesis-4.3.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.12.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.12.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.12.dist-info/RECORD,,

schemathesis/generation/hypothesis/strategies.py

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-from functools import reduce
-from operator import or_
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from hypothesis import strategies as st
-
-
-def combine(strategies: list[st.SearchStrategy] | tuple[st.SearchStrategy]) -> st.SearchStrategy:
-    """Combine a list of strategies into a single one.
-
-    If the input is `[a, b, c]`, then the result is equivalent to `a | b | c`.
-    """
-    return reduce(or_, strategies[1:], strategies[0])