py-predicate 0.7__tar.gz → 0.8__tar.gz

{py_predicate-0.7 → py_predicate-0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.7
+Version: 0.8
 Summary: Module to create composable predicates
 Author-email: Maurits Rijk <maurits.rijk@gmail.com>
 Requires-Python: >=3.10

{py_predicate-0.7 → py_predicate-0.8}/predicate/__init__.py

@@ -56,6 +56,7 @@ from predicate.standard_predicates import (
     is_nan_p,
     is_none_p,
     is_not_none_p,
+    is_predicate_of_p,
     is_predicate_p,
     is_range_p,
     is_set_of_p,
@@ -133,6 +134,7 @@ __all__ = [
     "is_none_p",
     "is_not_empty_p",
     "is_not_none_p",
+    "is_predicate_of_p",
     "is_predicate_p",
     "is_range_p",
     "is_set_of_p",

{py_predicate-0.7 → py_predicate-0.8}/predicate/all_predicate.py

@@ -18,10 +18,14 @@ class AllPredicate[T](Predicate[T]):
         return predicate in self.predicate
 
     def __repr__(self) -> str:
-        return f"all({repr(self.predicate)})"
+        return f"all_p({self.predicate!r})"
+
+    @override
+    def get_klass(self) -> type:
+        return Predicate[self.predicate.klass]  # type: ignore[name-defined]
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
         fail = first_false(iterable, self.predicate)
 
-        return {"reason": f"Item '{fail}' didn't match predicate {repr(self.predicate)}"}
+        return {"reason": f"Item '{fail}' didn't match predicate {self.predicate!r}"}

{py_predicate-0.7 → py_predicate-0.8}/predicate/always_false_predicate.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Final, override
+from typing import Any, Final, override
 
 from predicate.predicate import Predicate
 
@@ -18,6 +18,10 @@ class AlwaysFalsePredicate(Predicate):
     def explain_failure(self, *args, **kwargs) -> dict:
         return {"reason": "Always returns False"}
 
+    @override
+    def get_klass(self) -> type:
+        return type(Any)
+
 
 always_false_p: Final[AlwaysFalsePredicate] = AlwaysFalsePredicate()
 """Predicate that always evaluates to False."""

{py_predicate-0.7 → py_predicate-0.8}/predicate/always_true_predicate.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Final
+from typing import Any, Final, override
 
 from predicate.predicate import Predicate
 
@@ -14,6 +14,10 @@ class AlwaysTruePredicate(Predicate):
     def __repr__(self) -> str:
         return "always_true_p"
 
+    @override
+    def get_klass(self) -> type:
+        return type(Any)
+
 
 always_true_p: Final[AlwaysTruePredicate] = AlwaysTruePredicate()
 """Predicate that always evaluates to True."""

{py_predicate-0.7 → py_predicate-0.8}/predicate/any_predicate.py

@@ -17,8 +17,12 @@ class AnyPredicate[T](Predicate[T]):
         return predicate in self.predicate
 
     def __repr__(self) -> str:
-        return f"any({repr(self.predicate)})"
+        return f"any_p({self.predicate!r})"
+
+    @override
+    def get_klass(self) -> type:
+        return Predicate[self.predicate.klass]  # type: ignore[name-defined]
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
-        return {"reason": f"No item matches predicate {repr(self.predicate)}"}
+        return {"reason": f"No item matches predicate {self.predicate!r}"}

py_predicate-0.8/predicate/constructor/construct.py

@@ -0,0 +1,84 @@
+from typing import Iterator
+
+from more_itertools import first, gray_product, take
+
+from predicate import (
+    always_false_p,
+    always_true_p,
+    is_datetime_p,
+    is_falsy_p,
+    is_float_p,
+    is_int_p,
+    is_not_none_p,
+    is_set_p,
+    is_str_p,
+    is_truthy_p,
+)
+from predicate.constructor.helpers import perfect_match, sort_by_match
+from predicate.constructor.mutate import mutations
+from predicate.predicate import Predicate
+from predicate.standard_predicates import (
+    ge_p,
+    gt_p,
+    is_bool_p,
+    is_dict_p,
+    is_list_p,
+    is_none_p,
+    le_p,
+    lt_p,
+    ne_p,
+    zero_p,
+)
+
+
+def construct(false_set: list, true_set: list, attempts: int = 30) -> Predicate | None:
+    predicates = initial_predicates()
+
+    while attempts:
+        sorted_by_match = sort_by_match(list(predicates), false_set=false_set, true_set=true_set)
+
+        if perfect_match(matched := first(sorted_by_match), false_set=false_set, true_set=true_set):
+            return matched
+
+        predicates = create_mutations(take(20, sorted_by_match), false_set=false_set, true_set=true_set)
+
+        attempts -= 1
+
+    return None
+
+
+def create_mutations(candidates: list[Predicate], false_set: list, true_set: list) -> Iterator[Predicate]:
+    for candidate in candidates:
+        yield from mutations(candidate, false_set=false_set, true_set=true_set)
+
+    pairs = gray_product(candidates, candidates)
+    for pair in pairs:
+        left, right = pair
+        if left != right:
+            yield left | right
+            yield left & right
+            yield left ^ right
+
+
+def initial_predicates() -> Iterator[Predicate]:
+    # TODO: probably import from __init__
+    yield always_false_p
+    yield always_true_p
+    yield ge_p(0)
+    yield gt_p(0)
+    yield is_bool_p
+    yield is_datetime_p
+    yield is_dict_p
+    yield is_falsy_p
+    yield is_float_p
+    yield is_int_p
+    yield is_list_p
+    yield is_none_p
+    yield is_not_none_p
+    yield is_set_p
+    yield is_str_p
+    yield is_truthy_p
+    yield le_p(0)
+    yield lt_p(0)
+    yield ne_p(0)
+    yield zero_p

py_predicate-0.8/predicate/constructor/helpers.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from predicate.predicate import Predicate
+
+
+def safe_call_false(predicate: Predicate, value: Any) -> bool:
+    # For performance reasons type checking is not part of the predicate itself
+    try:
+        return predicate(value)
+    except TypeError:
+        return True
+
+
+def safe_call_true(predicate: Predicate, value: Any) -> bool:
+    # For performance reasons type checking is not part of the predicate itself
+    try:
+        return predicate(value)
+    except TypeError:
+        return False
+
+
+def predicate_match(predicate: Predicate, false_set: list, true_set: list) -> dict[str, int]:
+    false_misses = sum(safe_call_false(predicate, value) for value in false_set)
+    false_matches = len(false_set) - false_misses
+
+    true_matches = sum(safe_call_true(predicate, value) for value in true_set)
+    true_misses = len(true_set) - true_matches
+
+    return {
+        "false_matches": false_matches,
+        "false_misses": false_misses,
+        "true_matches": true_matches,
+        "true_misses": true_misses,
+    }
+
+
+def sort_by_match(predicates: list[Predicate], false_set: list, true_set: list) -> list[Predicate]:
+    def best_match(predicate) -> int:
+        match = predicate_match(predicate, false_set=false_set, true_set=true_set)
+
+        return match["false_matches"] + match["true_matches"]
+
+    return sorted(predicates, key=best_match, reverse=True)
+
+
+def perfect_match(predicate: Predicate, false_set: list, true_set: list) -> bool:
+    match = predicate_match(predicate, false_set=false_set, true_set=true_set)
+    return match["false_misses"] + match["true_misses"] == 0

py_predicate-0.8/predicate/constructor/mutate.py

@@ -0,0 +1,78 @@
+from collections.abc import Iterator
+from functools import singledispatch
+from random import choice, randint
+
+from predicate import eq_p, ge_p, gt_p, le_p, lt_p, ne_p
+from predicate.eq_predicate import EqPredicate
+from predicate.ge_predicate import GePredicate
+from predicate.gt_predicate import GtPredicate
+from predicate.le_predicate import LePredicate
+from predicate.lt_predicate import LtPredicate
+from predicate.ne_predicate import NePredicate
+from predicate.predicate import Predicate
+
+
+@singledispatch
+def mutations(predicate: Predicate, false_set: list, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    """Return nr of mutations."""
+    yield predicate
+
+
+def int_value_mutations(n: int, values: list, nr: int) -> Iterator[int]:
+    yield choice(values)
+    yield n - randint(0, 10)
+    yield n + randint(0, 10)
+
+
+@mutations.register
+def _(predicate: EqPredicate, false_set: list, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (eq_p(v) for v in int_value_mutations(n, true_set, nr))
+        case _:
+            pass
+
+
+@mutations.register
+def _(predicate: NePredicate, false_set, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (ne_p(v) for v in int_value_mutations(n, false_set, nr))
+        case _:
+            pass
+
+
+@mutations.register
+def _(predicate: GePredicate, false_set, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (ge_p(v) for v in int_value_mutations(n, true_set, nr))
+        case _:
+            pass
+
+
+@mutations.register
+def _(predicate: GtPredicate, false_set, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (gt_p(v) for v in int_value_mutations(n, true_set, nr))
+        case _:
+            pass
+
+
+@mutations.register
+def _(predicate: LePredicate, false_set, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (le_p(v) for v in int_value_mutations(n, true_set, nr))
+        case _:
+            pass
+
+
+@mutations.register
+def _(predicate: LtPredicate, false_set, true_set: list, nr: int = 3) -> Iterator[Predicate]:
+    match predicate.v:
+        case int(n):
+            yield from (lt_p(v) for v in int_value_mutations(n, true_set, nr))
+        case _:
+            pass

{py_predicate-0.7 → py_predicate-0.8}/predicate/eq_predicate.py

@@ -14,8 +14,12 @@ class EqPredicate[T](Predicate[T]):
         return x == self.v
 
     def __repr__(self) -> str:
-        return f"eq_p({self.v})"
+        return f"eq_p({self.v!r})"
+
+    @override
+    def get_klass(self) -> type:
+        return type(self.v)
 
     @override
     def explain_failure(self, x: T) -> dict:
-        return {"reason": f"{x} is not equal to {self.v}"}
+        return {"reason": f"{x} is not equal to {self.v!r}"}

{py_predicate-0.7 → py_predicate-0.8}/predicate/ge_predicate.py

@@ -14,8 +14,12 @@ class GePredicate[T](Predicate[T]):
         return x >= self.v
 
     def __repr__(self) -> str:
-        return f"ge_p({self.v})"
+        return f"ge_p({self.v!r})"
+
+    @override
+    def get_klass(self) -> type:
+        return type(self.v)
 
     @override
     def explain_failure(self, x: T) -> dict:
-        return {"reason": f"{x} is not greater or equal to {self.v}"}
+        return {"reason": f"{x} is not greater or equal to {self.v!r}"}

{py_predicate-0.7 → py_predicate-0.8}/predicate/generator/generate_false.py

@@ -331,9 +331,18 @@ def generate_is_instance_p(predicate: IsInstancePredicate) -> Iterator:
 
 @generate_false.register
 def generate_or(predicate: OrPredicate) -> Iterator:
-    iterable_1 = (item for item in generate_false(predicate.left) if not predicate.right(item))
-    iterable_2 = (item for item in generate_false(predicate.right) if not predicate.left(item))
-    yield from random_first_from_iterables(iterable_1, iterable_2)
+    attempts = 100
+
+    try_left = (item for item in take(attempts, generate_false(predicate.left)) if not predicate.right(item))
+    try_right = (item for item in take(attempts, generate_false(predicate.right)) if not predicate.left(item))
+
+    range_1 = (item for item in generate_false(predicate.left) if not predicate.right(item)) if try_left else ()
+    range_2 = (item for item in generate_false(predicate.right) if not predicate.left(item)) if try_right else ()
+
+    if range_1 or range_2:
+        yield from random_first_from_iterables(range_1, range_2)
+
+    raise ValueError(f"Couldn't generate values that statisfy {predicate}")
 
 
 @generate_false.register

py_predicate-0.8/predicate/generator/generate_predicate.py

@@ -0,0 +1,164 @@
+from typing import Any, Iterator
+
+from predicate.all_predicate import AllPredicate
+from predicate.eq_predicate import EqPredicate
+from predicate.ge_predicate import GePredicate
+from predicate.gt_predicate import GtPredicate
+from predicate.le_predicate import LePredicate
+from predicate.lt_predicate import LtPredicate
+from predicate.ne_predicate import NePredicate
+from predicate.predicate import AndPredicate, NotPredicate, OrPredicate, Predicate, XorPredicate
+from predicate.range_predicate import GeLePredicate, GeLtPredicate, GtLePredicate, GtLtPredicate
+from predicate.set_predicates import InPredicate, NotInPredicate
+
+
+def generate_predicate(predicate_type: type[Predicate], max_depth: int, klass: type) -> Iterator[Predicate]:
+    predicate_type_registry: dict[type, Any] = {
+        # TODO: AllPredicate works on iterables
+        # AllPredicate: generate_all_predicates,
+        AndPredicate: generate_and_predicates,
+        EqPredicate: generate_eq_predicates,
+        GeLePredicate: generate_ge_le_predicates,
+        GeLtPredicate: generate_ge_lt_predicates,
+        GePredicate: generate_ge_predicates,
+        GtPredicate: generate_gt_predicates,
+        GtLePredicate: generate_gt_le_predicates,
+        GtLtPredicate: generate_gt_lt_predicates,
+        InPredicate: generate_in_predicates,
+        LePredicate: generate_le_predicates,
+        LtPredicate: generate_lt_predicates,
+        NePredicate: generate_ne_predicates,
+        NotInPredicate: generate_not_in_predicates,
+        NotPredicate: generate_not_predicates,
+        OrPredicate: generate_or_predicates,
+        XorPredicate: generate_xor_predicates,
+    }
+
+    if generator := predicate_type_registry.get(predicate_type):
+        yield from generator(max_depth=max_depth, klass=klass)
+    else:
+        yield from []
+        # raise ValueError(f"No generator defined for predicate type {predicate_type}")
+
+
+def generate_random_predicate_pairs(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_predicates
+
+    left_predicates = random_predicates(max_depth=max_depth - 1, klass=klass)
+    right_predicates = random_predicates(max_depth=max_depth - 1, klass=klass)
+
+    return zip(left_predicates, right_predicates, strict=False)
+
+
+def generate_all_predicates(max_depth: int, klass: type) -> Iterator:
+    if not max_depth:
+        return
+
+    from predicate.generator.helpers import random_predicates
+
+    predicates = random_predicates(max_depth=max_depth - 1, klass=klass)
+
+    yield from (AllPredicate(predicate) for predicate in predicates)
+
+
+def generate_and_predicates(max_depth: int, klass: type) -> Iterator:
+    if not max_depth:
+        return
+
+    yield from (left & right for left, right in generate_random_predicate_pairs(max_depth=max_depth, klass=klass))
+
+
+def generate_eq_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_values_of_type
+
+    yield from (EqPredicate(value) for value in random_values_of_type(klass))
+
+
+def generate_ge_le_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_pairs_of_type
+
+    yield from (GeLePredicate(lower=lower, upper=upper) for lower, upper in random_constrained_pairs_of_type(klass))
+
+
+def generate_ge_lt_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_pairs_of_type
+
+    yield from (GeLtPredicate(lower=lower, upper=upper) for lower, upper in random_constrained_pairs_of_type(klass))
+
+
+def generate_gt_le_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_pairs_of_type
+
+    yield from (GtLePredicate(lower=lower, upper=upper) for lower, upper in random_constrained_pairs_of_type(klass))
+
+
+def generate_gt_lt_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_pairs_of_type
+
+    yield from (GtLtPredicate(lower=lower, upper=upper) for lower, upper in random_constrained_pairs_of_type(klass))
+
+
+def generate_ge_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_values_of_type
+
+    yield from (GePredicate(value) for value in random_constrained_values_of_type(klass))
+
+
+def generate_gt_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_values_of_type
+
+    yield from (GtPredicate(value) for value in random_constrained_values_of_type(klass))
+
+
+def generate_in_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_iterables
+
+    yield from (InPredicate(iterable) for iterable in random_iterables(klass=klass))
+
+
+def generate_not_in_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_iterables
+
+    yield from (NotInPredicate(iterable) for iterable in random_iterables(klass=klass))
+
+
+def generate_le_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_values_of_type
+
+    yield from (LePredicate(value) for value in random_constrained_values_of_type(klass))
+
+
+def generate_lt_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_constrained_values_of_type
+
+    yield from (LtPredicate(value) for value in random_constrained_values_of_type(klass))
+
+
+def generate_ne_predicates(max_depth: int, klass: type) -> Iterator:
+    from predicate.generator.helpers import random_values_of_type
+
+    yield from (NePredicate(value) for value in random_values_of_type(klass))
+
+
+def generate_not_predicates(max_depth: int, klass: type) -> Iterator:
+    if not max_depth:
+        return
+
+    from predicate.generator.helpers import random_predicates
+
+    predicates = random_predicates(max_depth=max_depth - 1, klass=klass)
+    yield from (~predicate for predicate in predicates)
+
+
+def generate_or_predicates(max_depth: int, klass: type) -> Iterator:
+    if not max_depth:
+        return
+
+    yield from (left | right for left, right in generate_random_predicate_pairs(max_depth=max_depth, klass=klass))
+
+
+def generate_xor_predicates(max_depth: int, klass: type) -> Iterator:
+    if not max_depth:
+        return
+
+    yield from (left ^ right for left, right in generate_random_predicate_pairs(max_depth=max_depth, klass=klass))

{py_predicate-0.7 → py_predicate-0.8}/predicate/generator/generate_true.py

@@ -56,6 +56,7 @@ from predicate.is_falsy_predicate import IsFalsyPredicate
 from predicate.is_instance_predicate import IsInstancePredicate
 from predicate.is_none_predicate import IsNonePredicate
 from predicate.is_not_none_predicate import IsNotNonePredicate
+from predicate.is_predicate_of_p import IsPredicateOfPredicate
 from predicate.is_truthy_predicate import IsTruthyPredicate
 from predicate.le_predicate import LePredicate
 from predicate.list_of_predicate import ListOfPredicate
@@ -119,9 +120,7 @@ def generate_any_p(any_predicate: AnyPredicate, *, min_size: int = 1, max_size:
         combined_values = false_values + true_values
 
         yield random_permutation(combined_values)
-        yield from set_from_list(
-            combined_values,
-        )
+        yield from set_from_list(combined_values)
 
 
 @generate_true.register
@@ -219,6 +218,7 @@ def generate_ge(predicate: GePredicate) -> Iterator:
         case int():
             yield from random_ints(lower=predicate.v)
         case str():
+            yield v
             yield from generate_strings(predicate)
         case UUID():
             yield from generate_uuids(predicate)
@@ -318,7 +318,7 @@ def generate_lt(predicate: LtPredicate) -> Iterator:
 
 @generate_true.register
 def generate_ne(predicate: NePredicate) -> Iterator:
-    yield not predicate.v
+    yield from generate_anys(predicate)
 
 
 @generate_true.register
@@ -374,8 +374,13 @@ def generate_truthy(_predicate: IsTruthyPredicate) -> Iterator:
 
 
 @generate_true.register
-def generate_is_instance_p(predicate: IsInstancePredicate) -> Iterator:
-    klass = predicate.klass[0]  # type: ignore
+def generate_predicate_of(predicate: IsPredicateOfPredicate, **kwargs) -> Iterator:
+    yield from random_predicates(**kwargs, klass=predicate.predicate_klass)
+
+
+@generate_true.register
+def generate_is_instance_p(predicate: IsInstancePredicate, **kwargs) -> Iterator:
+    klass = predicate.instance_klass[0]  # type: ignore
 
     type_registry: dict[Any, Callable[[], Iterator]] = {
         Callable: random_callables,
@@ -396,9 +401,11 @@ def generate_is_instance_p(predicate: IsInstancePredicate) -> Iterator:
     }
 
     if generator := type_registry.get(klass):
-        yield from generator()
-
-    raise ValueError(f"No generator found for {klass}")
+        yield from generator(**kwargs)
+    elif klass == Predicate:  # TODO
+        yield from random_predicates(**kwargs)
+    else:
+        raise ValueError(f"No generator found for {klass}")
 
 
 @generate_true.register