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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.1
+Version: 0.3
 Summary: Module to create composable predicates
 Author-email: Maurits Rijk <maurits.rijk@gmail.com>
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Developers
@@ -15,14 +15,16 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Web Environment
 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: graphviz
+Requires-Dist: lark
 Requires-Dist: more-itertools
+Requires-Dist: typer
 Requires-Dist: bumpversion ; extra == "dev"
 Requires-Dist: jsonschema ; extra == "dev"
 Requires-Dist: pre-commit ; extra == "dev"
@@ -32,6 +34,7 @@ Requires-Dist: mypy_extensions ; extra == "test"
 Requires-Dist: pytest ; extra == "test"
 Requires-Dist: pytest-cov ; extra == "test"
 Requires-Dist: ruff ; extra == "test"
+Project-URL: Documentation, https://mrijk.github.io/py-predicate/
 Project-URL: Source, https://github.com/mrijk/py-predicate
 Provides-Extra: dev
 Provides-Extra: test
@@ -42,23 +45,54 @@ Provides-Extra: test
 
 # Introduction
 
-py-predicate is a Python library to create composable predicates
+py-predicate is a typed Python library to create composable predicates.
 
-# Example
+# Getting started
+
+To get started, install the library with [pip](https://pip.pypa.io/en/stable/)
+
+```
+pip install py-predicate
+```
+
+The full documentation can be found [here](https://mrijk.github.io/py-predicate/). We give 2 small examples
+to show what the library can do.
+
+# Example 1
 
 ```python
-    filtered = [x for x in range(10) if x >= 2 and x <= 3]
+filtered = [x for x in range(10) if x >= 2 and x <= 3]
 ```
 
-Version with predicates:
+## Version with predicates:
 
 ```python
-    ge_2 = ge_p(2)
-    le_3 = le_p(3)
+from predicate import ge_p, le_p
 
-    between_2_and_3 = ge_2 & le_3
-    filtered = [x for x in range(10) if between_2_and_3(x)]
+ge_2 = ge_p(2)
+le_3 = le_p(3)
+
+between_2_and_3 = ge_2 & le_3
+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
+reusable predicates that can be used in multiple locations.
+
+# Example 2
+
+A unique (?) py-predicate feature is that you can define self referencing predicates.
+This makes it easy to apply predicates to arbitrarily nested structures, like JSON data.
+
+In the next example we define a predicate, that tests if a given data structure is
+either a string, or a list of data that can again either be a string or a list of
+data. Ad infinitum.
+
+```python
+from predicate import all_p, is_list_p, is_str_p, lazy_p
+
+str_or_list_of_str = is_str_p | (is_list_p & all_p(lazy_p("str_or_list_of_str")))
+```
+
+Using plain Python, the above one-liner would have to be coded as a (recursive) function.
+

py_predicate-0.3/README.md

@@ -0,0 +1,56 @@
+![Documentation](https://github.com/mrijk/py-predicate/actions/workflows/pages.yaml/badge.svg)
+![Test](https://github.com/mrijk/py-predicate/actions/workflows/test.yaml/badge.svg)
+[![codecov](https://codecov.io/gh/mrijk/py-predicate/graph/badge.svg?token=KMBDJNC3W9)](https://codecov.io/gh/mrijk/py-predicate)
+
+# Introduction
+
+py-predicate is a typed Python library to create composable predicates.
+
+# Getting started
+
+To get started, install the library with [pip](https://pip.pypa.io/en/stable/)
+
+```
+pip install py-predicate
+```
+
+The full documentation can be found [here](https://mrijk.github.io/py-predicate/). We give 2 small examples
+to show what the library can do.
+
+# Example 1
+
+```python
+filtered = [x for x in range(10) if x >= 2 and x <= 3]
+```
+
+## Version with predicates:
+
+```python
+from predicate import ge_p, le_p
+
+ge_2 = ge_p(2)
+le_3 = le_p(3)
+
+between_2_and_3 = ge_2 & le_3
+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.
+
+# Example 2
+
+A unique (?) py-predicate feature is that you can define self referencing predicates.
+This makes it easy to apply predicates to arbitrarily nested structures, like JSON data.
+
+In the next example we define a predicate, that tests if a given data structure is
+either a string, or a list of data that can again either be a string or a list of
+data. Ad infinitum.
+
+```python
+from predicate import all_p, is_list_p, is_str_p, lazy_p
+
+str_or_list_of_str = is_str_p | (is_list_p & all_p(lazy_p("str_or_list_of_str")))
+```
+
+Using plain Python, the above one-liner would have to be coded as a (recursive) function.

py_predicate-0.3/predicate/__init__.py

@@ -0,0 +1,148 @@
+"""The py-predicate module."""
+
+__version__ = "0.0.1"
+
+from predicate.formatter.format_dot import to_dot
+from predicate.formatter.format_json import to_json
+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,
+    XorPredicate,
+    always_false_p,
+    always_true_p,
+    is_empty_p,
+)
+from predicate.standard_predicates import (
+    all_p,
+    any_p,
+    comp_p,
+    eq_false_p,
+    eq_p,
+    eq_true_p,
+    fn_p,
+    ge_p,
+    gt_p,
+    in_p,
+    is_bool_p,
+    is_callable_p,
+    is_complex_p,
+    is_datetime_p,
+    is_dict_p,
+    is_falsy_p,
+    is_float_p,
+    is_instance_p,
+    is_int_p,
+    is_iterable_of_p,
+    is_iterable_p,
+    is_list_of_p,
+    is_list_p,
+    is_none_p,
+    is_not_none_p,
+    is_predicate_p,
+    is_set_of_p,
+    is_set_p,
+    is_str_p,
+    is_tuple_of_p,
+    is_tuple_p,
+    is_uuid_p,
+    lazy_p,
+    le_p,
+    lt_p,
+    ne_p,
+    not_in_p,
+    regex_p,
+    root_p,
+    this_p,
+)
+
+__all__ = [
+    "AllPredicate",
+    "AlwaysFalsePredicate",
+    "AlwaysTruePredicate",
+    "AndPredicate",
+    "AnyPredicate",
+    "EqPredicate",
+    "FnPredicate",
+    "GePredicate",
+    "GtPredicate",
+    "InPredicate",
+    "IsEmptyPredicate",
+    "IsInstancePredicate",
+    "IsNonePredicate",
+    "IsNotNonePredicate",
+    "LePredicate",
+    "LtPredicate",
+    "NePredicate",
+    "NotInPredicate",
+    "NotPredicate",
+    "OrPredicate",
+    "Predicate",
+    "XorPredicate",
+    "all_p",
+    "always_false_p",
+    "always_true_p",
+    "any_p",
+    "can_optimize",
+    "comp_p",
+    "eq_false_p",
+    "eq_p",
+    "eq_true_p",
+    "is_falsy_p",
+    "fn_p",
+    "ge_p",
+    "gt_p",
+    "in_p",
+    "is_bool_p",
+    "is_callable_p",
+    "is_complex_p",
+    "is_datetime_p",
+    "is_dict_p",
+    "is_empty_p",
+    "is_float_p",
+    "is_instance_p",
+    "is_int_p",
+    "is_iterable_p",
+    "is_iterable_of_p",
+    "is_list_p",
+    "is_list_of_p",
+    "is_none_p",
+    "is_not_none_p",
+    "is_predicate_p",
+    "is_set_p",
+    "is_set_of_p",
+    "is_str_p",
+    "is_tuple_p",
+    "is_tuple_of_p",
+    "is_uuid_p",
+    "lazy_p",
+    "le_p",
+    "lt_p",
+    "ne_p",
+    "not_in_p",
+    "optimize",
+    "regex_p",
+    "root_p",
+    "this_p",
+    "to_dot",
+    "to_json",
+]

py_predicate-0.3/predicate/comp_predicate.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import Callable
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class CompPredicate[S, T](Predicate[T]):
+    """A predicate class that transforms the input according to a function and then evaluates the predicate."""
+
+    fn: Callable[[S], T]
+    predicate: Predicate[T]
+
+    def __call__(self, x: S) -> bool:
+        return self.predicate(self.fn(x))
+
+    def __repr__(self) -> str:
+        return f"comp_p({repr(self.predicate)})"

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

@@ -1,31 +1,47 @@
+import inspect
+from functools import partial
 from itertools import count
 
 import graphviz  # type: ignore
+from more_itertools import first
 
-from predicate import (
-    AllPredicate,
+from predicate.comp_predicate import CompPredicate
+from predicate.lazy_predicate import LazyPredicate, find_predicate_by_ref
+from predicate.optimizer.predicate_optimizer import optimize
+from predicate.predicate import (
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
+    IsFalsyPredicate,
+    IsTruthyPredicate,
+    NamedPredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+    XorPredicate,
+)
+from predicate.root_predicate import RootPredicate, find_root_predicate
+from predicate.standard_predicates import (
+    AllPredicate,
     AnyPredicate,
     EqPredicate,
     FnPredicate,
     GePredicate,
     GtPredicate,
     InPredicate,
+    IsInstancePredicate,
+    IsNonePredicate,
     LePredicate,
     LtPredicate,
     NePredicate,
     NotInPredicate,
-    NotPredicate,
-    OrPredicate,
-    Predicate,
-    XorPredicate,
+    PredicateFactory,
 )
-from predicate.optimizer.predicate_optimizer import optimize
+from predicate.this_predicate import ThisPredicate, find_this_predicate
 
 
 def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: bool = False):
+    """Format predicate as a .dot file."""
     graph_attr = {"label": predicate_string, "labelloc": "t"}
 
     node_attr = {"shape": "rectangle", "style": "filled", "fillcolor": "#B7D7A8"}
@@ -45,13 +61,18 @@ def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: boo
 
 
 def render(dot, predicate: Predicate, node_nr):
-    def add_node(name: str, *, label: str):
+    node_predicate_mapping: dict[str, Predicate] = {}
+
+    def _add_node(name: str, *, label: str, predicate: Predicate):
         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 to_value(predicate: Predicate):
+        add_node = partial(_add_node, predicate=predicate)
+
         match predicate:
             case AllPredicate(all_predicate):
                 node = add_node("all", label="∀")
@@ -74,12 +95,19 @@ def render(dot, predicate: Predicate, node_nr):
                 child = to_value(any_predicate)
                 dot.edge(node, child)
                 return node
+            case CompPredicate(_fn, comp_predicate):
+                node = add_node("comp", label="f")
+                child = to_value(comp_predicate)
+                dot.edge(node, child)
+                return node
             case EqPredicate(v):
                 return add_node("eq", label=f"x = {v}")
+            case IsFalsyPredicate():
+                return add_node("falsy", label="falsy")
+            case IsTruthyPredicate():
+                return add_node("truthy", label="truthy")
             case FnPredicate(predicate_fn):
                 name = predicate_fn.__code__.co_name
-                # code = inspect.getsource(predicate_fn)
-                # m = re.match(r".*\(predicate_fn=(.*)\)", code)
                 return add_node("fn", label=f"fn: {name}")
             case GePredicate(v):
                 return add_node("ge", label=f"x ≥ {v}")
@@ -88,10 +116,19 @@ def render(dot, predicate: Predicate, node_nr):
             case InPredicate(v):
                 items = ", ".join(str(item) for item in v)
                 return add_node("in", label=f"x ∈ {{{items}}}")
+            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 LazyPredicate(ref):
+                return add_node("lazy", label=ref)
             case LePredicate(v):
                 return add_node("le", label=f"x ≤ {v}")
             case LtPredicate(v):
                 return add_node("lt", label=f"x < {v}")
+            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}}}")
@@ -109,6 +146,12 @@ def render(dot, predicate: Predicate, node_nr):
                 dot.edge(node, left_node)
                 dot.edge(node, right_node)
                 return node
