py-predicate 0.3__tar.gz → 0.5__tar.gz

{py_predicate-0.3 → py_predicate-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.3
+Version: 0.5
 Summary: Module to create composable predicates
 Author-email: Maurits Rijk <maurits.rijk@gmail.com>
 Requires-Python: >=3.10
@@ -21,6 +21,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: exrex
 Requires-Dist: graphviz
 Requires-Dist: lark
 Requires-Dist: more-itertools
@@ -32,6 +33,7 @@ Requires-Dist: black ; extra == "test"
 Requires-Dist: mypy ; extra == "test"
 Requires-Dist: mypy_extensions ; extra == "test"
 Requires-Dist: pytest ; extra == "test"
+Requires-Dist: pytest-benchmark ; extra == "test"
 Requires-Dist: pytest-cov ; extra == "test"
 Requires-Dist: ruff ; extra == "test"
 Project-URL: Documentation, https://mrijk.github.io/py-predicate/
@@ -89,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.3 → py_predicate-0.5}/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.3 → py_predicate-0.5}/predicate/__init__.py

@@ -2,28 +2,27 @@
 
 __version__ = "0.0.1"
 
+from predicate.all_predicate import AllPredicate
+from predicate.any_predicate import AnyPredicate
 from predicate.formatter.format_dot import to_dot
 from predicate.formatter.format_json import to_json
