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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.6
+Version: 0.7
 Summary: Module to create composable predicates
 Author-email: Maurits Rijk <maurits.rijk@gmail.com>
 Requires-Python: >=3.10
@@ -81,6 +81,21 @@ filtered = [x for x in range(10) if between_2_and_3(x)]
 Of course this example looks way more complicated than the original version. The point here is that you can build
 reusable predicates that can be used in multiple locations.
 
+So lets do just that, reuse our predicate to create a generator. The ``generate_false`` will create an infinite
+series of integers for which the predicate ``between_2_and_3`` is False. The ``generate_true`` will create an
+infinite (well, with lots of duplicates obviously) series of integers for which the predicate is True.
+
+```python
+from predicate import generate_false, generate_true
+from more_itertools import take
+
+take(5, generate_true(between_2_and_3))
+
+take(5, generate_false(between_2_and_3))
+```
+
+This might be useful for example in unit tests.
+
 # Example 2
 
 A unique (?) py-predicate feature is that you can define self referencing predicates.

{py_predicate-0.6 → py_predicate-0.7}/README.md

@@ -38,6 +38,21 @@ filtered = [x for x in range(10) if between_2_and_3(x)]
 Of course this example looks way more complicated than the original version. The point here is that you can build
 reusable predicates that can be used in multiple locations.
 
+So lets do just that, reuse our predicate to create a generator. The ``generate_false`` will create an infinite
+series of integers for which the predicate ``between_2_and_3`` is False. The ``generate_true`` will create an
+infinite (well, with lots of duplicates obviously) series of integers for which the predicate is True.
+
+```python
+from predicate import generate_false, generate_true
+from more_itertools import take
+
+take(5, generate_true(between_2_and_3))
+
+take(5, generate_false(between_2_and_3))
+```
+
+This might be useful for example in unit tests.
+
 # Example 2
 
 A unique (?) py-predicate feature is that you can define self referencing predicates.

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

@@ -2,37 +2,16 @@
 
 __version__ = "0.0.1"
 
-from predicate.all_predicate import AllPredicate
-from predicate.any_predicate import AnyPredicate
-from predicate.eq_predicate import EqPredicate
+from predicate.always_false_predicate import always_false_p, never_p
+from predicate.always_true_predicate import always_p, always_true_p
 from predicate.explain import explain
