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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.7
+Version: 0.9
 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.9}/predicate/__init__.py

@@ -8,8 +8,8 @@ from predicate.explain import explain
 from predicate.formatter import to_dot, to_json, to_latex
 from predicate.generator.generate_false import generate_false
 from predicate.generator.generate_true import generate_true
-from predicate.is_empty_predicate import is_empty_p, is_not_empty_p
 from predicate.is_lambda_predicate import is_lambda_p, is_lambda_with_signature_p
+from predicate.match_predicate import exactly_n, match_p, optional, plus, repeat, star
 from predicate.optimizer.predicate_optimizer import can_optimize, optimize
 from predicate.set_predicates import (
     in_p,
@@ -42,6 +42,7 @@ from predicate.standard_predicates import (
     is_datetime_p,
     is_dict_of_p,
     is_dict_p,
+    is_empty_p,
     is_falsy_p,
     is_finite_p,
     is_float_p,
@@ -55,7 +56,9 @@ from predicate.standard_predicates import (
     is_list_p,
     is_nan_p,
     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,
@@ -89,6 +92,7 @@ __all__ = [
     "eq_false_p",
     "eq_p",
     "eq_true_p",
+    "exactly_n",
     "explain",
     "fn_p",
     "ge_le_p",
@@ -133,6 +137,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",
@@ -151,14 +156,19 @@ __all__ = [
     "lazy_p",
     "le_p",
     "lt_p",
+    "match_p",
     "ne_p",
     "neg_p",
     "never_p",
     "not_in_p",
     "optimize",
+    "optional",
+    "plus",
     "pos_p",
     "regex_p",
+    "repeat",
     "root_p",
+    "star",
     "tee_p",
     "this_p",
     "to_dot",

{py_predicate-0.7 → py_predicate-0.9}/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 self.predicate.klass
 
     @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.9}/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.9}/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.9}/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 self.predicate.klass
 
     @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.7 → py_predicate-0.9}/predicate/comp_predicate.py

@@ -15,7 +15,7 @@ class CompPredicate[S, T](Predicate[T]):
         return self.predicate(self.fn(x))
 
     def __repr__(self) -> str:
-        return f"comp_p({repr(self.predicate)})"
+        return f"comp_p({self.predicate!r})"
 
     def __contains__(self, predicate: Predicate[T]) -> bool:
         return predicate in self.predicate

py_predicate-0.9/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.9/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.9/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.9}/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.9}/predicate/fn_predicate.py

@@ -1,14 +1,20 @@
 from dataclasses import dataclass
-from typing import Callable, override
+from typing import Callable, Iterator, override
 
 from predicate.predicate import Predicate
 
 
+def undefined() -> Iterator:
+    raise ValueError("Please register generator type")
+
+
 @dataclass
 class FnPredicate[T](Predicate[T]):
     """A predicate class that can hold a function."""
 
     predicate_fn: Callable[[T], bool]
+    generate_false_fn: Callable[[], Iterator]
+    generate_true_fn: Callable[[], Iterator]
 
     def __call__(self, x: T) -> bool:
         return self.predicate_fn(x)

{py_predicate-0.7 → py_predicate-0.9}/predicate/formatter/helpers.py

@@ -1,4 +1,3 @@
 def set_to_str(v: set) -> str:
-    # TODO: truncate if too many items.
     items = ", ".join(str(item) for item in v)
     return f"{{{items}}}"

{py_predicate-0.7 → py_predicate-0.9}/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.9}/predicate/generator/generate_false.py

@@ -6,13 +6,14 @@ from functools import singledispatch
 from itertools import repeat
 from uuid import UUID
 
-from more_itertools import chunked, flatten, interleave, random_combination_with_replacement, random_permutation, take
+from more_itertools import chunked, first, flatten, interleave, random_permutation, take
 
 from predicate.all_predicate import AllPredicate
 from predicate.always_false_predicate import AlwaysFalsePredicate, always_false_p
 from predicate.always_true_predicate import AlwaysTruePredicate, always_true_p
 from predicate.dict_of_predicate import DictOfPredicate
 from predicate.eq_predicate import EqPredicate
