New filtering syntax using a more natural python style

Author: jeandet

tests/test_filtering.py

@@ -9,6 +9,8 @@
 from tscat.filtering import Predicate, Comparison, Field, Attribute, Has, Match, Not, All, Any, In, UUID, \
     InCatalogue, PredicateRecursionError, CatalogueFilterError
 
+from tscat import filtering
+
 import datetime as dt
 
 dates = [
@@ -38,7 +40,10 @@ class TestFilterRepr(unittest.TestCase):
          "All(Comparison('<=', Field('fieldName'), 'value'), Match(Field('fieldName'), '^mat[ch]{2}\\\\n$'))"),
         (In("Value", Field("FieldName")), "In('Value', Field('FieldName'))"),
         (InCatalogue(create_catalogue('Name', 'Author', uuid='957d65ae-f278-48f5-aab1-8cf50efeadef')),
-         "InCatalogue(Catalogue(name=Name, author=Author, uuid=957d65ae-f278-48f5-aab1-8cf50efeadef, tags=[], predicate=None) attributes())")
+         "InCatalogue(Catalogue(name=Name, author=Author, uuid=957d65ae-f278-48f5-aab1-8cf50efeadef, tags=[], predicate=None) attributes())"),
+        (filtering.catalogue.some_field == 'value', "Comparison('==', Attribute('some_field'), 'value')"),
+        (filtering.events.some_field == 'value', "Comparison('==', Attribute('some_field'), 'value')"),
+        (filtering.events.another_field.matches(r'^pattern$'), "Match(Attribute('another_field'), '^pattern$')"),
     )
     @unpack
     def test_predicate_repr(self, pred: Predicate, expected: str) -> None:
@@ -153,6 +158,25 @@ def test_logical_combinations(self, pred, idx):
         event_list = get_events(All(pred))
         self.assertListEqual(event_list, [events[i] for i in idx])
 
+    def test_new_syntax(self):
+        # Test the new syntax for filtering
+        event_list = get_events(filtering.events.author == 'Patrick')
+        self.assertListEqual(event_list, [events[0]])
+
+        event_list = get_events((filtering.events.author == 'Patrick') | (filtering.events.author == 'Alexis'))
+        self.assertListEqual(event_list, [events[0], events[1]])
+
+        event_list = get_events((filtering.events.author == 'Patrick') & (filtering.events.a == 1))
+        self.assertListEqual(event_list, [events[0]])
+
+        event_list = get_events(filtering.events.s.matches(r'^Go.*'))
+        self.assertListEqual(event_list, [events[2]])
+
+        event_list = get_events(~(filtering.events.s.matches(r'^Go.*') & (filtering.events.h == 30)))
+        self.assertListEqual(event_list, [events[0], events[1]])
+
+
+
     def test_get_only_manually_added_events_from_dynamic_catalogue(self):
         cat = create_catalogue('T', 'A')
         cat.predicate = Comparison("==", Field('author'), 'Patrick')

tscat/filtering.py

@@ -7,35 +7,83 @@
 if TYPE_CHECKING:
     from . import _Catalogue
 
+MemberValueType = Union[str, int, float, dt.datetime, bool]
 
-class Field:
+class _Member:
     def __init__(self, name: str):
         self.value = name
 
+    def __eq__(self, other: MemberValueType) -> 'Predicate':
+        return Comparison('==', self, other)
+
+    def __ne__(self, other) -> 'Predicate':
+        return Comparison('!=', self, other)
+
+    def __gt__(self, other) -> 'Predicate':
+        return Comparison('>', self, other)
+
+    def __lt__(self, other) -> 'Predicate':
+        return Comparison('<', self, other)
+
+    def __ge__(self, other) -> 'Predicate':
+        return Comparison('>=', self, other)
+
+    def __le__(self, other) -> 'Predicate':
+        return Comparison('<=', self, other)
+
+    def matches(self, value: str) -> 'Predicate':
+        return Match(self, value)
+
+
+class Field(_Member):
+    def __init__(self, name: str):
+        super().__init__(name)
+
     def __repr__(self):
         return f"Field('{self.value}')"
 
 
-class Attribute:
+class Attribute(_Member):
     def __init__(self, name: str):
-        self.value = name
+        super().__init__(name)
 
     def __repr__(self):
         return f"Attribute('{self.value}')"
 
+    def exists(self) -> 'Predicate':
+        return Has(self)
 
 class Predicate:
     def __eq__(self, o):
         return repr(self) == repr(o)
 
+    def __and__(self, other):
+        if isinstance(other, Predicate):
+            return All(self, other)
+        elif isinstance(other, (list, tuple)) and all(isinstance(item, Predicate) for item in other):
+            return All(self, *other)
+        else:
+            raise TypeError(f"Cannot combine {type(self).__name__} with {type(other).__name__}")
+
+    def __or__(self, other):
+        if isinstance(other, Predicate):
+            return Any(self, other)
+        elif isinstance(other, (list, tuple)) and all(isinstance(item, Predicate) for item in other):
+            return Any(self, *other)
+        else:
+            raise TypeError(f"Cannot combine {type(self).__name__} with {type(other).__name__}")
+
+    def __invert__(self):
+        return Not(self)
+
 
 class Comparison(Predicate):
     def __init__(self,
                  op: Union[Literal['>'], Literal['>='],
-                           Literal['<'], Literal['<='],
-                           Literal['=='], Literal['!=']],
-                 lhs: Union[Field, Attribute],
-                 rhs: Union[str, int, float, dt.datetime, bool]):
+                 Literal['<'], Literal['<='],
+                 Literal['=='], Literal['!=']],
+                 lhs: _Member,
+                 rhs: MemberValueType):
         self._op = op
         self._lhs = lhs
         self._rhs = rhs
@@ -46,7 +94,7 @@ def __repr__(self):
 
 class Match(Predicate):
     def __init__(self,
-                 lhs: Union[Field, Attribute],
+                 lhs: _Member,
                  rhs: str):  # regex
         self._lhs = lhs
         self._rhs = rhs
@@ -88,7 +136,7 @@ def __repr__(self):
 
 
 class In(Predicate):
-    def __init__(self, lhs: str, rhs: Union[Field, Attribute]):
+    def __init__(self, lhs: str, rhs: _Member):
         self._lhs = lhs
         self._rhs = rhs
 
@@ -120,3 +168,36 @@ def __init__(self, message: str, predicate: Predicate):
 class CatalogueFilterError(Exception):
     def __init__(self, message: str):
         super().__init__(message)
+
+
+
+class _Catalogue:
+    def __init__(self):
+        pass
+
+    def __contains__(self, item: "_Event") -> Predicate:
+        return InCatalogue(item)
+
+    def __getattr__(self, item) -> _Member:
+        if item in ('name', 'author', 'uuid', 'tags', 'predicate', 'attributes'):
+            return Field(item)
+        return Attribute(item)
+
+
+class _Events:
+    def __init__(self):
+        pass
+
+    def __contains__(self, item: str) -> Predicate:
+        return self[item].exists()
+
+    def __getattr__(self, item) -> _Member:
+        if item in ('start', 'stop', 'author', 'tags', 'products', 'rating', 'uuid'):
+            return Field(item)
+        return Attribute(item)
+
+
+# tokens to create predicates from Python code
+catalogue = _Catalogue()
+events = _Events()
+event = events