Pass filters into DatabaseInterface.retrieve

Author: pylipp

financeager/pocket/base.py

@@ -173,8 +173,6 @@ def remove_entry(self, eid, table_name=None):
     def get_entries(self, filters=None, recurrent_only=False):
         """Get entries that match the items of the filters dict, if specified.
 
-        Constructs a condition from the given filters and uses it to query all tables.
-
         If `recurrent_only` is true, return a list of all entries of the
         recurrent table. Filters are applied.
 
@@ -186,13 +184,10 @@ def get_entries(self, filters=None, recurrent_only=False):
                     } or
                  list[dict]
         """
-        filters = filters or {}
-        condition = self.db_interface.create_query_condition(**filters)
-
         if recurrent_only:
-            return self.db_interface.retrieve(RECURRENT_TABLE, condition)
+            return self.db_interface.retrieve(RECURRENT_TABLE, filters)
 
-        return self._search_all_tables(condition)
+        return self._search_all_tables(filters)
 
     def get_categories(self):
         """Return unique category names in alphabetical order."""
@@ -402,27 +397,41 @@ def _preprocess_entry_for_update(self, *, table_name, raw_data):
 
         return fields
 
-    def _search_all_tables(self, condition):
+    def _search_all_tables(self, filters):
         """Search both the standard table and the recurrent table for elements
-        that satisfy the given condition.
+        that satisfy the given filters.
+
+        Constructs a condition from the given filters and uses it to query all tables.
 
         The entry IDs are used as key in the returned subdicts.
 
-        :param condition: condition for the search
+        :param filters: filters for the search
         :return: dict
         """
 
         elements = {DEFAULT_TABLE: {}, RECURRENT_TABLE: defaultdict(list)}
 
-        for element in self.db_interface.retrieve(DEFAULT_TABLE, condition):
+        for element in self.db_interface.retrieve(DEFAULT_TABLE, filters):
             elements[DEFAULT_TABLE][element["eid"]] = element
 
+        # Filter keys are name, value, category, and/or date. The first three exist in
+        # the recurrent table, too, and are hence passed to the retrieve() call.
+        # Filtering of the date field happens via a lambda function in Python after
+        # instantiations of recurrent entries have been created.
+        date_filter = lambda _: True
+        date_pattern = None
+        if filters:
+            date_pattern = filters.pop("date", None)
+        if date_pattern is not None:
+            date_pattern = date_pattern.lower()
+            date_filter = lambda row: date_pattern in row["date"].lower()
+
         # all recurrent elements are generated, and the ones matching the
         # condition are appended to a list that is stored under their generating
         # element's ID in the 'recurrent' subdictionary
-        for element in self.db_interface.retrieve(RECURRENT_TABLE):
+        for element in self.db_interface.retrieve(RECURRENT_TABLE, filters):
             for e in self._create_recurrent_elements(element):
-                if condition(e):
+                if date_filter(e):
                     elements[RECURRENT_TABLE][element["eid"]].append(e)
 
         return elements

financeager/pocket/tinydb.py

@@ -18,10 +18,11 @@ def __init__(self, *args, **kwargs):
         """
         self._db = TinyDB(*args, **kwargs)
 
-    def retrieve(self, table_name, condition=None):
-        if condition is None:
+    def retrieve(self, table_name, filters=None):
+        if not filters:
             elements = self._db.table(table_name).all()
         else:
+            condition = self.create_query_condition(**filters)
             elements = self._db.table(table_name).search(condition)
         # Flatten tinydb Documents into dict
         return [{**e, **{"eid": e.doc_id}} for e in elements]
@@ -46,9 +47,6 @@ def delete_by_id(self, table_name, element_id):
     def create_query_condition(**filters):
         """:return: tinydb.queries.QueryInstance (default: noop)"""
         condition = Query().noop()
-        if not filters:
-            return condition
-
         entry = Query()
         for field, pattern in filters.items():
             if pattern is None and field in ["category", "end"]:

financeager/pocket/utils.py

@@ -8,11 +8,11 @@ class DatabaseInterface(ABC):
     """Abstract base class for database client implementations."""
 
     @abstractmethod
-    def retrieve(self, table_name, condition=None) -> Iterable[dict[str, Any]]:
+    def retrieve(self, table_name, filters=None) -> Iterable[dict[str, Any]]:
         """Retrieve rows from a table.
 
         :param table_name: name of the table to query
-        :param condition: optional condition to filter rows
+        :param filters: optional filters dict to filter rows
         :return: list of dicts
         """
 
@@ -59,9 +59,11 @@ def create_query_condition(**filters) -> Any:
         """Construct query condition according to given filters. A filter is
         given by a key-value pair. The key indicates the field, the value the
         pattern to filter for. Valid keys are 'name', 'date', 'value' and/or
-        'category'. Patterns must be of type string, or None (only for the fields
-        'category' and 'end'; indicates filtering for all entries of the default
-        category, and recurrent entries with indefinite end, resp.).
+        'category' for the standard table, and 'name', 'value', 'category', 'start',
+        'end', 'frequency' for the recurrent table.
+        Patterns must be of type string, or None (only for the fields 'category' and
+        'end'; indicates filtering for all entries of the default category, and
+        recurrent entries with indefinite end, resp.).
         Return a condition object that is comprehended by the database interface (i.e.
         DatabaseInterface.retrieve).
         """