+from predicate.fn_predicate import FnPredicate
 from predicate.ge_predicate import GePredicate
 from predicate.generator.helpers import (
     generate_anys,
@@ -26,11 +27,11 @@ from predicate.generator.helpers import (
     random_floats,
     random_ints,
     random_iterables,
+    random_values_of_type,
 )
 from predicate.gt_predicate import GtPredicate
 from predicate.has_key_predicate import HasKeyPredicate
 from predicate.has_length_predicate import HasLengthPredicate
-from predicate.is_empty_predicate import IsEmptyPredicate, IsNotEmptyPredicate
 from predicate.is_falsy_predicate import IsFalsyPredicate
 from predicate.is_instance_predicate import IsInstancePredicate
 from predicate.is_none_predicate import IsNonePredicate
@@ -41,13 +42,7 @@ from predicate.list_of_predicate import ListOfPredicate
 from predicate.lt_predicate import LtPredicate
 from predicate.ne_predicate import NePredicate
 from predicate.optimizer.predicate_optimizer import optimize
-from predicate.predicate import (
-    AndPredicate,
-    NotPredicate,
-    OrPredicate,
-    Predicate,
-    XorPredicate,
-)
+from predicate.predicate import AndPredicate, NotPredicate, OrPredicate, Predicate, XorPredicate
 from predicate.range_predicate import GeLePredicate, GeLtPredicate, GtLePredicate, GtLtPredicate
 from predicate.set_of_predicate import SetOfPredicate
 from predicate.set_predicates import InPredicate, NotInPredicate
@@ -56,21 +51,17 @@ from predicate.tuple_of_predicate import TupleOfPredicate
 
 
 @singledispatch
-def generate_false[T](_predicate: Predicate[T]) -> Iterator[T]:
+def generate_false[T](predicate: Predicate[T]) -> Iterator[T]:
     """Generate values that don't satisfy this predicate."""
-    raise ValueError("Please register generator for correct predicate type")
+    raise ValueError(f"Please register generator for correct predicate type: {predicate!r}")
 
 
 @generate_false.register
-def generate_all_p(all_predicate: AllPredicate) -> Iterator:
+def generate_all_p(all_predicate: AllPredicate, *, min_size: int = 1, max_size: int = 10) -> Iterator:
     predicate = all_predicate.predicate
 
     while True:
-        max_length = random.randint(1, 10)
-
-        # TODO: combination of some true values, or just rewrite as any(false)
-        values = take(max_length, generate_false(predicate))
-        yield random_combination_with_replacement(values, max_length)
+        yield generate_at_least_one_false(predicate, min_size=min_size, max_size=max_size)
 
 
 @generate_false.register
@@ -98,7 +89,7 @@ def generate_always_true(_predicate: AlwaysTruePredicate) -> Iterator:
 
 @generate_false.register
 def generate_eq(predicate: EqPredicate) -> Iterator:
-    yield from generate_anys(~predicate)
+    yield from (value for value in random_values_of_type(klass=predicate.klass) if not predicate(value))
 
 
 @generate_false.register
@@ -115,8 +106,13 @@ def generate_has_key(predicate: HasKeyPredicate) -> Iterator:
 
 @generate_false.register
 def generate_has_length(predicate: HasLengthPredicate) -> Iterator:
-    length = predicate.length
-    yield from random_iterables(max_size=length - 1)
+    length_p = predicate.length_p
+    invalid_lengths = (length for length in generate_false(length_p) if length >= 0)
+    invalid_length = first(invalid_lengths)
+
+    # TODO: generate with different invalid lengths
+
+    yield from random_iterables(min_size=invalid_length, max_size=invalid_length)
 
 
 @generate_false.register
@@ -234,6 +230,11 @@ def generate_falsy(_predicate: IsFalsyPredicate) -> Iterator:
     yield from generate_anys(IsTruthyPredicate())
 
 
+@generate_false.register
+def generate_fn_p(predicate: FnPredicate) -> Iterator:
+    yield from predicate.generate_false_fn()
+
+
 @generate_false.register
 def generate_in(predicate: InPredicate) -> Iterator:
     # TODO: combine with generate_not_in true
@@ -245,16 +246,6 @@ def generate_in(predicate: InPredicate) -> Iterator:
                 yield from generate_strings(~predicate)
 
 
-@generate_false.register
-def generate_is_empty(_predicate: IsEmptyPredicate) -> Iterator:
-    yield from random_iterables(min_size=1)
-
-
-@generate_false.register
-def generate_is_not_empty(_predicate: IsNotEmptyPredicate) -> Iterator:
-    yield from random_iterables(max_size=0)
-
-
 @generate_false.register
 def generate_le(predicate: LePredicate) -> Iterator:
     match v := predicate.v:
@@ -331,9 +322,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
@@ -354,9 +354,7 @@ def generate_list_of_p(list_of_predicate: ListOfPredicate, *, min_size: int = 1,
     predicate = list_of_predicate.predicate
 
     while True:
-        length = random.randint(min_size, max_size)
-        # TODO: generate mix of both false (at least 1) and true
-        yield take(length, generate_false(predicate))
+        yield list(generate_at_least_one_false(predicate, min_size=min_size, max_size=max_size))
 
 
 @generate_false.register
@@ -368,12 +366,14 @@ def generate_tuple_of_p(tuple_of_predicate: TupleOfPredicate) -> Iterator:
 
 
 @generate_false.register
-def generate_set_of_p(set_of_predicate: SetOfPredicate) -> Iterator:
+def generate_set_of_p(set_of_predicate: SetOfPredicate, *, min_size: int = 1, max_size: int = 10) -> Iterator:
     predicate = set_of_predicate.predicate
 
-    values = take(10, generate_false(predicate))
-
-    yield set(random_combination_with_replacement(values, 5))
+    while True:
+        result = set(generate_at_least_one_false(predicate, min_size=min_size, max_size=max_size))
+        # This check is needed because {False, 0} and {True, 1} result in {False} and {True}
+        if not set_of_predicate(result):
+            yield result
 
 
 @generate_false.register
@@ -390,3 +390,19 @@ def generate_xor(predicate: XorPredicate) -> Iterator:
         left_and_right = (item for item in generate_true(predicate.left) if predicate.right(item))
 
         yield from random_first_from_iterables(left_and_right, not_right_and_not_left)
+
+
+def generate_at_least_one_false(predicate: Predicate, *, min_size: int, max_size: int) -> tuple:
+    from predicate import generate_true
+
+    length = random.randint(min_size, max_size)
+
+    nr_false_values = random.randint(1, length) if length > 1 else 1
+    nr_true_values = length - nr_false_values
+
+    false_values = take(nr_false_values, generate_false(predicate))
+    true_values = take(nr_true_values, generate_true(predicate))
+
+    combined_values = false_values + true_values
+
+    return random_permutation(combined_values)