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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py_predicate
-Version: 0.4
+Version: 0.5
 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.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.4 → py_predicate-0.5}/predicate/__init__.py

@@ -17,14 +17,12 @@ from predicate.predicate import (
     FnPredicate,
     GePredicate,
     GtPredicate,
-    InPredicate,
     IsEmptyPredicate,
     IsNonePredicate,
     IsNotNonePredicate,
     LePredicate,
     LtPredicate,
     NePredicate,
-    NotInPredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
@@ -33,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,
@@ -47,7 +55,7 @@ from predicate.standard_predicates import (
     gt_le_p,
     gt_lt_p,
     gt_p,
-    in_p,
+    has_length_p,
     is_bool_p,
     is_callable_p,
     is_complex_p,
@@ -68,6 +76,7 @@ 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,
@@ -80,7 +89,6 @@ from predicate.standard_predicates import (
     lt_p,
     ne_p,
     neg_p,
-    not_in_p,
     pos_p,
     regex_p,
     root_p,
@@ -90,9 +98,9 @@ from predicate.standard_predicates import (
 )
 
 __all__ = [
+    "AllPredicate",
     "AlwaysFalsePredicate",
     "AlwaysTruePredicate",
-    "AllPredicate",
     "AndPredicate",
     "AnyPredicate",
     "EqPredicate",
@@ -120,7 +128,6 @@ __all__ = [
     "eq_false_p",
     "eq_p",
     "eq_true_p",
-    "is_falsy_p",
     "fn_p",
     "ge_le_p",
     "ge_lt_p",
@@ -130,33 +137,48 @@ __all__ = [
     "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_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_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_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 +196,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.4 → py_predicate-0.5}/predicate/all_predicate.py

@@ -10,11 +10,8 @@ class AllPredicate[T](Predicate[T]):
 
     predicate: Predicate[T]
 
-    def __call__(self, iter: Iterable[T]) -> bool:
-        return all(self.predicate(x) for x in iter)
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, AllPredicate) and self.predicate == other.predicate
+    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.4 → py_predicate-0.5}/predicate/any_predicate.py

@@ -10,11 +10,8 @@ class AnyPredicate[T](Predicate[T]):
 
     predicate: Predicate[T]
 
-    def __call__(self, iter: Iterable[T]) -> bool:
-        return any(self.predicate(x) for x in iter)
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, AnyPredicate) and self.predicate == other.predicate
+    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.4 → py_predicate-0.5}/predicate/formatter/format_dot.py

@@ -25,17 +25,23 @@ from predicate.predicate import (
 )
 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 (
     EqPredicate,
     FnPredicate,
     GePredicate,
     GtPredicate,
-    InPredicate,
     IsNonePredicate,
     LePredicate,
     LtPredicate,
     NePredicate,
-    NotInPredicate,
 )
 from predicate.tee_predicate import TeePredicate
 from predicate.this_predicate import ThisPredicate, find_this_predicate
@@ -61,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():
@@ -119,17 +131,24 @@ 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 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,22 +158,13 @@ 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():
@@ -162,12 +172,7 @@ def render(dot, predicate: Predicate, node_nr):
             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}")
 
@@ -176,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)
 
@@ -199,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.4 → py_predicate-0.5}/predicate/generator/generate_false.py

@@ -10,6 +10,7 @@ from more_itertools import random_combination_with_replacement, take
 from predicate.all_predicate import AllPredicate
 from predicate.generator.helpers import (
     generate_anys,
+    generate_ints,
     generate_strings,
     generate_uuids,
     random_anys,
@@ -24,15 +25,20 @@ from predicate.predicate import (
     AndPredicate,
     EqPredicate,
     GePredicate,
+    GtPredicate,
+    IsEmptyPredicate,
     IsFalsyPredicate,
     IsNonePredicate,
     IsNotNonePredicate,
     IsTruthyPredicate,
+    NePredicate,
     NotPredicate,
     OrPredicate,
     Predicate,
     always_true_p,
 )
+from predicate.set_of_predicate import SetOfPredicate
+from predicate.set_predicates import InPredicate
 
 
 @singledispatch
@@ -58,8 +64,8 @@ def generate_and(predicate: AndPredicate) -> Iterator:
     if optimize(predicate) == always_true_p:
         yield from []
     else:
-        yield from (item for item in generate_false(predicate.left) if not predicate.right(item))
-        yield from (item for item in generate_false(predicate.right) if not predicate.left(item))
+        yield from (item for item in generate_false(predicate.left))
+        yield from (item for item in generate_false(predicate.right))
 
 
 @generate_false.register
@@ -92,14 +98,51 @@ def generate_ge(predicate: GePredicate) -> Iterator:
             yield from generate_uuids(NotPredicate(predicate=predicate))
 
 
+@generate_false.register
+def generate_gt(predicate: GtPredicate) -> Iterator:
+    match predicate.v:
+        case datetime() as dt:
+            yield from (dt - timedelta(days=days) for days in range(0, 5))
+        case float():
+            yield from random_floats(upper=predicate.v)
+        case int():
+            yield from random_ints(upper=predicate.v)
+        case str():
+            yield from generate_strings(NotPredicate(predicate=predicate))
+        case uuid.UUID():
+            yield from generate_uuids(NotPredicate(predicate=predicate))
+
+
 @generate_false.register
 def generate_falsy(_predicate: IsFalsyPredicate) -> Iterator:
     yield from generate_anys(IsTruthyPredicate())
 
 
+@generate_false.register
+def generate_in(predicate: InPredicate) -> Iterator:
+    # TODO: combine with generate_not_in true
+    for item in predicate.v:
+        match item:
+            case int():
+                yield from generate_ints(NotPredicate(predicate=predicate))
+            case str():
+                yield from generate_strings(NotPredicate(predicate=predicate))
+
+
+@generate_false.register
+def generate_is_empty(_predicate: IsEmptyPredicate) -> Iterator:
+    # TODO: add generic helper function
+    yield from ([1], {1, 2, 3}, (1,), "aap")
+
+
+@generate_false.register
+def generate_ne(predicate: NePredicate) -> Iterator:
+    yield from predicate.v
+
+
 @generate_false.register
 def generate_none(_predicate: IsNonePredicate) -> Iterator:
-    yield generate_anys(IsNotNonePredicate())
+    yield from generate_anys(IsNotNonePredicate())
 
 
 @generate_false.register
@@ -122,3 +165,12 @@ def generate_is_instance_p(predicate: IsInstancePredicate) -> Iterator:
 def generate_or(predicate: OrPredicate) -> Iterator:
     yield from (item for item in generate_false(predicate.left) if not predicate.right(item))
     yield from (item for item in generate_false(predicate.right) if not predicate.left(item))
+
+
+@generate_false.register
+def generate_set_of_p(set_of_predicate: SetOfPredicate) -> Iterator:
+    predicate = set_of_predicate.predicate
+
+    values = take(10, generate_false(predicate))
+
+    yield set(random_combination_with_replacement(values, 5))

{py_predicate-0.4 → py_predicate-0.5}/predicate/generator/generate_true.py

@@ -4,15 +4,18 @@ import uuid
 from collections.abc import Iterator
 from datetime import datetime, timedelta
 from functools import singledispatch
+from itertools import cycle
 
 import exrex  # type: ignore
-from more_itertools import interleave, random_combination_with_replacement, take
+from more_itertools import interleave, powerset_of_sets, random_combination_with_replacement, take
 
 from predicate.any_predicate import AnyPredicate
 from predicate.generator.helpers import (
+    generate_anys,
     generate_ints,
     generate_strings,
     generate_uuids,
+    random_anys,
     random_complex_numbers,
     random_datetimes,
     random_dicts,
@@ -21,6 +24,7 @@ from predicate.generator.helpers import (
     random_strings,
     random_uuids,
 )
+from predicate.has_key_predicate import HasKeyPredicate
 from predicate.is_instance_predicate import IsInstancePredicate
 from predicate.optimizer.predicate_optimizer import optimize
 from predicate.predicate import (
@@ -30,7 +34,7 @@ from predicate.predicate import (
     EqPredicate,
     GePredicate,
     GtPredicate,
-    InPredicate,
+    IsEmptyPredicate,
     IsFalsyPredicate,
     IsNonePredicate,
     IsNotNonePredicate,
@@ -38,13 +42,15 @@ from predicate.predicate import (
     LePredicate,
     LtPredicate,
     NePredicate,
-    NotInPredicate,
     OrPredicate,
     Predicate,
     always_false_p,
 )
 from predicate.regex_predicate import RegexPredicate
+from predicate.set_of_predicate import SetOfPredicate
+from predicate.set_predicates import InPredicate, IsRealSubsetPredicate, IsSubsetPredicate, NotInPredicate
 from predicate.standard_predicates import AllPredicate
+from predicate.tuple_of_predicate import TupleOfPredicate
 
 
 @singledispatch
@@ -126,6 +132,13 @@ def generate_gt(predicate: GtPredicate) -> Iterator:
             yield from generate_uuids(predicate)
 
 
+@generate_true.register
+def generate_has_key(predicate: HasKeyPredicate) -> Iterator:
+    key = predicate.key
+    for random_dict, value in zip(random_dicts(), random_anys(), strict=False):
+        yield random_dict | {key: value}
+
+
 @generate_true.register
 def generate_le(predicate: LePredicate) -> Iterator:
     match predicate.v:
@@ -141,11 +154,26 @@ def generate_le(predicate: LePredicate) -> Iterator:
             yield from generate_uuids(predicate)
 
 
+@generate_true.register
+def generate_subset(predicate: IsSubsetPredicate) -> Iterator:
+    yield from powerset_of_sets(predicate.v)
+
+
+@generate_true.register
+def generate_real_subset(predicate: IsRealSubsetPredicate) -> Iterator:
+    yield from (v for v in powerset_of_sets(predicate.v) if v != predicate.v)
+
+
 @generate_true.register
 def generate_in(predicate: InPredicate) -> Iterator:
     yield from predicate.v
 
 
+@generate_true.register
+def generate_is_empty(_predicate: IsEmptyPredicate) -> Iterator:
+    yield from ([], {}, (), "", set())
+
+
 @generate_true.register
 def generate_lt(predicate: LtPredicate) -> Iterator:
     match predicate.v:
@@ -182,8 +210,8 @@ def generate_not_in(predicate: NotInPredicate) -> Iterator:
 
 
 @generate_true.register
-def generate_not_none(_predicate: IsNotNonePredicate) -> Iterator:
-    yield from ("foo", 3.14, 42)
+def generate_not_none(predicate: IsNotNonePredicate) -> Iterator:
+    yield from generate_anys(predicate)
 
 
 @generate_true.register
@@ -212,7 +240,7 @@ def generate_is_instance_p(predicate: IsInstancePredicate) -> Iterator:
     if klass is str:
         yield from random_strings()
     elif klass is bool:
-        yield from (False, True)
+        yield from cycle((False, True))
     elif klass is complex:
         yield from random_complex_numbers()
     elif klass == datetime:
@@ -239,3 +267,19 @@ def generate_any_p(any_predicate: AnyPredicate) -> Iterator:
     yield random_combination_with_replacement(values, 5)
 
     yield set(random_combination_with_replacement(values, 5))
+
+
+@generate_true.register
+def generate_tuple_of_p(tuple_of_predicate: TupleOfPredicate) -> Iterator:
+    predicates = tuple_of_predicate.predicates
+
+    yield from zip(*(generate_true(predicate) for predicate in predicates), strict=False)
+
+
+@generate_true.register
+def generate_set_of_p(set_of_predicate: SetOfPredicate) -> Iterator:
+    predicate = set_of_predicate.predicate
+
+    values = take(10, generate_true(predicate))
+
+    yield set(random_combination_with_replacement(values, 5))

{py_predicate-0.4 → py_predicate-0.5}/predicate/generator/helpers.py

@@ -47,18 +47,17 @@ def random_ints(lower: int = -sys.maxsize, upper: int = sys.maxsize) -> Iterator
     # yield lower
     # yield upper
     # TODO: maybe first generate_true some smaller ints
-    while True:
-        low = max(-1, lower)
-        high = min(1, upper)
-        if high >= low:
-            yield from (random.randint(low, high) for _ in range(0, 1))
 
-        low = max(-10, lower)
-        high = min(10, upper)
+    def between(limit: int) -> Iterator[int]:
+        low = max(-limit, lower)
+        high = min(limit, upper)
         if high >= low:
-            yield from (random.randint(low, high) for _ in range(0, 10))
+            yield from (random.randint(low, high) for _ in range(0, limit))
 
-        # yield random.randint(lower, upper)
+    while True:
+        yield from between(1)
+        yield from between(10)
+        yield from between(100)
 
 
 def random_uuids() -> Iterator[UUID]:

{py_predicate-0.4 → py_predicate-0.5}/predicate/has_key_predicate.py

@@ -1,11 +1,10 @@
 from dataclasses import dataclass
-from typing import Any
 
 from predicate.predicate import Predicate
 
 
 @dataclass
-class HasKeyPredicate[T](Predicate[dict[T, Any]]):
+class HasKeyPredicate[T](Predicate[T]):
     """A predicate class that models the has key."""
 
     key: T
@@ -13,8 +12,5 @@ class HasKeyPredicate[T](Predicate[dict[T, Any]]):
     def __call__(self, v: dict) -> bool:
         return self.key in v.keys()
 
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, HasKeyPredicate) and self.key == other.key
-
     def __repr__(self) -> str:
         return f'has_key_p("{self.key}")'