+from predicate.generator.generate_false import generate_false
+from predicate.generator.generate_true import generate_true
 from predicate.optimizer.predicate_optimizer import can_optimize, optimize
 from predicate.predicate import (
-    AllPredicate,
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
-    AnyPredicate,
     EqPredicate,
     FnPredicate,
     GePredicate,
     GtPredicate,
-    InPredicate,
     IsEmptyPredicate,
-    IsInstancePredicate,
     IsNonePredicate,
     IsNotNonePredicate,
     LePredicate,
     LtPredicate,
     NePredicate,
-    NotInPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
@@ -32,6 +31,16 @@ from predicate.predicate import (
     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,
     any_p,
@@ -40,16 +49,24 @@ from predicate.standard_predicates import (
     eq_p,
     eq_true_p,
     fn_p,
+    ge_le_p,
+    ge_lt_p,
     ge_p,
+    gt_le_p,
+    gt_lt_p,
     gt_p,
-    in_p,
+    has_length_p,
     is_bool_p,
     is_callable_p,
     is_complex_p,
+    is_container_p,
     is_datetime_p,
     is_dict_p,
     is_falsy_p,
+    is_finite_p,
     is_float_p,
+    is_hashable_p,
+    is_inf_p,
     is_instance_p,
     is_int_p,
     is_iterable_of_p,
@@ -59,9 +76,11 @@ from predicate.standard_predicates import (
     is_none_p,
     is_not_none_p,
     is_predicate_p,
+    is_range_p,
     is_set_of_p,
     is_set_p,
     is_str_p,
+    is_truthy_p,
     is_tuple_of_p,
     is_tuple_p,
     is_uuid_p,
@@ -69,10 +88,13 @@ from predicate.standard_predicates import (
     le_p,
     lt_p,
     ne_p,
-    not_in_p,
+    neg_p,
+    pos_p,
     regex_p,
     root_p,
+    tee_p,
     this_p,
+    zero_p,
 )
 
 __all__ = [
@@ -87,7 +109,6 @@ __all__ = [
     "GtPredicate",
     "InPredicate",
     "IsEmptyPredicate",
-    "IsInstancePredicate",
     "IsNonePredicate",
     "IsNotNonePredicate",
     "LePredicate",
@@ -107,42 +128,82 @@ __all__ = [
     "eq_false_p",
     "eq_p",
     "eq_true_p",
-    "is_falsy_p",
     "fn_p",
+    "ge_le_p",
+    "ge_lt_p",
     "ge_p",
+    "generate_false",
+    "generate_true",
+    "gt_le_p",
+    "gt_lt_p",
     "gt_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_p",
     "is_empty_p",
+    "is_falsy_p",
+    "is_finite_p",
     "is_float_p",
+    "is_hashable_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_none_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_tuple_p",
+    "is_subset_p",
+    "is_superset_p",
+    "is_real_subset_p",
+    "is_real_superset_p",
+    "is_title_p",
+    "is_truthy_p",
     "is_tuple_of_p",
+    "is_tuple_p",
+    "is_upper_p",
     "is_uuid_p",
     "lazy_p",
     "le_p",
     "lt_p",
     "ne_p",
+    "neg_p",
     "not_in_p",
     "optimize",
+    "pos_p",
     "regex_p",
     "root_p",
+    "tee_p",
     "this_p",
     "to_dot",
     "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.5/predicate/all_predicate.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+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)})"

py_predicate-0.5/predicate/any_predicate.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+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)})"

py_predicate-0.5/predicate/constructor/construct.py

@@ -0,0 +1,49 @@
+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.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
+
+
+def construct(false_set: list, true_set: list) -> Iterator[Predicate]:
+    predicates = list(initial_predicates())
+
+    while True:
+        for predicate in predicates:
+            all_true = all_p(predicate)
+            all_false = all_p(~predicate)
+            if all_true(true_set) and all_false(false_set):
+                yield predicate
+
+        predicates = list(create_mutations(predicates))
+
+
+def create_mutations(candidates: list[Predicate]) -> Iterator[Predicate]:
+    pairs = gray_product(candidates, candidates)
+    for pair in pairs:
+        left, right = pair
+        if 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 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

{py_predicate-0.3 → py_predicate-0.5}/predicate/formatter/format_dot.py

@@ -5,8 +5,12 @@ from itertools import count
 import graphviz  # type: ignore
 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.is_instance_predicate import IsInstancePredicate
 from predicate.lazy_predicate import LazyPredicate, find_predicate_by_ref
+from predicate.named_predicate import NamedPredicate
 from predicate.optimizer.predicate_optimizer import optimize
 from predicate.predicate import (
     AlwaysFalsePredicate,
@@ -14,29 +18,32 @@ from predicate.predicate import (
     AndPredicate,
     IsFalsyPredicate,
     IsTruthyPredicate,
-    NamedPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
     XorPredicate,
 )
+from predicate.range_predicate import GeLePredicate, GeLtPredicate, GtLePredicate, GtLtPredicate
 from predicate.root_predicate import RootPredicate, find_root_predicate
+from predicate.set_predicates import (
+    InPredicate,
+    IsRealSubsetPredicate,
+    IsRealSupersetPredicate,
+    IsSubsetPredicate,
+    IsSupersetPredicate,
+    NotInPredicate,
+)
 from predicate.standard_predicates import (
-    AllPredicate,
-    AnyPredicate,
     EqPredicate,
     FnPredicate,
     GePredicate,
     GtPredicate,
-    InPredicate,
-    IsInstancePredicate,
     IsNonePredicate,
     LePredicate,
     LtPredicate,
     NePredicate,
-    NotInPredicate,
-    PredicateFactory,
 )
+from predicate.tee_predicate import TeePredicate
 from predicate.this_predicate import ThisPredicate, find_this_predicate
 
 
@@ -60,46 +67,52 @@ def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: boo
     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):
     node_predicate_mapping: dict[str, Predicate] = {}
 
-    def _add_node(name: str, *, label: str, predicate: Predicate):
+    def _add_node(name: str, *, label: str, predicate: Predicate) -> str:
         node = next(node_nr)
         unique_name = f"{name}_{node}"
         dot.node(unique_name, label=label)
         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():
@@ -111,16 +124,31 @@ def render(dot, predicate: Predicate, node_nr):
                 return add_node("fn", label=f"fn: {name}")
             case GePredicate(v):
                 return add_node("ge", label=f"x ≥ {v}")
+            case GeLePredicate(upper, lower):
+                return add_node("gele", label=f"{lower} ≤ x ≤ {upper}")
+            case GeLtPredicate(upper, lower):
+                return add_node("gelt", label=f"{lower} ≤ x < {upper}")
             case GtPredicate(v):
                 return add_node("gt", label=f"x > {v}")
+            case GtLePredicate(upper, lower):
+                return add_node("gtle", label=f"{lower} ≤ x ≤ {upper}")
+            case GtLtPredicate(upper, lower):
+                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 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):
@@ -130,35 +158,21 @@ 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
-            case PredicateFactory() as factory:
-                return to_value(factory.predicate)
+                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)
-                return node
+                return add_node_left_right("xor", label="⊻", left=left, right=right)
             case _:
                 raise ValueError(f"Unknown predicate type {predicate}")
 
@@ -167,7 +181,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)
 
@@ -190,14 +204,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.3 → py_predicate-0.5}/predicate/formatter/format_json.py

@@ -1,21 +1,22 @@
 from typing import Any
 
+from predicate.all_predicate import AllPredicate
+from predicate.any_predicate import AnyPredicate
+from predicate.named_predicate import NamedPredicate
 from predicate.predicate import (
-    AllPredicate,
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
-    AnyPredicate,
     FnPredicate,
     IsFalsyPredicate,
     IsTruthyPredicate,
-    NamedPredicate,
     NePredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
     XorPredicate,
 )
+from predicate.tee_predicate import TeePredicate
 
 
 def to_json(predicate: Predicate) -> dict[str, Any]:
@@ -48,6 +49,8 @@ def to_json(predicate: Predicate) -> dict[str, Any]:
                 return "not", {"predicate": to_json(not_predicate)}
             case OrPredicate(left, right):
                 return "or", {"left": to_json(left), "right": to_json(right)}
+            case TeePredicate():
+                return "tee", None
             case XorPredicate(left, right):
                 return "xor", {"left": to_json(left), "right": to_json(right)}
             case _:

py_predicate-0.5/predicate/generator/__init__.py

@@ -0,0 +1,4 @@
+__all__ = [
+    "generate_false",
+    "generate_true",
+]