py-predicate 0.1__py3-none-any.whl

predicate/__init__.py

@@ -0,0 +1,63 @@
+"""The py-predicate module."""
+
+__version__ = "0.0.1"
+
+from predicate.optimizer.predicate_optimizer import can_optimize, optimize
+from predicate.predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AndPredicate,
+    AnyPredicate,
+    EqPredicate,
+    FnPredicate,
+    GePredicate,
+    GtPredicate,
+    InPredicate,
+    IsEmptyPredicate,
+    IsNonePredicate,
+    IsNotNonePredicate,
+    LePredicate,
+    LtPredicate,
+    NePredicate,
+    NotInPredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+    XorPredicate,
+    always_false_p,
+    always_true_p,
+)
+from predicate.standard_predicates import ge_p, gt_p, le_p, lt_p
+
+__all__ = [
+    "ge_p",
+    "gt_p",
+    "le_p",
+    "lt_p",
+    "can_optimize",
+    "optimize",
+    "always_true_p",
+    "AllPredicate",
+    "AndPredicate",
+    "AnyPredicate",
+    "InPredicate",
+    "FnPredicate",
+    "GePredicate",
+    "GtPredicate",
+    "IsEmptyPredicate",
+    "IsNonePredicate",
+    "IsNotNonePredicate",
+    "LePredicate",
+    "LtPredicate",
+    "NePredicate",
+    "NotInPredicate",
+    "XorPredicate",
+    "always_false_p",
+    "AlwaysTruePredicate",
+    "AlwaysFalsePredicate",
+    "EqPredicate",
+    "NotPredicate",
+    "OrPredicate",
+    "Predicate",
+]

predicate/formatter/format_dot.py

@@ -0,0 +1,138 @@
+from itertools import count
+
+import graphviz  # type: ignore
+
+from predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AndPredicate,
+    AnyPredicate,
+    EqPredicate,
+    FnPredicate,
+    GePredicate,
+    GtPredicate,
+    InPredicate,
+    LePredicate,
+    LtPredicate,
+    NePredicate,
+    NotInPredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+    XorPredicate,
+)
+from predicate.optimizer.predicate_optimizer import optimize
+
+
+def to_dot(predicate: Predicate, predicate_string: str = "", show_optimized: bool = False):
+    graph_attr = {"label": predicate_string, "labelloc": "t"}
+
+    node_attr = {"shape": "rectangle", "style": "filled", "fillcolor": "#B7D7A8"}
+
+    edge_attr: dict = {}
+
+    dot = graphviz.Digraph(graph_attr=graph_attr, node_attr=node_attr, edge_attr=edge_attr)
+
+    node_nr = count()
+
+    render_original(dot, predicate, node_nr)
+
+    if show_optimized:
+        render_optimized(dot, predicate, node_nr)
+
+    return dot
+
+
+def render(dot, predicate: Predicate, node_nr):
+    def add_node(name: str, *, label: str):
+        node = next(node_nr)
+        unique_name = f"{name}_{node}"
+        dot.node(unique_name, label=label)
+        return unique_name
+
+    def to_value(predicate: Predicate):
+        match predicate:
+            case AllPredicate(all_predicate):
+                node = add_node("all", label="∀")
+                child = to_value(all_predicate)
+                dot.edge(node, child)
+                return node
+            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
+            case AnyPredicate(any_predicate):
+                node = add_node("any", label="∃")
+                child = to_value(any_predicate)
+                dot.edge(node, child)
+                return node
+            case EqPredicate(v):
+                return add_node("eq", label=f"x = {v}")
+            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}")
+            case GtPredicate(v):
+                return add_node("gt", label=f"x > {v}")
+            case InPredicate(v):
+                items = ", ".join(str(item) for item in v)
+                return add_node("in", label=f"x ∈ {{{items}}}")
+            case LePredicate(v):
+                return add_node("le", label=f"x ≤ {v}")
+            case LtPredicate(v):
+                return add_node("lt", label=f"x < {v}")
+            case NotInPredicate(v):
+                items = ", ".join(str(item) for item in v)
+                return add_node("in", label=f"x ∉ {{{items}}}")
+            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
+            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 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
+            case _:
+                raise ValueError(f"Unknown predicate type {predicate}")
+
+    to_value(predicate)
+
+
+def render_original(dot, predicate: Predicate, node_nr):
+    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):
+    optimized_predicate = optimize(predicate)
+
+    with dot.subgraph(name="cluster_optimized") as optimized:
+        optimized.attr(style="filled", color="lightgrey")
+        optimized.attr(label="Optimized predicate")
+        render(optimized, optimized_predicate, node_nr)

