py-predicate 1.5__tar.gz → 1.7.0__tar.gz

py_predicate-1.7.0/PKG-INFO

@@ -0,0 +1,253 @@
+Metadata-Version: 2.4
+Name: py_predicate
+Version: 1.7.0
+Summary: Module to create composable predicates
+Author-email: Maurits Rijk <maurits.rijk@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
+Requires-Dist: exrex
+Requires-Dist: graphviz
+Requires-Dist: lark
+Requires-Dist: more-itertools
+Requires-Dist: pyyaml
+Requires-Dist: typer
+Requires-Dist: bumpversion ; extra == "dev"
+Requires-Dist: jsonschema ; extra == "dev"
+Requires-Dist: mutmut ; extra == "dev"
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: mypy ; extra == "test"
+Requires-Dist: mypy_extensions ; extra == "test"
+Requires-Dist: pytest ; extra == "test"
+Requires-Dist: pytest-asyncio ; extra == "test"
+Requires-Dist: pytest-benchmark ; extra == "test"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: ruff ; extra == "test"
+Requires-Dist: types-PyYAML ; extra == "test"
+Project-URL: Documentation, https://mrijk.github.io/py-predicate/
+Project-URL: Source, https://github.com/mrijk/py-predicate
+Provides-Extra: dev
+Provides-Extra: test
+
+![Documentation](https://github.com/mrijk/py-predicate/actions/workflows/pages.yaml/badge.svg)
+![Test](https://github.com/mrijk/py-predicate/actions/workflows/test.yaml/badge.svg)
+[![codecov](https://codecov.io/gh/mrijk/py-predicate/graph/badge.svg?token=KMBDJNC3W9)](https://codecov.io/gh/mrijk/py-predicate)
+
+# py-predicate
+
+A typed Python library for composable predicates.
+
+Predicates are first-class objects that can be combined with boolean operators, optimized algebraically, compiled to native callables for performance, serialized to multiple formats, and used to instrument functions with runtime contracts.
+
+Full documentation: [mrijk.github.io/py-predicate](https://mrijk.github.io/py-predicate/)
+
+## Installation
+
+```bash
+pip install py-predicate
+```
+
+## Quick start
+
+```python
+from predicate import ge_p, le_p
+
+ge_2 = ge_p(2)
+le_5 = le_p(5)
+
+between = ge_2 & le_5
+
+between(3)   # True
+between(7)   # False
+
+filtered = [x for x in range(10) if between(x)]  # [2, 3, 4, 5]
+```
+
+Predicates compose with standard Python operators:
+
+| Operator | Meaning |
+|----------|---------|
+| `p & q`  | both must hold (`AndPredicate`) |
+| `p \| q` | either must hold (`OrPredicate`) |
+| `p ^ q`  | exactly one must hold (`XorPredicate`) |
+| `~p`     | negation (`NotPredicate`) |
+
+## Built-in predicates
+
+**Comparisons:** `eq_p`, `ne_p`, `gt_p`, `ge_p`, `lt_p`, `le_p`, `is_close_p`
+
+**Ranges:** `ge_le_p`, `ge_lt_p`, `gt_le_p`, `gt_lt_p` (compiled to chained comparisons)
+
+**Type checks:** `is_int_p`, `is_str_p`, `is_float_p`, `is_bool_p`, `is_list_p`, `is_dict_p`, `is_none_p`, `is_not_none_p`, `is_instance_p`, and many more
+
+**Collections:** `all_p`, `any_p`, `in_p`, `not_in_p`, `has_length_p`, `is_empty_p`, `is_not_empty_p`, `has_key_p`, `has_path_p`
+
+**Typed collections:** `is_list_of_p`, `is_set_of_p`, `is_dict_of_p`, `is_tuple_of_p`
+
+**Strings:** `regex_p`, `starts_with_p`, `ends_with_p`, `is_alpha_p`, `is_digit_p`, `is_upper_p`, `is_lower_p`, and more
+
+**Logic:** `always_p`, `never_p`, `implies_p`, `fn_p`
+
+**Numeric:** `is_even_p`, `is_odd_p`, `is_nan_p`, `is_inf_p`, `is_finite_p`, `pos_p`, `neg_p`, `zero_p`
+
+## Failure explanation
+
+Use `explain` to get a structured description of why a predicate failed:
+
+```python
+from predicate import explain, ge_p, le_p
+
+between = ge_p(2) & le_p(5)
+explain(between, 8)
+# {'reason': 'Right predicate failed', 'right': {'reason': 'Expected 8 <= 5'}}
+```
+
+## Optimizer
+
+Predicate trees can be algebraically simplified:
+
+```python
+from predicate import ge_p, le_p, optimize, can_optimize
+
+p = ge_p(2) & le_p(5)
+can_optimize(p)   # True (may simplify to a range predicate, etc.)
+optimized = optimize(p)
+```
+
+The optimizer handles identities like `p & always_true == p`, `p | always_true == always_true`, double-negation elimination, De Morgan's laws, and more.
+
+## Compile to native callables
+
+`compile_predicate` translates a predicate tree into a native Python lambda via AST generation, removing interpreter overhead on hot paths:
+
+```python
+from predicate import compile_predicate, ge_p, le_p
+
+between = ge_p(2) & le_p(5)
+fast = compile_predicate(between)  # returns a CompiledPredicate
+
+fast(3)   # True  — evaluated by a native lambda: lambda x: x >= 2 and x <= 5
+fast(8)   # False
+
+# Introspection is preserved
+repr(fast)            # same as repr(between)
+fast.explain_failure  # delegates to the original predicate
+```
+
+Use `try_compile_predicate` to fall back to the original when compilation is not supported (e.g. `fn_p`, `regex_p`):
+
+```python
+from predicate import try_compile_predicate
+
+safe = try_compile_predicate(some_predicate)  # always returns a callable
+```
+
+## Value generation
+
+Predicates can drive property-based testing by generating values that satisfy or violate them:
+
+```python
+from predicate import generate_true, generate_false, ge_p, le_p
+from more_itertools import take
+
+between = ge_p(2) & le_p(5)
+
+take(5, generate_true(between))   # e.g. [2, 3, 4, 5, 2]
+take(5, generate_false(between))  # e.g. [0, 1, 6, 7, -1]
+```
+
+## Recursive predicates
+
+Use `root_p` (or `this_p`) to define self-referencing predicates over arbitrarily nested structures without writing recursive functions:
+
+```python
+from predicate import all_p, is_list_p, is_str_p, root_p
+
+# Matches a string, or a list of strings/lists (recursively)
+str_or_nested = is_str_p | (is_list_p & all_p(root_p))
+
+str_or_nested("hello")            # True
+str_or_nested(["a", ["b", "c"]]) # True
+str_or_nested(["a", 1])          # False
+```
+
+For mutually recursive predicates, use `mutual_recur_p`.
+
+## Runtime instrumentation (Spec)
+
+Instrument functions with predicate-based contracts that are checked at call time:
+
+```python
+from predicate import ge_p, instrument, is_int_p, is_str_p, le_p
+
+@instrument({"args": {"x": is_int_p & ge_p(0) & le_p(100)}, "ret": is_str_p})
+def grade(x: int) -> str:
+    return "pass" if x >= 50 else "fail"
+
+grade(75)   # "pass"
+grade(-1)   # raises ValueError: Parameter predicate for function grade failed
+```
+
+You can also instrument all functions in a module or class:
+
+```python
+from predicate import instrument_module, instrument_class
+
+instrument_module(my_module)
+instrument_class(MyClass)
+```
+
+Specs can include cross-argument constraints via `fn` or `fn_p` keys, and expected exception types via `raises`.
+
+## Analysis
+
+Check logical properties of predicates:
+
+```python
+from predicate import are_equivalent, is_satisfiable, is_tautology, ge_p, le_p, always_p
+
+is_tautology(always_p)               # True
+is_satisfiable(ge_p(5) & le_p(3))   # False (unsatisfiable)
+are_equivalent(~~ge_p(2), ge_p(2))  # True
+```
+
+## Serialization
+
+Export predicates to multiple formats:
+
+```python
+from predicate import ge_p, le_p, to_json, to_yaml, to_dot, to_latex
+
+p = ge_p(2) & le_p(5)
+
+to_json(p)   # JSON string
+to_yaml(p)   # YAML string
+to_dot(p)    # Graphviz DOT for visualization
+to_latex(p)  # LaTeX expression
+```
+
+Deserialize from JSON:
+
+```python
+from predicate.formatter.from_json import from_json
+
+p = from_json('{"and": [{"ge": 2}, {"le": 5}]}')
+```
+

py_predicate-1.7.0/README.md

@@ -0,0 +1,204 @@
+![Documentation](https://github.com/mrijk/py-predicate/actions/workflows/pages.yaml/badge.svg)
+![Test](https://github.com/mrijk/py-predicate/actions/workflows/test.yaml/badge.svg)
+[![codecov](https://codecov.io/gh/mrijk/py-predicate/graph/badge.svg?token=KMBDJNC3W9)](https://codecov.io/gh/mrijk/py-predicate)
+
+# py-predicate
+
+A typed Python library for composable predicates.
+
+Predicates are first-class objects that can be combined with boolean operators, optimized algebraically, compiled to native callables for performance, serialized to multiple formats, and used to instrument functions with runtime contracts.
+
+Full documentation: [mrijk.github.io/py-predicate](https://mrijk.github.io/py-predicate/)
+
+## Installation
+
+```bash
+pip install py-predicate
+```
+
+## Quick start
+
+```python
+from predicate import ge_p, le_p
+
+ge_2 = ge_p(2)
+le_5 = le_p(5)
+
+between = ge_2 & le_5
+
+between(3)   # True
+between(7)   # False
+
+filtered = [x for x in range(10) if between(x)]  # [2, 3, 4, 5]
+```
+
+Predicates compose with standard Python operators:
+
+| Operator | Meaning |
+|----------|---------|
+| `p & q`  | both must hold (`AndPredicate`) |
+| `p \| q` | either must hold (`OrPredicate`) |
+| `p ^ q`  | exactly one must hold (`XorPredicate`) |
+| `~p`     | negation (`NotPredicate`) |
+
+## Built-in predicates
+
+**Comparisons:** `eq_p`, `ne_p`, `gt_p`, `ge_p`, `lt_p`, `le_p`, `is_close_p`
+
+**Ranges:** `ge_le_p`, `ge_lt_p`, `gt_le_p`, `gt_lt_p` (compiled to chained comparisons)
+
+**Type checks:** `is_int_p`, `is_str_p`, `is_float_p`, `is_bool_p`, `is_list_p`, `is_dict_p`, `is_none_p`, `is_not_none_p`, `is_instance_p`, and many more
+
+**Collections:** `all_p`, `any_p`, `in_p`, `not_in_p`, `has_length_p`, `is_empty_p`, `is_not_empty_p`, `has_key_p`, `has_path_p`
+
+**Typed collections:** `is_list_of_p`, `is_set_of_p`, `is_dict_of_p`, `is_tuple_of_p`
+
+**Strings:** `regex_p`, `starts_with_p`, `ends_with_p`, `is_alpha_p`, `is_digit_p`, `is_upper_p`, `is_lower_p`, and more
+
+**Logic:** `always_p`, `never_p`, `implies_p`, `fn_p`
+
+**Numeric:** `is_even_p`, `is_odd_p`, `is_nan_p`, `is_inf_p`, `is_finite_p`, `pos_p`, `neg_p`, `zero_p`
+
+## Failure explanation
+
+Use `explain` to get a structured description of why a predicate failed:
+
+```python
+from predicate import explain, ge_p, le_p
+
+between = ge_p(2) & le_p(5)
+explain(between, 8)
+# {'reason': 'Right predicate failed', 'right': {'reason': 'Expected 8 <= 5'}}
+```
+
+## Optimizer
+
+Predicate trees can be algebraically simplified:
+
+```python
+from predicate import ge_p, le_p, optimize, can_optimize
+
+p = ge_p(2) & le_p(5)
+can_optimize(p)   # True (may simplify to a range predicate, etc.)
+optimized = optimize(p)
+```
+
+The optimizer handles identities like `p & always_true == p`, `p | always_true == always_true`, double-negation elimination, De Morgan's laws, and more.
+
+## Compile to native callables
+
+`compile_predicate` translates a predicate tree into a native Python lambda via AST generation, removing interpreter overhead on hot paths:
+
+```python
+from predicate import compile_predicate, ge_p, le_p
+
+between = ge_p(2) & le_p(5)
+fast = compile_predicate(between)  # returns a CompiledPredicate
+
+fast(3)   # True  — evaluated by a native lambda: lambda x: x >= 2 and x <= 5
+fast(8)   # False
+
+# Introspection is preserved
+repr(fast)            # same as repr(between)
+fast.explain_failure  # delegates to the original predicate
+```
+
+Use `try_compile_predicate` to fall back to the original when compilation is not supported (e.g. `fn_p`, `regex_p`):
+
+```python
+from predicate import try_compile_predicate
+
+safe = try_compile_predicate(some_predicate)  # always returns a callable
+```
+
+## Value generation
+
+Predicates can drive property-based testing by generating values that satisfy or violate them:
+
+```python
+from predicate import generate_true, generate_false, ge_p, le_p
+from more_itertools import take
+
+between = ge_p(2) & le_p(5)
+
+take(5, generate_true(between))   # e.g. [2, 3, 4, 5, 2]
+take(5, generate_false(between))  # e.g. [0, 1, 6, 7, -1]
+```
+
+## Recursive predicates
+
+Use `root_p` (or `this_p`) to define self-referencing predicates over arbitrarily nested structures without writing recursive functions:
+
+```python
+from predicate import all_p, is_list_p, is_str_p, root_p
+
+# Matches a string, or a list of strings/lists (recursively)
+str_or_nested = is_str_p | (is_list_p & all_p(root_p))
+
+str_or_nested("hello")            # True
+str_or_nested(["a", ["b", "c"]]) # True
+str_or_nested(["a", 1])          # False
+```
+
+For mutually recursive predicates, use `mutual_recur_p`.
+
+## Runtime instrumentation (Spec)
+
+Instrument functions with predicate-based contracts that are checked at call time:
+
+```python
+from predicate import ge_p, instrument, is_int_p, is_str_p, le_p
+
+@instrument({"args": {"x": is_int_p & ge_p(0) & le_p(100)}, "ret": is_str_p})
+def grade(x: int) -> str:
+    return "pass" if x >= 50 else "fail"
+
+grade(75)   # "pass"
+grade(-1)   # raises ValueError: Parameter predicate for function grade failed
+```
+
+You can also instrument all functions in a module or class:
+
+```python
+from predicate import instrument_module, instrument_class
+
+instrument_module(my_module)
+instrument_class(MyClass)
+```
+
+Specs can include cross-argument constraints via `fn` or `fn_p` keys, and expected exception types via `raises`.
+
+## Analysis
+
+Check logical properties of predicates:
+
+```python
+from predicate import are_equivalent, is_satisfiable, is_tautology, ge_p, le_p, always_p
+
+is_tautology(always_p)               # True
+is_satisfiable(ge_p(5) & le_p(3))   # False (unsatisfiable)
+are_equivalent(~~ge_p(2), ge_p(2))  # True
+```
+
+## Serialization
+
+Export predicates to multiple formats:
+
+```python
+from predicate import ge_p, le_p, to_json, to_yaml, to_dot, to_latex
+
+p = ge_p(2) & le_p(5)
+
+to_json(p)   # JSON string
+to_yaml(p)   # YAML string
+to_dot(p)    # Graphviz DOT for visualization
+to_latex(p)  # LaTeX expression
+```
+
+Deserialize from JSON:
+
+```python
+from predicate.formatter.from_json import from_json
+
+p = from_json('{"and": [{"ge": 2}, {"le": 5}]}')
+```

{py_predicate-1.5 → py_predicate-1.7.0}/predicate/__init__.py

@@ -1,20 +1,22 @@
 """The py-predicate module."""
 
-__version__ = "0.0.1"
+__version__ = "1.6.0"
 
 from predicate.all_predicate import all_p
 from predicate.always_false_predicate import always_false_p, never_p
 from predicate.always_true_predicate import always_p, always_true_p
+from predicate.analysis import are_equivalent, is_satisfiable, is_tautology
 from predicate.any_predicate import any_p
 from predicate.comp_predicate import comp_p
 from predicate.count_predicate import count_p, exactly_one_p, exactly_zero_p
 from predicate.dict_of_predicate import is_dict_of_p
 from predicate.eq_predicate import eq_false_p, eq_p, eq_true_p, zero_p
 from predicate.exactly_predicate import exactly_n
-from predicate.exception_predicate import PredicateError, exception_p
+from predicate.exception_predicate import exception_p
+from predicate.compile_predicate import compile_predicate, try_compile_predicate
 from predicate.explain import explain
 from predicate.fn_predicate import fn_p, is_even_p, is_finite_p, is_inf_p, is_nan_p, is_odd_p
-from predicate.formatter import to_dot, to_json, to_latex
+from predicate.formatter import to_dot, to_json, to_latex, to_yaml
 from predicate.ge_predicate import ge_p
 from predicate.generator.generate_false import generate_false
 from predicate.generator.generate_true import generate_true
@@ -24,6 +26,8 @@ from predicate.has_length_predicate import has_length_p, is_empty_p, is_not_empt
 from predicate.has_path_predicate import has_path_p
 from predicate.implies_predicate import implies_p
 from predicate.in_predicate import in_p
+from predicate.is_async_predicate import is_async_p
+from predicate.is_close_predicate import is_close_p
 from predicate.is_falsy_predicate import is_falsy_p
 from predicate.is_instance_predicate import (
     is_bool_p,
@@ -69,6 +73,7 @@ from predicate.optimizer.predicate_optimizer import can_optimize, optimize
 from predicate.optional_predicate import optional
 from predicate.plus_predicate import plus
 from predicate.predicate import and_p, or_p, xor_p
+from predicate.raises_predicate import raises_exception_p, raises_p
 from predicate.range_predicate import ge_le_p, ge_lt_p, gt_le_p, gt_lt_p
 from predicate.recur_predicate import recur_p
 from predicate.reduce_predicate import reduce_p
@@ -76,14 +81,20 @@ from predicate.regex_predicate import regex_p
 from predicate.repeat_predicate import repeat
 from predicate.set_of_predicate import is_set_of_p
 from predicate.set_predicates import (
+    intersects_p,
     is_real_subset_p,
     is_real_superset_p,
     is_subset_p,
     is_superset_p,
 )
 from predicate.spec.exercise import exercise
-from predicate.spec.instrument import instrument_function
-from predicate.spec.spec import Spec
+from predicate.spec.instrument import (
+    instrument,
+    instrument_class,
+    instrument_function,
+    instrument_module,
+    is_instrumented,
+)
 from predicate.standard_predicates import (
     is_dict_p,
     is_float_p,
@@ -96,12 +107,14 @@ from predicate.standard_predicates import (
     this_p,
 )
 from predicate.star_predicate import star
+from predicate.struct_predicate import is_struct_p
 from predicate.tee_predicate import tee_p
 from predicate.tuple_of_predicate import is_tuple_of_p
 
 __all__ = [
-    "PredicateError",
-    "Spec",
+    "are_equivalent",
+    "is_satisfiable",
+    "is_tautology",
     "all_p",
     "always_false_p",
     "always_p",
@@ -109,10 +122,12 @@ __all__ = [
     "and_p",
     "any_p",
     "can_optimize",
+    "compile_predicate",
     "comp_p",
     "count_p",
     "eq_false_p",
     "eq_p",
+    "ends_with_p",
     "eq_true_p",
     "exactly_n",
     "exactly_one_p",
@@ -134,18 +149,26 @@ __all__ = [
     "has_path_p",
     "implies_p",
     "in_p",
+    "intersects_p",
+    "instrument",
+    "instrument_class",
     "instrument_function",
+    "instrument_module",
+    "is_instrumented",
     "is_alnum_p",
     "is_alpha_p",
     "is_ascii_p",
+    "is_async_p",
     "is_bool_p",
     "is_bytes_p",
     "is_callable_p",
+    "is_close_p",
     "is_complex_p",
     "is_container_p",
     "is_date_p",
     "is_datetime_p",
     "is_decimal_p",
+    "is_digit_p",
     "is_dict_of_p",
     "is_dict_p",
     "is_frozenset_p",
@@ -174,20 +197,24 @@ __all__ = [
     "is_none_p",
     "is_not_empty_p",
     "is_not_none_p",
+    "is_numeric_p",
     "is_number_p",
     "is_odd_p",
     "is_p",
     "is_path_p",
     "is_predicate_of_p",
     "is_predicate_p",
+    "is_printable_p",
     "is_range_p",
     "is_real_subset_p",
     "is_real_superset_p",
     "is_sequence_p",
     "is_set_of_p",
     "is_set_p",
+    "is_space_p",
     "is_str_enum_p",
     "is_str_p",
+    "is_struct_p",
     "is_subclass_p",
     "is_subset_p",
     "is_superset_p",
@@ -219,26 +246,37 @@ __all__ = [
     "pos_p",
     "recur_p",
     "reduce_p",
+    "raises_exception_p",
+    "raises_p",
     "regex_p",
     "repeat",
     "root_p",
     "star",
+    "starts_with_p",
     "tee_p",
     "this_p",
+    "try_compile_predicate",
     "to_dot",
     "to_json",
     "to_latex",
+    "to_yaml",
     "xor_p",
     "zero_p",
 ]
 
 from predicate.str_predicates import (
+    ends_with_p,
     is_alnum_p,
     is_alpha_p,
     is_ascii_p,
     is_decimal_p,
+    is_digit_p,
     is_identifier_p,
     is_lower_p,
+    is_numeric_p,
+    is_printable_p,
+    is_space_p,
     is_title_p,
     is_upper_p,
+    starts_with_p,
 )

{py_predicate-1.5 → py_predicate-1.7.0}/predicate/all_predicate.py

@@ -2,9 +2,8 @@ from dataclasses import dataclass
 from itertools import takewhile
 from typing import Any, Iterable, Iterator, override
 
-from more_itertools import ilen
+from more_itertools import first, ilen
 
-from predicate.helpers import first_false
 from predicate.predicate import Predicate, resolve_predicate
 
 
@@ -34,9 +33,8 @@ class AllPredicate[T](Predicate[T]):
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
-        fail = first_false(iterable, self.predicate)
-
-        return {"reason": f"Item '{fail}' didn't match predicate {self.predicate!r}"}
+        index, item = first((i, x) for i, x in enumerate(iterable) if not self.predicate(x))
+        return {"index": index, "value": item} | self.predicate.explain_failure(item)
 
     @override
     def consumes(self, iterable: Iterable[Any]) -> Iterator[int]:

py_predicate-1.7.0/predicate/analysis.py

@@ -0,0 +1,22 @@
+from predicate.predicate import Predicate
+
+
+def is_tautology(predicate: Predicate) -> bool:
+    """Return True if the predicate is True for all possible inputs."""
+    from predicate.always_true_predicate import AlwaysTruePredicate
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    return isinstance(optimize(predicate), AlwaysTruePredicate)
+
+
+def is_satisfiable(predicate: Predicate) -> bool:
+    """Return True if the predicate can be True for at least one input."""
+    from predicate.always_false_predicate import AlwaysFalsePredicate
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    return not isinstance(optimize(predicate), AlwaysFalsePredicate)
+
+
+def are_equivalent(p: Predicate, q: Predicate) -> bool:
+    """Return True if both predicates accept exactly the same values."""
+    return is_tautology(~(p ^ q))

{py_predicate-1.5 → py_predicate-1.7.0}/predicate/any_predicate.py

@@ -33,7 +33,11 @@ class AnyPredicate[T](Predicate[T]):
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
-        return {"reason": f"No item matches predicate {self.predicate!r}"}
+        failures = [
+            {"index": index, "value": item} | self.predicate.explain_failure(item)
+            for index, item in enumerate(iterable)
+        ]
+        return {"failures": failures}
 
     @override
     def consumes(self, iterable: Iterable[Any]) -> Iterator[int]: