!squash extract

Author: tony

libvcs/utils/list_query.py

@@ -1,7 +1,7 @@
 import dataclasses
 import re
 import traceback
-from typing import Any, Callable, Generic, Optional, Sequence, TypeVar, Union
+from typing import Any, Callable, Generic, Optional, Protocol, Sequence, TypeVar, Union
 
 T = TypeVar("T", Any, Any)
 
@@ -45,6 +45,80 @@ def parse_lookup(obj, path, lookup):
     return None
 
 
+class LookupProtocol(Protocol):
+    def __call__(self, data: Union[list[str], str], rhs: Union[list[str], str]):
+        pass
+
+
+def lookup_exact(data, rhs):
+    return rhs == data
+
+
+def lookup_iexact(data, rhs):
+    return rhs.lower() == data.lower()
+
+
+def lookup_contains(data, rhs):
+    return rhs in data
+
+
+def lookup_icontains(data, rhs):
+    return rhs.lower() in data.lower()
+
+
+def lookup_startswith(data, rhs):
+    return data.startswith(rhs)
+
+
+def lookup_istartswith(data, rhs):
+    return data.lower().startswith(rhs.lower())
+
+
+def lookup_endswith(data, rhs):
+    return data.endswith(rhs)
+
+
+def lookup_iendswith(data, rhs):
+    return data.lower().endswith(rhs.lower())
+
+
+def lookup_in(data, rhs):
+    if isinstance(rhs, list):
+        return data in rhs
+    return rhs in data
+
+
+def lookup_nin(data, rhs):
+    if isinstance(rhs, list):
+        return data not in rhs
+    return rhs not in data
+
+
+def lookup_regex(data, rhs):
+    return re.search(rhs, data)
+
+
+def lookup_iregex(data, rhs):
+    return re.search(rhs, data, re.IGNORECASE)
+
+
+LOOKUP_NAME_MAP: dict[str, LookupProtocol] = {
+    "eq": lookup_exact,
+    "exact": lookup_exact,
+    "iexact": lookup_iexact,
+    "contains": lookup_contains,
+    "icontains": lookup_icontains,
+    "startswith": lookup_startswith,
+    "istartswith": lookup_istartswith,
+    "endswith": lookup_endswith,
+    "iendswith": lookup_iendswith,
+    "in": lookup_in,
+    "nin": lookup_nin,
+    "regex": lookup_regex,
+    "iregex": lookup_iregex,
+}
+
+
 @dataclasses.dataclass(eq=False)
 class ListQuery(Generic[T]):
     """Filter a list of dicts. *Experimental and unstable*.
@@ -119,93 +193,25 @@ def __eq__(self, other):
             return True
         return False
 
-    def lookup_exact(self, data, rhs):
-        return rhs == data
-
-    def lookup_iexact(self, data, rhs):
-        return rhs.lower() == data.lower()
-
-    def lookup_contains(self, data, rhs):
-        return rhs in data
-
-    def lookup_icontains(self, data, rhs):
-        return rhs.lower() in data.lower()
-
-    LOOKUP_NAME_MAP = {
-        "contains": lookup_contains,
-        "icontains": lookup_icontains,
-        "exact": lookup_exact,
-        "iexact": lookup_iexact,
-    }
-
     def filter(self, matcher: Optional[Union[Callable[[T], bool], T]] = None, **kwargs):
         def filter_lookup(obj) -> bool:
 
             for path, v in kwargs.items():
                 try:
                     lhs, op = path.rsplit("__", 1)
+
+                    if op not in LOOKUP_NAME_MAP:
+                        raise ValueError(f"{op} not in LOOKUP_NAME_MAP")
                 except ValueError:
                     lhs = path
                     op = "exact"
 
-                # assert op in self.LOOKUP_NAME_MAP
-                # path = lhs
+                assert op in LOOKUP_NAME_MAP
+                path = lhs
+                data = keygetter(obj, path)
 
-                if (field := parse_lookup(obj, path, "__contains")) is not None:
-                    if v not in field:
-                        return False
-                elif (field := parse_lookup(obj, path, "__icontains")) is not None:
-                    if v.lower() not in field.lower():
-                        return False
-                elif (field := parse_lookup(obj, path, "__in")) is not None:
-                    if isinstance(v, list):
-                        if field not in v:
-                            return False
-                    else:
-                        if v not in field:
-                            return False
-                elif (field := parse_lookup(obj, path, "__nin")) is not None:
-                    if isinstance(v, list):
-                        if field in v:
-                            return False
-                    else:
-                        if v in field:
-                            return False
-                elif (field := parse_lookup(obj, path, "__startswith")) is not None:
-                    if not field.startswith(v):
-                        return False
-                elif (field := parse_lookup(obj, path, "__istartswith")) is not None:
-                    if not field.lower().startswith(v.lower()):
-                        return False
-                elif (field := parse_lookup(obj, path, "__endswith")) is not None:
-                    if not field.endswith(v):
-                        return False
-                elif (field := parse_lookup(obj, path, "__iendswith")) is not None:
-                    if not field.lower().endswith(v.lower()):
-                        return False
-                elif (field := parse_lookup(obj, path, "__regex")) is not None:
-                    if not re.search(v, field):
-                        return False
-                elif (field := parse_lookup(obj, path, "__iregex")) is not None:
-                    if not re.search(v, field, re.IGNORECASE):
-                        return False
-                elif (field := parse_lookup(obj, path, "__iexact")) is not None:
-                    if field.lower() != v.lower():
-                        return False
-                elif (
-                    field := parse_lookup(obj, path, "__exact")
-                ) is not None:  # same as else
-                    if field != v:
-                        return False
-                elif (
-                    field := parse_lookup(obj, path, "__eq")
-                ) is not None:  # same as else
-                    if field != v:
-                        return False
-                else:
-                    if (field := keygetter(obj, path)) is not None:  # same as else
-                        if field != v:
-                            return False
+                if not LOOKUP_NAME_MAP[op](data, v):
+                    return False
 
             return True