predicate/formatter/format_json.py

@@ -0,0 +1,45 @@
+from typing import Any
+
+from predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AndPredicate,
+    AnyPredicate,
+    FnPredicate,
+    NePredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+    XorPredicate,
+)
+
+
+def to_json(predicate: Predicate) -> dict[str, Any]:
+    def to_value(predicate) -> tuple[str, Any]:
+        match predicate:
+            case AllPredicate(all_predicate):
+                return "all", {"predicate": to_json(all_predicate)}
+            case AlwaysFalsePredicate():
+                return "false", False
+            case AlwaysTruePredicate():
+                return "true", True
+            case AndPredicate(left, right):
+                return "and", {"left": to_json(left), "right": to_json(right)}
+            case AnyPredicate(any_predicate):
+                return "any", {"predicate": to_json(any_predicate)}
+            case FnPredicate(predicate_fn):
+                name = predicate_fn.__code__.co_name
+                return "fn", {"name": name}
+            case NePredicate(v):
+                return "ne", {"v": v}
+            case NotPredicate(not_predicate):
+                return "not", {"predicate": to_json(not_predicate)}
+            case OrPredicate(left, right):
+                return "or", {"left": to_json(left), "right": to_json(right)}
+            case XorPredicate(left, right):
+                return "xor", {"left": to_json(left), "right": to_json(right)}
+            case _:
+                return "unknown", {}
+
+    return dict([to_value(predicate)])

predicate/negate.py

@@ -0,0 +1,88 @@
+from functools import singledispatch
+
+from predicate import (
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    EqPredicate,
+    GePredicate,
+    GtPredicate,
+    InPredicate,
+    IsNonePredicate,
+    IsNotNonePredicate,
+    LePredicate,
+    LtPredicate,
+    NePredicate,
+    NotInPredicate,
+    NotPredicate,
+    Predicate,
+)
+
+
+@singledispatch
+def negate[T](predicate: Predicate[T]) -> Predicate[T]:
+    return NotPredicate(predicate=predicate)
+
+
+@negate.register
+def negate_is_not(predicate: NotPredicate) -> Predicate:
+    return predicate.predicate
+
+
+@negate.register
+def negate_is_false(_predicate: AlwaysFalsePredicate) -> Predicate:
+    return AlwaysTruePredicate()
+
+
+@negate.register
+def negate_is_true(_predicate: AlwaysTruePredicate) -> Predicate:
+    return AlwaysFalsePredicate()
+
+
+@negate.register
+def negate_eq(predicate: EqPredicate) -> Predicate:
+    return NePredicate(v=predicate.v)
+
+
+@negate.register
+def negate_ne(predicate: NePredicate) -> Predicate:
+    return EqPredicate(v=predicate.v)
+
+
+@negate.register
+def negate_gt(predicate: GtPredicate) -> Predicate:
+    return LePredicate(v=predicate.v)
+
+
+@negate.register
+def negate_ge(predicate: GePredicate) -> Predicate:
+    return LtPredicate(v=predicate.v)
+
+
+@negate.register
+def negate_in(predicate: InPredicate) -> Predicate:
+    return NotInPredicate(v=predicate.v)
+
+
+@negate.register
+def negate_not_in(predicate: NotInPredicate) -> Predicate:
+    return InPredicate(v=predicate.v)
+
+
+@negate.register
+def negate_lt(predicate: LtPredicate) -> Predicate:
+    return GePredicate(v=predicate.v)
+
+
+@negate.register
+def negate_le(predicate: LePredicate) -> Predicate:
+    return GtPredicate(v=predicate.v)
+
+
+@negate.register
+def negate_is_none(_predicate: IsNonePredicate) -> Predicate:
+    return IsNotNonePredicate()
+
+
+@negate.register
+def negate_is_not_none(_predicate: IsNotNonePredicate) -> Predicate:
+    return IsNonePredicate()

predicate/optimizer/all_optimizer.py

