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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.4
+Version: 0.6
 Summary: Module to create composable predicates
 Author-email: Maurits Rijk <maurits.rijk@gmail.com>
 Requires-Python: >=3.10
@@ -91,9 +91,9 @@ either a string, or a list of data that can again either be a string or a list o
 data. Ad infinitum.
 
 ```python
-from predicate import all_p, is_list_p, is_str_p, lazy_p
+from predicate import all_p, is_list_p, is_str_p, root_p
 
-str_or_list_of_str = is_str_p | (is_list_p & all_p(lazy_p("str_or_list_of_str")))
+str_or_list_of_str = is_str_p | (is_list_p & all_p(root_p))
 ```
 
 Using plain Python, the above one-liner would have to be coded as a (recursive) function.

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

@@ -48,9 +48,9 @@ either a string, or a list of data that can again either be a string or a list o
 data. Ad infinitum.
 
 ```python
-from predicate import all_p, is_list_p, is_str_p, lazy_p
+from predicate import all_p, is_list_p, is_str_p, root_p
 
-str_or_list_of_str = is_str_p | (is_list_p & all_p(lazy_p("str_or_list_of_str")))
+str_or_list_of_str = is_str_p | (is_list_p & all_p(root_p))
 ```
 
 Using plain Python, the above one-liner would have to be coded as a (recursive) function.

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

@@ -4,34 +4,41 @@ __version__ = "0.0.1"
 
 from predicate.all_predicate import AllPredicate
 from predicate.any_predicate import AnyPredicate