-from predicate.formatter.format_dot import to_dot
-from predicate.formatter.format_json import to_json
-from predicate.ge_predicate import GePredicate
+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.gt_predicate import GtPredicate
-from predicate.is_empty_predicate import IsEmptyPredicate, IsNotEmptyPredicate, is_empty_p, is_not_empty_p
-from predicate.is_none_predicate import IsNonePredicate
-from predicate.is_not_none_predicate import IsNotNonePredicate
-from predicate.le_predicate import LePredicate
-from predicate.lt_predicate import LtPredicate
-from predicate.ne_predicate import NePredicate
+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.optimizer.predicate_optimizer import can_optimize, optimize
-from predicate.predicate import (
-    AlwaysFalsePredicate,
-    AlwaysTruePredicate,
-    AndPredicate,
-    NotPredicate,
-    OrPredicate,
-    Predicate,
-    XorPredicate,
-    always_false_p,
-    always_true_p,
-)
 from predicate.set_predicates import (
-    InPredicate,
-    NotInPredicate,
     in_p,
     is_real_subset_p,
     is_real_superset_p,
@@ -100,29 +79,9 @@ from predicate.standard_predicates import (
 )
 
 __all__ = [
-    "AllPredicate",
-    "AlwaysFalsePredicate",
-    "AlwaysTruePredicate",
-    "AndPredicate",
-    "AnyPredicate",
-    "EqPredicate",
-    "GePredicate",
-    "GtPredicate",
-    "LePredicate",
-    "LtPredicate",
-    "InPredicate",
-    "IsEmptyPredicate",
-    "IsNonePredicate",
-    "IsNotEmptyPredicate",
-    "IsNotNonePredicate",
-    "NePredicate",
-    "NotInPredicate",
-    "NotPredicate",
-    "OrPredicate",
-    "Predicate",
-    "XorPredicate",
     "all_p",
     "always_false_p",
+    "always_p",
     "always_true_p",
     "any_p",
     "can_optimize",
@@ -165,6 +124,8 @@ __all__ = [
     "is_int_p",
     "is_iterable_of_p",
     "is_iterable_p",
+    "is_lambda_p",
+    "is_lambda_with_signature_p",
     "is_list_of_p",
     "is_list_p",
     "is_lower_p",
@@ -192,6 +153,7 @@ __all__ = [
     "lt_p",
     "ne_p",
     "neg_p",
+    "never_p",
     "not_in_p",
     "optimize",
     "pos_p",
@@ -201,6 +163,7 @@ __all__ = [
     "this_p",
     "to_dot",
     "to_json",
+    "to_latex",
     "zero_p",
 ]
 

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

@@ -1,8 +1,7 @@
 from dataclasses import dataclass
 from typing import Iterable, override
 
-from more_itertools import first
-
+from predicate.helpers import first_false
 from predicate.predicate import Predicate
 
 
@@ -15,11 +14,14 @@ class AllPredicate[T](Predicate[T]):
     def __call__(self, iterable: Iterable[T]) -> bool:
         return all(self.predicate(x) for x in iterable)
 
+    def __contains__(self, predicate: Predicate[T]) -> bool:
+        return predicate in self.predicate
+
     def __repr__(self) -> str:
         return f"all({repr(self.predicate)})"
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
-        fail = first(item for item in iterable if not self.predicate(item))
+        fail = first_false(iterable, self.predicate)
 
-        return {"result": False, "reason": f"Item '{fail}' didn't match predicate {repr(self.predicate)}"}
+        return {"reason": f"Item '{fail}' didn't match predicate {repr(self.predicate)}"}

py_predicate-0.7/predicate/always_false_predicate.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Final, override
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class AlwaysFalsePredicate(Predicate):
+    """A predicate class that models the 'False' predicate."""
+
+    def __call__(self, *args, **kwargs):
+        return False
+
+    def __repr__(self) -> str:
+        return "always_false_p"
+
+    @override
+    def explain_failure(self, *args, **kwargs) -> dict:
+        return {"reason": "Always returns False"}
+
+
+always_false_p: Final[AlwaysFalsePredicate] = AlwaysFalsePredicate()
+"""Predicate that always evaluates to False."""
+
+never_p = always_false_p
+"""Synonym for always_false_p."""

py_predicate-0.7/predicate/always_true_predicate.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import Final
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class AlwaysTruePredicate(Predicate):
+    """A predicate class that models the 'True' predicate."""
+
+    def __call__(self, *args, **kwargs):
+        return True
+
+    def __repr__(self) -> str:
+        return "always_true_p"
+
+
+always_true_p: Final[AlwaysTruePredicate] = AlwaysTruePredicate()
+"""Predicate that always evaluates to True."""
+
+always_p = always_true_p
+"""Synonym for always_true_p."""

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

@@ -13,9 +13,12 @@ class AnyPredicate[T](Predicate[T]):
     def __call__(self, iterable: Iterable[T]) -> bool:
         return any(self.predicate(x) for x in iterable)
 
+    def __contains__(self, predicate: Predicate[T]) -> bool:
+        return predicate in self.predicate
+
     def __repr__(self) -> str:
         return f"any({repr(self.predicate)})"
 
     @override
     def explain_failure(self, iterable: Iterable[T]) -> dict:
-        return {"result": False, "reason": f"No item matches predicate {repr(self.predicate)}"}
+        return {"reason": f"No item matches predicate {repr(self.predicate)}"}

{py_predicate-0.6 → py_predicate-0.7}/predicate/comp_predicate.py

@@ -17,6 +17,9 @@ class CompPredicate[S, T](Predicate[T]):
     def __repr__(self) -> str:
         return f"comp_p({repr(self.predicate)})"
 
+    def __contains__(self, predicate: Predicate[T]) -> bool:
+        return predicate in self.predicate
+
     @override
     def explain_failure(self, x: S) -> dict:
-        return {"result": False, "predicate": self.predicate.explain(x)}
+        return {"reason": self.predicate.explain(x)}

{py_predicate-0.6 → py_predicate-0.7}/predicate/constructor/construct.py

@@ -2,8 +2,19 @@ from typing import Iterator
 
 from more_itertools import gray_product
 
-from predicate import 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.predicate import Predicate, always_false_p, always_true_p
+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.predicate import Predicate
 from predicate.standard_predicates import all_p, is_bool_p, is_dict_p, is_list_p, is_none_p
 
 # TODO: this is very much work under construction (pun intended) and not ready for public consumption

{py_predicate-0.6 → py_predicate-0.7}/predicate/dict_of_predicate.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from typing import Any, override
 
+from predicate.eq_predicate import EqPredicate
 from predicate.predicate import Predicate
 
 
@@ -11,15 +12,6 @@ class DictOfPredicate[T](Predicate[T]):
     key_value_predicates: list[tuple[Predicate, Predicate]]
 
     def __init__(self, key_value_predicates: list[tuple[Predicate | str, Predicate]]):
-        def to_key_p(key_p: Predicate | str) -> Predicate:
-            from predicate.standard_predicates import eq_p
-
-            match key_p:
-                case str(s):
-                    return eq_p(s)
-                case _:
-                    return key_p
-
         self.key_value_predicates = [(to_key_p(key_p), value_p) for key_p, value_p in key_value_predicates]
 
     def __call__(self, x: Any) -> bool:
@@ -42,10 +34,37 @@ class DictOfPredicate[T](Predicate[T]):
         return True
 
     def __repr__(self) -> str:
-        # TODO: show predicates
-        return "is_dict_of_p"
+        def to_key_value_str(key_p: Predicate, value_p: Predicate) -> str:
+            return f"({repr(from_key_p(key_p))}, {repr(value_p)})"
+
+        key_value_predicates = ", ".join(
+            to_key_value_str(key_p, value_p) for key_p, value_p in self.key_value_predicates
+        )
+
+        return f"is_dict_of_p({key_value_predicates})"
 
     @override
     def explain_failure(self, x: Any) -> dict:
-        # TODO: finish
-        return {"result": False, "key_value_predicates": []}
+        match x:
+            case dict():
+                return {"key_value_predicates": []}
+            case _:
+                return {"reason": f"{x} is not an instance of a dict"}
+
+
+def to_key_p(key_p: Predicate | str) -> Predicate:
+    from predicate.standard_predicates import eq_p
+
+    match key_p:
+        case str(s):
+            return eq_p(s)
+        case _:
+            return key_p
+
+
+def from_key_p(key_p: Predicate) -> Predicate | str:
+    match key_p:
+        case EqPredicate(v):
+            return v
+        case _:
+            return key_p

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

@@ -18,4 +18,4 @@ class EqPredicate[T](Predicate[T]):
 
     @override
     def explain_failure(self, x: T) -> dict:
-        return {"result": False, "reason": f"{x} is not equal to {self.v}"}
+        return {"reason": f"{x} is not equal to {self.v}"}

{py_predicate-0.6 → py_predicate-0.7}/predicate/fn_predicate.py

@@ -14,8 +14,8 @@ class FnPredicate[T](Predicate[T]):
         return self.predicate_fn(x)
 
     def __repr__(self) -> str:
-        return "fn_p"
+        return f"fn_p(predicate_fn={self.predicate_fn.__name__})"
 
     @override
     def explain_failure(self, x: T) -> dict:
-        return {"result": False, "reason": f"Function returned False for value {x}"}
+        return {"reason": f"Function returned False for value {x}"}

py_predicate-0.7/predicate/formatter/__init__.py

@@ -0,0 +1,9 @@
+from predicate.formatter.format_dot import to_dot
+from predicate.formatter.format_json import to_json
+from predicate.formatter.format_latex import to_latex
+
+__all__ = [
+    "to_dot",
+    "to_json",
+    "to_latex",
+]

{py_predicate-0.6 → py_predicate-0.7}/predicate/formatter/format_dot.py

@@ -6,15 +6,21 @@ import graphviz  # type: ignore
 from more_itertools import first
 
 from predicate.all_predicate import AllPredicate
+from predicate.always_false_predicate import AlwaysFalsePredicate
+from predicate.always_true_predicate import AlwaysTruePredicate
 from predicate.any_predicate import AnyPredicate
 from predicate.comp_predicate import CompPredicate
 from predicate.dict_of_predicate import DictOfPredicate
 from predicate.eq_predicate import EqPredicate
 from predicate.fn_predicate import FnPredicate
+from predicate.formatter.helpers import set_to_str
 from predicate.ge_predicate import GePredicate
 from predicate.gt_predicate import GtPredicate
+from predicate.implies import Implies
+from predicate.is_falsy_predicate import IsFalsyPredicate
 from predicate.is_instance_predicate import IsInstancePredicate
 from predicate.is_none_predicate import IsNonePredicate
+from predicate.is_truthy_predicate import IsTruthyPredicate
 from predicate.lazy_predicate import LazyPredicate, find_predicate_by_ref
 from predicate.le_predicate import LePredicate
 from predicate.lt_predicate import LtPredicate
@@ -22,11 +28,7 @@ from predicate.named_predicate import NamedPredicate
 from predicate.ne_predicate import NePredicate
 from predicate.optimizer.predicate_optimizer import optimize
 from predicate.predicate import (
-    AlwaysFalsePredicate,
-    AlwaysTruePredicate,
     AndPredicate,
-    IsFalsyPredicate,
-    IsTruthyPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
@@ -69,12 +71,6 @@ def to_dot(predicate: Predicate, predicate_string: str | None = None, show_optim
     return dot
 
 
-def set_to_str(v: set) -> str:
-    # TODO: truncate if too many items.
-    items = ", ".join(str(item) for item in v)
-    return f"{{{items}}}"
-
-
 def render(dot, predicate: Predicate, node_nr: count):
     node_predicate_mapping: dict[str, Predicate] = {}
 
@@ -147,6 +143,8 @@ def render(dot, predicate: Predicate, node_nr: count):
                     dot.edge(kv, to_value(key), label="key")
                     dot.edge(kv, to_value(value), label="value")
                 return node
+            case Implies(left, right):
+                return add_node_left_right("implies", label="=>", left=left, right=right)
             case IsInstancePredicate(klass):
                 name = klass[0].__name__  # type: ignore
                 return add_node("instance", label=f"is_{name}_p")
@@ -209,15 +207,12 @@ def render_lazy_references(dot, node_predicate_mapping) -> None:
 
     for node, predicate in node_predicate_mapping.items():
         match predicate:
-            case LazyPredicate():
-                if reference := find_predicate_by_ref(frame, predicate.ref):
-                    add_dashed_line(node, reference)
-            case RootPredicate():
-                if root := find_root_predicate(frame, predicate):
-                    add_dashed_line(node, root)
-            case ThisPredicate():
-                if this := find_this_predicate(frame, predicate):
-                    add_dashed_line(node, this)
+            case LazyPredicate() if reference := find_predicate_by_ref(frame, predicate.ref):
+                add_dashed_line(node, reference)
+            case RootPredicate() if root := find_root_predicate(frame, predicate):
+                add_dashed_line(node, root)
+            case ThisPredicate() if this := find_this_predicate(frame, predicate):
+                add_dashed_line(node, this)
 
 
 def render_original(dot, predicate: Predicate, node_nr) -> None:

{py_predicate-0.6 → py_predicate-0.7}/predicate/formatter/format_json.py

@@ -1,16 +1,16 @@
 from typing import Any
 
 from predicate.all_predicate import AllPredicate
+from predicate.always_false_predicate import AlwaysFalsePredicate
+from predicate.always_true_predicate import AlwaysTruePredicate
 from predicate.any_predicate import AnyPredicate
 from predicate.fn_predicate import FnPredicate
+from predicate.is_falsy_predicate import IsFalsyPredicate
+from predicate.is_truthy_predicate import IsTruthyPredicate
 from predicate.named_predicate import NamedPredicate
 from predicate.ne_predicate import NePredicate
 from predicate.predicate import (
-    AlwaysFalsePredicate,
-    AlwaysTruePredicate,
     AndPredicate,
-    IsFalsyPredicate,
-    IsTruthyPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,

py_predicate-0.7/predicate/formatter/format_latex.py

@@ -0,0 +1,86 @@
+from predicate.all_predicate import AllPredicate
+from predicate.always_false_predicate import AlwaysFalsePredicate
+from predicate.always_true_predicate import AlwaysTruePredicate
+from predicate.any_predicate import AnyPredicate
+from predicate.eq_predicate import EqPredicate
+from predicate.ge_predicate import GePredicate
+from predicate.gt_predicate import GtPredicate
+from predicate.implies_predicate import ImpliesPredicate
+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,
+    IsRealSubsetPredicate,
+    IsRealSupersetPredicate,
+    IsSubsetPredicate,
+    IsSupersetPredicate,
+)
+
+
+def set_to_latex_set(v: set) -> str:
+    items = ", ".join(str(item) for item in v)
+    return f"\\{{{items}\\}}"
+
+
+def to_latex(predicate: Predicate) -> str:
+    """Format predicate as LaTeX."""
+    match predicate:
+        case AllPredicate(all_predicate):
+            return f"\\forall x \\in S, {to_latex(all_predicate)}"
+        case AlwaysFalsePredicate():
+            return "False"
+        case AlwaysTruePredicate():
+            return "True"
+        case AndPredicate(left, right):
+            return f"{to_latex(left)} \\wedge {to_latex(right)}"
+        case AnyPredicate(all_predicate):
+            return f"\\exists x \\in S, {to_latex(all_predicate)}"
+        case EqPredicate(v):
+            return f"x = {v}"
+        case GePredicate(v):
+            return f"x \\ge {v}"
+        case GeLePredicate(lower, upper):
+            return f"{lower} \\le x \\le {upper}"
+        case GeLtPredicate(lower, upper):
+            return f"{lower} \\le x \\lt {upper}"
+        case GtLePredicate(lower, upper):
+            return f"{lower} \\lt x \\le {upper}"
+        case GtLtPredicate(lower, upper):
+            return f"{lower} \\lt x \\lt {upper}"
+        case GtPredicate(v):
+            return f"x \\gt {v}"
+        case ImpliesPredicate(p):
+            return f"p \\implies {to_latex(p)}"
+        case InPredicate(v):
+            return f"x \\in {set_to_latex_set(v)}"
+        case IsRealSubsetPredicate(v):
+            return f"x \\subseteq {set_to_latex_set(v)}"
+        case IsSubsetPredicate(v):
+            return f"x \\subset {set_to_latex_set(v)}"
+        case IsRealSupersetPredicate(v):
+            return f"x \\supseteq {set_to_latex_set(v)}"
+        case IsSupersetPredicate(v):
+            return f"x \\supset {set_to_latex_set(v)}"
+        case LePredicate(v):
+            return f"x \\le {v}"
+        case LtPredicate(v):
+            return f"x \\lt {v}"
+        case NePredicate(v):
+            return f"x \\neq {v}"
+        case NotPredicate(child):
+            return f"\\neg {to_latex(child)}"
+        case OrPredicate(left, right):
+            return f"{to_latex(left)} \\vee {to_latex(right)}"
+        case XorPredicate(left, right):
+            return f"{to_latex(left)} \\oplus {to_latex(right)}"
+        case _:
+            raise ValueError(f"Unknown predicate type {predicate}")

py_predicate-0.7/predicate/formatter/helpers.py

@@ -0,0 +1,4 @@
+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.6 → py_predicate-0.7}/predicate/ge_predicate.py

@@ -18,4 +18,4 @@ class GePredicate[T](Predicate[T]):
 
     @override
     def explain_failure(self, x: T) -> dict:
-        return {"result": False, "reason": f"{x} is not greater or equal to {self.v}"}
+        return {"reason": f"{x} is not greater or equal to {self.v}"}