@@ -0,0 +1,31 @@
+from predicate.predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AnyPredicate,
+    IsEmptyPredicate,
+    IsNonePredicate,
+    IsNotNonePredicate,
+    NotPredicate,
+    Predicate,
+)
+
+
+def optimize_all_predicate[T](predicate: AllPredicate[T]) -> Predicate[T]:
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    optimized = optimize(predicate.predicate)
+
+    match optimized:
+        case AlwaysTruePredicate():
+            return AlwaysTruePredicate()
+        case AlwaysFalsePredicate():
+            return IsEmptyPredicate()
+        case NotPredicate(not_predicate):
+            return NotPredicate(predicate=AnyPredicate(predicate=not_predicate))
+        case IsNotNonePredicate():
+            return NotPredicate(predicate=AnyPredicate(predicate=IsNonePredicate()))
+        case _:
+            pass
+
+    return AllPredicate(predicate=optimized)

predicate/optimizer/and_optimizer.py

@@ -0,0 +1,121 @@
+from predicate.predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AndPredicate,
+    EqPredicate,
+    FnPredicate,
+    GePredicate,
+    InPredicate,
+    NePredicate,
+    NotInPredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+)
+
+
+def optimize_and_predicate[T](predicate: AndPredicate[T]) -> Predicate[T]:
+    from predicate.negate import negate
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    match left := predicate.left, right := predicate.right:
+        case OrPredicate(or_left, or_right), _:
+            match or_left, or_right:
+                case NotPredicate(not_predicate), _ if not_predicate == right:  # (~p | q) & p == q & p
+                    return AndPredicate(left=or_right, right=right)
+                case _, NotPredicate(not_predicate) if not_predicate == right:  # (q | ~p) & p == q & p
+                    return AndPredicate(left=or_left, right=right)
+
+        case _, OrPredicate():
+            return optimize_and_predicate(AndPredicate(left=right, right=left))
+
+        case _, _ if left == negate(right):
+            return AlwaysFalsePredicate()  # p & ~p == False
+
+    match left := optimize(left), right := optimize(right):
+        case _, AlwaysFalsePredicate():  # p & False = False
+            return AlwaysFalsePredicate()
+        case AlwaysFalsePredicate(), _:  # False & p = False
+            return AlwaysFalsePredicate()
+        case _, AlwaysTruePredicate():  # p & True == p
+            return optimize(left)
+        case AlwaysTruePredicate(), _:  # True & p == p
+            return optimize(right)
+
+        case EqPredicate(v1), EqPredicate(v2) if v1 == v2:
+            # x = v1 & x = v2 & v1 == v2 => x = v1
+            return left
+        case EqPredicate(v1), EqPredicate(v2) if v1 != v2:
+            # x = v1 & x = v2 & v1 != v2 => False
+            return AlwaysFalsePredicate()
+        case EqPredicate(v1), GePredicate(v2) if v1 == v2:
+            # x = v1 & x >= v2 & v1 = v2 => x = v1
+            return left
+        case EqPredicate(v1), GePredicate(v2) if v1 < v2:
+            # x = v1 & x >= v2 & v1 < v2 => False
+            return AlwaysFalsePredicate()
+        case GePredicate(v1), GePredicate(v2):
+            # x >= v1 & x >= v2 => x >= max(v1, v2)
+            return GePredicate(v=max(v1, v2))
+
+        case FnPredicate(predicate_fn), EqPredicate(v):
+            return AlwaysTruePredicate() if predicate_fn(v) else AlwaysFalsePredicate()
+
+        case InPredicate(v1), InPredicate(v2):
+            v = v1 & v2
+            if not v:
+                return AlwaysFalsePredicate()
+            if len(v) == 1:
+                return EqPredicate(v=v.pop())
+            return InPredicate(v=v)
+
+        case InPredicate(v1), NotInPredicate(v2):
+            v = v1 - v2
+            if not v:
+                return AlwaysFalsePredicate()
+            if len(v) == 1:
+                return EqPredicate(v=v.pop())
+            return InPredicate(v=v)
+
+        case NotInPredicate(v1), NotInPredicate(v2):
+            v = v1 | v2
+            if not v:
+                return AlwaysTruePredicate()
+            if len(v) == 1:
+                return NePredicate(v=v.pop())
+            return NotInPredicate(v=v)
+
+        case AllPredicate(left_all), AllPredicate(right_all):
+            # All(p1) & All(p2) => All(p1 & p2)
+            return optimize(AllPredicate(predicate=optimize(AndPredicate(left=left_all, right=right_all))))
+
+        case _, _ if and_contains_negate(predicate, right):
+            return AlwaysFalsePredicate()  # p & q & ... & ~p == False
+
+        case _, _ if and_contains_negate(predicate, left):
+            return AlwaysFalsePredicate()  # q & p & ... & ~p == False
+
+        case _, _ if left == negate(right):
+            return AlwaysFalsePredicate()  # p & ~p == False
+
+        case _, _ if left == right:  # p & p == p
+            return left
+
+        case _:
+            # return AndPredicate(left=left, right=right)
+            return predicate
+
+
+def and_contains_negate(predicate: AndPredicate, sub_predicate: Predicate) -> bool:
+    from predicate.negate import negate
+
+    match left := predicate.left, right := predicate.right:
+        case AndPredicate() as and_left, _:
+            return and_contains_negate(and_left, sub_predicate)
+        case _, AndPredicate() as and_right:
+            return and_contains_negate(and_right, sub_predicate)
+        case AndPredicate() as and_left, AndPredicate() as and_right:
+            return and_contains_negate(and_left, sub_predicate) or and_contains_negate(and_right, sub_predicate)
+        case _:
+            return negate(sub_predicate) in (left, right)