+            case PredicateFactory() as factory:
+                return to_value(factory.predicate)
+            case RootPredicate():
+                return add_node("root", label="root")
+            case ThisPredicate():
+                return add_node("this", label="this")
             case XorPredicate(left, right):
                 node = add_node("xor", label="⊻")
                 left_node = to_value(left)
@@ -121,6 +164,31 @@ def render(dot, predicate: Predicate, node_nr):
 
     to_value(predicate)
 
+    render_lazy_references(dot, node_predicate_mapping)
+
+
+def render_lazy_references(dot, node_predicate_mapping):
+    def find_in_mapping(lookup: Predicate) -> str:
+        return first(node for node, predicate in node_predicate_mapping.items() if predicate == lookup)
+
+    def add_dashed_line(node: str, lookup: Predicate) -> None:
+        found = find_in_mapping(lookup)
+        dot.edge(node, found, style="dashed")
+
+    frame = inspect.currentframe()
+
+    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)
+
 
 def render_original(dot, predicate: Predicate, node_nr):
     with dot.subgraph(name="cluster_original") as original:

{py_predicate-0.1 → py_predicate-0.3}/predicate/formatter/format_json.py

@@ -1,12 +1,15 @@
 from typing import Any
 
-from predicate import (
+from predicate.predicate import (
     AllPredicate,
     AlwaysFalsePredicate,
     AlwaysTruePredicate,
     AndPredicate,
     AnyPredicate,
     FnPredicate,
+    IsFalsyPredicate,
+    IsTruthyPredicate,
+    NamedPredicate,
     NePredicate,
     NotPredicate,
     OrPredicate,
@@ -16,6 +19,8 @@ from predicate import (
 
 
 def to_json(predicate: Predicate) -> dict[str, Any]:
+    """Format predicate as json."""
+
     def to_value(predicate) -> tuple[str, Any]:
         match predicate:
             case AllPredicate(all_predicate):
@@ -31,6 +36,12 @@ def to_json(predicate: Predicate) -> dict[str, Any]:
             case FnPredicate(predicate_fn):
                 name = predicate_fn.__code__.co_name
                 return "fn", {"name": name}
+            case IsFalsyPredicate():
+                return "is_falsy", None
+            case NamedPredicate(name):
+                return "variable", name
+            case IsTruthyPredicate():
+                return "is_truthy", None
             case NePredicate(v):
                 return "ne", {"v": v}
             case NotPredicate(not_predicate):

py_predicate-0.3/predicate/implies.py

@@ -0,0 +1,53 @@
+from functools import singledispatch
+
+from predicate.predicate import (
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    EqPredicate,
+    GePredicate,
+    GtPredicate,
+    InPredicate,
+    Predicate,
+)
+
+
+@singledispatch
+def implies(predicate: Predicate, other: Predicate) -> bool:
+    """Return True if predicate implies another predicate, otherwise False."""
+    return False
+
+
+@implies.register
+def implies_false(_predicate: AlwaysFalsePredicate, _other: Predicate) -> bool:
+    return True
+
+
+@implies.register
+def implies_true(_predicate: AlwaysTruePredicate, other: Predicate) -> bool:
+    return other == AlwaysTruePredicate()
+
+
+@implies.register
+def _(predicate: GePredicate, other: Predicate) -> bool:
+    match other:
+        case GePredicate(v):
+            return predicate.v >= v
+        case GtPredicate(v):
+            return predicate.v > v
+        case _:
+            return False
+
+
+@implies.register
+def _(predicate: EqPredicate, other: Predicate) -> bool:
+    match other:
+        case EqPredicate(v):
+            return predicate.v == v
+        case GePredicate(v):
+            return predicate.v >= v
+        case GtPredicate(v):
+            return predicate.v > v
+        case InPredicate(v):
+            return predicate.v in v
+        case _:
+            return False

py_predicate-0.3/predicate/lazy_predicate.py

@@ -0,0 +1,34 @@
+import inspect
+from dataclasses import dataclass
+from functools import cached_property
+
+from predicate.predicate import Predicate
+
+
+@dataclass
+class LazyPredicate[T](Predicate[T]):
+    """A predicate class that lazily references another predicate by name."""
+
+    ref: str
+
+    @cached_property
+    def predicate(self) -> Predicate | None:
+        return find_predicate_by_ref(self.frame, self.ref)
+
+    def __call__(self, x: T) -> bool:
+        self.frame = inspect.currentframe()
+        if self.predicate:
+            return self.predicate(x)
+        raise ValueError(f"Could not find predicate with reference {self.ref}")
+
+    def __repr__(self) -> str:
+        return f'lazy_p("{self.ref}")'
+
+
+def find_predicate_by_ref(frame, ref: str) -> Predicate | None:
+    for key, value in frame.f_locals.items():
+        if key == ref:
+            return value
+    if next_frame := frame.f_back:
+        return find_predicate_by_ref(next_frame, ref)
+    return None

{py_predicate-0.1 → py_predicate-0.3}/predicate/negate.py

@@ -7,6 +7,7 @@ from predicate import (
     GePredicate,
     GtPredicate,
     InPredicate,
+    IsEmptyPredicate,
     IsNonePredicate,
     IsNotNonePredicate,
     LePredicate,
@@ -15,11 +16,19 @@ from predicate import (
     NotInPredicate,
     NotPredicate,
     Predicate,
+    always_false_p,
+    always_true_p,
+    is_empty_p,
+    is_none_p,
+    is_not_none_p,
 )
+from predicate.predicate import IsFalsyPredicate, IsNotEmptyPredicate, IsTruthyPredicate, is_not_empty_p
+from predicate.standard_predicates import is_falsy_p, is_truthy_p
 
 
 @singledispatch
 def negate[T](predicate: Predicate[T]) -> Predicate[T]:
+    """Return the negation of a predicate."""
     return NotPredicate(predicate=predicate)
 
 
@@ -30,12 +39,22 @@ def negate_is_not(predicate: NotPredicate) -> Predicate:
 
 @negate.register
 def negate_is_false(_predicate: AlwaysFalsePredicate) -> Predicate:
-    return AlwaysTruePredicate()
+    return always_true_p
 
 
 @negate.register
 def negate_is_true(_predicate: AlwaysTruePredicate) -> Predicate:
-    return AlwaysFalsePredicate()
+    return always_false_p
+
+
+@negate.register
+def negate_is_falsy(_predicate: IsFalsyPredicate) -> Predicate:
+    return is_truthy_p
+
+
+@negate.register
+def negate_is_truthy(_predicate: IsTruthyPredicate) -> Predicate:
+    return is_falsy_p
 
 
 @negate.register
@@ -80,9 +99,19 @@ def negate_le(predicate: LePredicate) -> Predicate:
 
 @negate.register
 def negate_is_none(_predicate: IsNonePredicate) -> Predicate:
-    return IsNotNonePredicate()
+    return is_not_none_p
 
 
 @negate.register
 def negate_is_not_none(_predicate: IsNotNonePredicate) -> Predicate:
-    return IsNonePredicate()
+    return is_none_p
+
+
+@negate.register
+def negate_is_empty(_predicate: IsEmptyPredicate) -> Predicate:
+    return is_not_empty_p
+
+
+@negate.register
+def negate_is_not_empty(_predicate: IsNotEmptyPredicate) -> Predicate:
+    return is_empty_p