+from predicate.eq_predicate import EqPredicate
+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.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.optimizer.predicate_optimizer import can_optimize, optimize
 from predicate.predicate import (
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
-    EqPredicate,
-    FnPredicate,
-    GePredicate,
-    GtPredicate,
-    InPredicate,
-    IsEmptyPredicate,
-    IsNonePredicate,
-    IsNotNonePredicate,
-    LePredicate,
-    LtPredicate,
-    NePredicate,
-    NotInPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
     XorPredicate,
     always_false_p,
     always_true_p,
-    is_empty_p,
+)
+from predicate.set_predicates import (
+    InPredicate,
+    NotInPredicate,
+    in_p,
+    is_real_subset_p,
+    is_real_superset_p,
+    is_subset_p,
+    is_superset_p,
+    not_in_p,
 )
 from predicate.standard_predicates import (
     all_p,
@@ -47,12 +54,14 @@ from predicate.standard_predicates import (
     gt_le_p,
     gt_lt_p,
     gt_p,
-    in_p,
+    has_key_p,
+    has_length_p,
     is_bool_p,
     is_callable_p,
     is_complex_p,
     is_container_p,
     is_datetime_p,
+    is_dict_of_p,
     is_dict_p,
     is_falsy_p,
     is_finite_p,
@@ -65,9 +74,11 @@ from predicate.standard_predicates import (
     is_iterable_p,
     is_list_of_p,
     is_list_p,
+    is_nan_p,
     is_none_p,
     is_not_none_p,
     is_predicate_p,
+    is_range_p,
     is_set_of_p,
     is_set_p,
     is_str_p,
@@ -80,7 +91,6 @@ from predicate.standard_predicates import (
     lt_p,
     ne_p,
     neg_p,
-    not_in_p,
     pos_p,
     regex_p,
     root_p,
@@ -90,21 +100,21 @@ from predicate.standard_predicates import (
 )
 
 __all__ = [
+    "AllPredicate",
     "AlwaysFalsePredicate",
     "AlwaysTruePredicate",
-    "AllPredicate",
     "AndPredicate",
     "AnyPredicate",
     "EqPredicate",
-    "FnPredicate",
     "GePredicate",
     "GtPredicate",
+    "LePredicate",
+    "LtPredicate",
     "InPredicate",
     "IsEmptyPredicate",
     "IsNonePredicate",
+    "IsNotEmptyPredicate",
     "IsNotNonePredicate",
-    "LePredicate",
-    "LtPredicate",
     "NePredicate",
     "NotInPredicate",
     "NotPredicate",
@@ -120,7 +130,7 @@ __all__ = [
     "eq_false_p",
     "eq_p",
     "eq_true_p",
-    "is_falsy_p",
+    "explain",
     "fn_p",
     "ge_le_p",
     "ge_lt_p",
@@ -130,33 +140,52 @@ __all__ = [
     "gt_le_p",
     "gt_lt_p",
     "gt_p",
+    "has_key_p",
+    "has_length_p",
     "in_p",
+    "is_alnum_p",
+    "is_alpha_p",
+    "is_ascii_p",
     "is_bool_p",
     "is_callable_p",
     "is_complex_p",
     "is_container_p",
     "is_datetime_p",
+    "is_decimal_p",
+    "is_dict_of_p",
     "is_dict_p",
     "is_empty_p",
+    "is_falsy_p",
     "is_finite_p",
     "is_float_p",
     "is_hashable_p",
-    "is_instance_p",
+    "is_identifier_p",
     "is_inf_p",
+    "is_instance_p",
     "is_int_p",
-    "is_iterable_p",
     "is_iterable_of_p",
-    "is_list_p",
+    "is_iterable_p",
     "is_list_of_p",
+    "is_list_p",
+    "is_lower_p",
+    "is_nan_p",
     "is_none_p",
+    "is_not_empty_p",
     "is_not_none_p",
     "is_predicate_p",
-    "is_set_p",
+    "is_range_p",
     "is_set_of_p",
+    "is_set_p",
     "is_str_p",
+    "is_subset_p",
+    "is_superset_p",
+    "is_real_subset_p",
+    "is_real_superset_p",
+    "is_title_p",
     "is_truthy_p",
-    "is_tuple_p",
     "is_tuple_of_p",
+    "is_tuple_p",
+    "is_upper_p",
     "is_uuid_p",
     "lazy_p",
     "le_p",
@@ -174,3 +203,14 @@ __all__ = [
     "to_json",
     "zero_p",
 ]
+
+from predicate.str_predicates import (
+    is_alnum_p,
+    is_alpha_p,
+    is_ascii_p,
+    is_decimal_p,
+    is_identifier_p,
+    is_lower_p,
+    is_title_p,
+    is_upper_p,
+)

py_predicate-0.6/predicate/all_predicate.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Iterable, override
+
+from more_itertools import first
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class AllPredicate[T](Predicate[T]):
+    """A predicate class that models the 'all' predicate."""
+
+    predicate: Predicate[T]
+
+    def __call__(self, iterable: Iterable[T]) -> bool:
+        return all(self.predicate(x) for x in iterable)
+
+    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))
+
+        return {"result": False, "reason": f"Item '{fail}' didn't match predicate {repr(self.predicate)}"}

py_predicate-0.6/predicate/any_predicate.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Iterable, override
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class AnyPredicate[T](Predicate[T]):
+    """A predicate class that models the 'any' predicate."""
+
+    predicate: Predicate[T]
+
+    def __call__(self, iterable: Iterable[T]) -> bool:
+        return any(self.predicate(x) for x in iterable)
+
+    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)}"}

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

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Callable
+from typing import Callable, override
 
 from predicate.predicate import Predicate
 
@@ -16,3 +16,7 @@ class CompPredicate[S, T](Predicate[T]):
 
     def __repr__(self) -> str:
         return f"comp_p({repr(self.predicate)})"
+
+    @override
+    def explain_failure(self, x: S) -> dict:
+        return {"result": False, "predicate": self.predicate.explain(x)}

py_predicate-0.6/predicate/dict_of_predicate.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from typing import Any, override
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class DictOfPredicate[T](Predicate[T]):
+    """A predicate class that models the dict_of predicate."""
+
+    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:
+        if not isinstance(x, dict):
+            return False
+
+        if not x:
+            return False
+
+        # For all values, a predicate must be True
+        for key, value in x.items():
+            if not any(key_p(key) and value_p(value) for key_p, value_p in self.key_value_predicates):
+                return False
+
+        # All predicates must be True
+        for key_p, value_p in self.key_value_predicates:
+            if any(key_p(key) and not value_p(value) for key, value in x.items()):
+                return False
+
+        return True
+
+    def __repr__(self) -> str:
+        # TODO: show predicates
+        return "is_dict_of_p"
+
+    @override
+    def explain_failure(self, x: Any) -> dict:
+        # TODO: finish
+        return {"result": False, "key_value_predicates": []}

py_predicate-0.6/predicate/eq_predicate.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import override
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class EqPredicate[T](Predicate[T]):
+    """A predicate class that models the 'eq' (=) predicate."""
+
+    v: T
+
+    def __call__(self, x: T) -> bool:
+        return x == self.v
+
+    def __repr__(self) -> str:
+        return f"eq_p({self.v})"
+
+    @override
+    def explain_failure(self, x: T) -> dict:
+        return {"result": False, "reason": f"{x} is not equal to {self.v}"}

py_predicate-0.6/predicate/explain.py

@@ -0,0 +1,7 @@
+from typing import Any
+
+from predicate.predicate import Predicate
+
+
+def explain(predicate: Predicate, value: Any) -> dict:
+    return predicate.explain(value)

py_predicate-0.6/predicate/fn_predicate.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Callable, override
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class FnPredicate[T](Predicate[T]):
+    """A predicate class that can hold a function."""
+
+    predicate_fn: Callable[[T], bool]
+
+    def __call__(self, x: T) -> bool:
+        return self.predicate_fn(x)
+
+    def __repr__(self) -> str:
+        return "fn_p"
+
+    @override
+    def explain_failure(self, x: T) -> dict:
+        return {"result": False, "reason": f"Function returned False for value {x}"}

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

@@ -8,9 +8,18 @@ from more_itertools import first
 from predicate.all_predicate import AllPredicate
 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.ge_predicate import GePredicate
+from predicate.gt_predicate import GtPredicate
 from predicate.is_instance_predicate import IsInstancePredicate
+from predicate.is_none_predicate import IsNonePredicate
 from predicate.lazy_predicate import LazyPredicate, find_predicate_by_ref
+from predicate.le_predicate import LePredicate
+from predicate.lt_predicate import LtPredicate
 from predicate.named_predicate import NamedPredicate
+from predicate.ne_predicate import NePredicate
 from predicate.optimizer.predicate_optimizer import optimize
 from predicate.predicate import (
     AlwaysFalsePredicate,
@@ -25,25 +34,24 @@ from predicate.predicate import (
 )
 from predicate.range_predicate import GeLePredicate, GeLtPredicate, GtLePredicate, GtLtPredicate
 from predicate.root_predicate import RootPredicate, find_root_predicate
-from predicate.standard_predicates import (
-    EqPredicate,
-    FnPredicate,
-    GePredicate,
-    GtPredicate,
+from predicate.set_predicates import (
     InPredicate,
-    IsNonePredicate,
-    LePredicate,
-    LtPredicate,
-    NePredicate,
+    IsRealSubsetPredicate,
+    IsRealSupersetPredicate,
+    IsSubsetPredicate,
+    IsSupersetPredicate,
     NotInPredicate,
 )
 from predicate.tee_predicate import TeePredicate
 from predicate.this_predicate import ThisPredicate, find_this_predicate
+from predicate.tuple_of_predicate import TupleOfPredicate
 
 
-def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: bool = False):
+def to_dot(predicate: Predicate, predicate_string: str | None = None, show_optimized: bool = False):
     """Format predicate as a .dot file."""
-    graph_attr = {"label": predicate_string, "labelloc": "t"}
+    label = predicate_string if predicate_string else repr(predicate)
+
+    graph_attr = {"label": label, "labelloc": "t"}
 
     node_attr = {"shape": "rectangle", "style": "filled", "fillcolor": "#B7D7A8"}
 
@@ -61,46 +69,53 @@ def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: boo
     return dot
 
 
-def render(dot, predicate: Predicate, node_nr):
+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] = {}
 
-    def _add_node(name: str, *, label: str, predicate: Predicate):
+    def _add_node(name: str, *, label: str, predicate: Predicate | None) -> str:
         node = next(node_nr)
         unique_name = f"{name}_{node}"
         dot.node(unique_name, label=label)
-        node_predicate_mapping[unique_name] = predicate
+        if predicate:
+            node_predicate_mapping[unique_name] = predicate
         return unique_name
 
+    def _add_node_left_right(name: str, *, label: str, predicate: Predicate, left: Predicate, right: Predicate) -> str:
+        node = _add_node(name, label=label, predicate=predicate)
+        dot.edge(node, to_value(left))
+        dot.edge(node, to_value(right))
+
+        return node
+
+    def _add_node_with_child(name: str, *, label: str, predicate: Predicate, child: Predicate) -> str:
+        node = _add_node(name, label=label, predicate=predicate)
+        dot.edge(node, to_value(child))
+        return node
+
     def to_value(predicate: Predicate):
         add_node = partial(_add_node, predicate=predicate)
+        add_node_left_right = partial(_add_node_left_right, predicate=predicate)
+        add_node_with_child = partial(_add_node_with_child, predicate=predicate)
 
         match predicate:
             case AllPredicate(all_predicate):
-                node = add_node("all", label="∀")
-                child = to_value(all_predicate)
-                dot.edge(node, child)
-                return node
+                return add_node_with_child("all", label="∀", child=all_predicate)
             case AlwaysFalsePredicate():
                 return add_node("F", label="false")
             case AlwaysTruePredicate():
                 return add_node("T", label="true")
             case AndPredicate(left, right):
-                node = add_node("and", label="∧")
-                left_node = to_value(left)
-                right_node = to_value(right)
-                dot.edge(node, left_node)
-                dot.edge(node, right_node)
-                return node
+                return add_node_left_right("and", label="∧", left=left, right=right)
             case AnyPredicate(any_predicate):
-                node = add_node("any", label="∃")
-                child = to_value(any_predicate)
-                dot.edge(node, child)
-                return node
+                return add_node_with_child("any", label="∃", child=any_predicate)
             case CompPredicate(_fn, comp_predicate):
-                node = add_node("comp", label="f")
-                child = to_value(comp_predicate)
-                dot.edge(node, child)
-                return node
+                return add_node_with_child("comp", label="f", child=comp_predicate)
             case EqPredicate(v):
                 return add_node("eq", label=f"x = {v}")
             case IsFalsyPredicate():
@@ -119,17 +134,32 @@ def render(dot, predicate: Predicate, node_nr):
             case GtPredicate(v):
                 return add_node("gt", label=f"x > {v}")
             case GtLePredicate(upper, lower):
-                return add_node("gele", label=f"{lower} ≤ x ≤ {upper}")
+                return add_node("gtle", label=f"{lower} ≤ x ≤ {upper}")
             case GtLtPredicate(upper, lower):
-                return add_node("gelt", label=f"{lower} ≤ x < {upper}")
+                return add_node("gtlt", label=f"{lower} ≤ x < {upper}")
             case InPredicate(v):
-                items = ", ".join(str(item) for item in v)
-                return add_node("in", label=f"x ∈ {{{items}}}")
+                return add_node("in", label=f"x ∈ {set_to_str(v)}")
+            case DictOfPredicate(key_value_predicates):
+                node = add_node("dict_of", label="is_dict_of")
+                for key, value in key_value_predicates:
+                    kv = _add_node("kv", label="kv", predicate=None)
+                    dot.edge(node, kv)
+                    dot.edge(kv, to_value(key), label="key")
+                    dot.edge(kv, to_value(value), label="value")
+                return node
             case IsInstancePredicate(klass):
                 name = klass[0].__name__  # type: ignore
                 return add_node("instance", label=f"is_{name}_p")
             case IsNonePredicate():
                 return add_node("none", label="x = None")
+            case IsRealSubsetPredicate(v):
+                return add_node("real_subset", label=f"x ⊂ {set_to_str(v)}")
+            case IsSubsetPredicate(v):
+                return add_node("subset", label=f"x ⊆ {set_to_str(v)}")
+            case IsRealSupersetPredicate(v):
+                return add_node("real_superset", label=f"x ⊃ {set_to_str(v)}")
+            case IsSupersetPredicate(v):
+                return add_node("superset", label=f"x ⊇ {set_to_str(v)}")
             case LazyPredicate(ref):
                 return add_node("lazy", label=ref)
             case LePredicate(v):
@@ -139,35 +169,26 @@ def render(dot, predicate: Predicate, node_nr):
             case NamedPredicate(name):
                 return add_node("named", label=name)
             case NotInPredicate(v):
-                items = ", ".join(str(item) for item in v)
-                return add_node("in", label=f"x ∉ {{{items}}}")
+                return add_node("in", label=f"x ∉ {set_to_str(v)}")
             case NePredicate(v):
                 return add_node("ne", label=f"x ≠ {v}")
             case NotPredicate(not_predicate):
-                child = to_value(not_predicate)
-                node = add_node("not", label="¬")
-                dot.edge(node, child)
-                return node
+                return add_node_with_child("not", label="¬", child=not_predicate)
             case OrPredicate(left, right):
-                node = add_node("or", label="∨")
-                left_node = to_value(left)
-                right_node = to_value(right)
-                dot.edge(node, left_node)
-                dot.edge(node, right_node)
-                return node
+                return add_node_left_right("or", label="∨", left=left, right=right)
             case RootPredicate():
                 return add_node("root", label="root")
             case TeePredicate():
                 return add_node("tee", label="tee")
             case ThisPredicate():
                 return add_node("this", label="this")
-            case XorPredicate(left, right):
-                node = add_node("xor", label="⊻")
-                left_node = to_value(left)
-                right_node = to_value(right)
-                dot.edge(node, left_node)
-                dot.edge(node, right_node)
+            case TupleOfPredicate(predicates):
+                node = add_node("tuple_of", label="is_tuple_of")
+                for tuple_predicate in predicates:
+                    dot.edge(node, to_value(tuple_predicate))
                 return node
+            case XorPredicate(left, right):
+                return add_node_left_right("xor", label="⊻", left=left, right=right)
             case _:
                 raise ValueError(f"Unknown predicate type {predicate}")
 
@@ -176,7 +197,7 @@ def render(dot, predicate: Predicate, node_nr):
     render_lazy_references(dot, node_predicate_mapping)
 
 
-def render_lazy_references(dot, node_predicate_mapping):
+def render_lazy_references(dot, node_predicate_mapping) -> None:
     def find_in_mapping(lookup: Predicate) -> str:
         return first(node for node, predicate in node_predicate_mapping.items() if predicate == lookup)
 
@@ -199,14 +220,14 @@ def render_lazy_references(dot, node_predicate_mapping):
                     add_dashed_line(node, this)
 
 
-def render_original(dot, predicate: Predicate, node_nr):
+def render_original(dot, predicate: Predicate, node_nr) -> None:
     with dot.subgraph(name="cluster_original") as original:
         original.attr(style="filled", color="lightgrey")
         original.attr(label="Original predicate")
         render(original, predicate, node_nr)
 
 
-def render_optimized(dot, predicate: Predicate, node_nr):
+def render_optimized(dot, predicate: Predicate, node_nr) -> None:
     optimized_predicate = optimize(predicate)
 
     with dot.subgraph(name="cluster_optimized") as optimized:

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

@@ -2,15 +2,15 @@ from typing import Any
 
 from predicate.all_predicate import AllPredicate
 from predicate.any_predicate import AnyPredicate
+from predicate.fn_predicate import FnPredicate
 from predicate.named_predicate import NamedPredicate
+from predicate.ne_predicate import NePredicate
 from predicate.predicate import (
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
-    FnPredicate,
     IsFalsyPredicate,
     IsTruthyPredicate,
-    NePredicate,
     NotPredicate,
     OrPredicate,
     Predicate,

py_predicate-0.6/predicate/ge_predicate.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import override
+
+from predicate.predicate import ConstrainedT, Predicate
+
+
+@dataclass
+class GePredicate[T](Predicate[T]):
+    """A predicate class that models the 'ge' (>=) predicate."""
+
+    v: ConstrainedT
+
+    def __call__(self, x: T) -> bool:
+        return x >= self.v
+
+    def __repr__(self) -> str:
+        return f"ge_p({self.v})"
+
+    @override
+    def explain_failure(self, x: T) -> dict:
+        return {"result": False, "reason": f"{x} is not greater or equal to {self.v}"}