predicate/optimizer/any_optimizer.py

@@ -0,0 +1,30 @@
+from predicate.predicate import (
+    AllPredicate,
+    AlwaysFalsePredicate,
+    AlwaysTruePredicate,
+    AnyPredicate,
+    EqPredicate,
+    NePredicate,
+    NotPredicate,
+    Predicate,
+)
+
+
+def optimize_any_predicate[T](predicate: AnyPredicate[T]) -> Predicate[T]:
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    optimized = optimize(predicate.predicate)
+
+    match optimized:
+        case AlwaysTruePredicate():
+            return AlwaysTruePredicate()
+        case AlwaysFalsePredicate():
+            return AlwaysFalsePredicate()
+        case NePredicate(v):
+            return NotPredicate(predicate=AllPredicate(predicate=EqPredicate(v)))
+        case NotPredicate(not_predicate):
+            return NotPredicate(predicate=AllPredicate(predicate=optimize(not_predicate)))
+        case _:
+            pass
+
+    return AnyPredicate(predicate=optimized)

predicate/optimizer/not_optimizer.py

@@ -0,0 +1,57 @@
+from predicate.predicate import (
+    AllPredicate,
+    AndPredicate,
+    AnyPredicate,
+    NotPredicate,
+    OrPredicate,
+    Predicate,
+    XorPredicate,
+)
+
+
+def optimize_not_predicate[T](predicate: NotPredicate[T]) -> Predicate[T]:
+    from predicate.negate import negate
+    from predicate.optimizer.predicate_optimizer import optimize
+
+    # ~~p == p
+    match predicate.predicate:
+        case NotPredicate(not_predicate):
+            return optimize(not_predicate)
+
+    optimized = optimize(predicate.predicate)
+
+    match optimized:
+        case AllPredicate(all_predicate):
+            match negate(all_predicate):
+                case _ as inverted:
+                    return AnyPredicate(predicate=inverted)
+
+        case AndPredicate(left, right):
+            match left, right:
+                case _, NotPredicate(not_predicate):
+                    return OrPredicate(left=negate(left), right=not_predicate)  # ~(p & ~q) => ~p | q
+                case NotPredicate(not_predicate), _:
+                    return OrPredicate(left=not_predicate, right=negate(right))  # ~(~p & q) => p | ~q
+
+        case AnyPredicate(any_predicate):
+            match negate(any_predicate):
+                case _ as inverted:
+                    return AllPredicate(predicate=inverted)
+
+        case OrPredicate(left, right):
+            match left, right:
+                case _, NotPredicate(not_predicate):
+                    return AndPredicate(left=negate(left), right=not_predicate)  # ~(p | ~q) => ~p & q
+                case NotPredicate(not_predicate), _:
+                    return AndPredicate(left=not_predicate, right=negate(right))  # ~(~p | q) => p & ~q
+
+        case XorPredicate(left, right):
+            match left, right:
+                case NotPredicate(not_predicate), _:  # ~(~p ^ q) == p ^ q
+                    return XorPredicate(left=not_predicate, right=right)
+                case _, NotPredicate(not_predicate):  # ~(p ^ ~q) == p ^ q
+                    return XorPredicate(left=left, right=not_predicate)
+                case _:  # ~(p ^ q) == ~p ^ q
+                    return XorPredicate(left=NotPredicate(predicate=left), right=right)
+
+    return negate(optimized)