unified new and old query with a get_filter_by_attribute method so they will be compatible

Author: alejcas

O365/calendar.py

@@ -1825,28 +1825,19 @@ def get_events(self, limit=25, *, query=None, order_by=None, batch=None,
             if query and not isinstance(query, str):
                 # extract start and end from query because
                 # those are required by a calendarView
-                for query_data in query._filters:
-                    if not isinstance(query_data, list):
-                        continue
-                    attribute = query_data[0]
-                    # the 2nd position contains the filter data
-                    # and the 3rd position in filter_data contains the value
-                    word = query_data[2][3]
-
-                    if attribute.lower().startswith('start/'):
-                        start = word.replace("'", '')  # remove the quotes
-                        query.remove_filter('start')
-                    if attribute.lower().startswith('end/'):
-                        end = word.replace("'", '')  # remove the quotes
-                        query.remove_filter('end')
+                start = query.get_filter_by_attribute('start/')
+                end = query.get_filter_by_attribute('start/')
 
-            if start is None or end is None:
-                raise ValueError(
-                    "When 'include_recurring' is True you must provide a 'start' and 'end' datetimes inside a Query instance.")
+                if start:
+                    start = start.replace("'", '')  # remove the quotes
+                    query.remove_filter('start')
+                if end:
+                    end = end.replace("'", '')  # remove the quotes
+                    query.remove_filter('end')
 
-            if end < start:
-                raise ValueError('When using "include_recurring=True", the date asigned to the "end" datetime'
-                                 ' should be greater or equal than the date asigned to the "start" datetime.')
+            if start is None or end is None:
+                raise ValueError("When 'include_recurring' is True you must provide "
+                                 "a 'start' and 'end' datetime inside a 'Query' instance.")
 
             params[self._cc('startDateTime')] = start
             params[self._cc('endDateTime')] = end

O365/utils/query.py

@@ -2,12 +2,12 @@
 
 import datetime as dt
 from abc import ABC, abstractmethod
-from typing import Union, Optional, TYPE_CHECKING, Type, Iterator, Literal
+from typing import Union, Optional, TYPE_CHECKING, Type, Iterator, Literal, TypeAlias
 
 if TYPE_CHECKING:
     from O365.connection import Protocol
 
-FilterWord = Union[str, bool, None, dt.date, int, float]
+FilterWord: TypeAlias = Union[str, bool, None, dt.date, int, float]
 
 
 class QueryBase(ABC):
@@ -35,6 +35,34 @@ def __and__(self, other):
     def __or__(self, other):
         pass
 
+    def get_filter_by_attribute(self, attribute: str) -> Optional[str]:
+        """
+        Returns a filter value by attribute name. It will match the attribute to the start of each filter attribute
+        and return the first found.
+        :param attribute: the attribute you want to search
+        :return: The value applied to that attribute or None
+        """
+        search_object: Optional[QueryFilter] = getattr(self, "_filter_instance") or getattr(self, "filters")
+        if search_object is not None:
+            # CompositeFilter, IterableFilter, ModifierQueryFilter (negate, group)
+            return search_object.get_filter_by_attribute(attribute)
+
+        search_object: Optional[list[QueryFilter]] = getattr(self, "_filter_instances")
+        if search_object is not None:
+            # ChainFilter
+            for filter_obj in search_object:
+                result = filter_obj.get_filter_by_attribute(attribute)
+                if result is not None:
+                    return result
+            return None
+
+        search_object: Optional[str] = getattr(self, "_attribute")
+        if search_object is not None:
+            # LogicalFilter or FunctionFilter
+            if search_object.lower().startswith(attribute.lower()):
+                return getattr(self, "_word")
+        return None
+
 
 class QueryFilter(QueryBase, ABC):
     __slots__ = ()
@@ -428,7 +456,7 @@ def _parse_filter_word(self, word: FilterWord) -> str:
             # bools are treated as lower case bools
             parsed_word = str(word).lower()
         elif word is None:
-            parsed_word = 'null'
+            parsed_word = "null"
         elif isinstance(word, dt.date):
             if isinstance(word, dt.datetime):
                 if word.tzinfo is None:
@@ -451,9 +479,9 @@ def _get_attribute_from_mapping(self, attribute: str) -> str:
         """
         mapping = self._attribute_mapping.get(attribute)
         if mapping:
-            attribute = '/'.join(
+            attribute = "/".join(
                 [self.protocol.convert_case(step) for step in
-                 mapping.split('/')])
+                 mapping.split("/")])
         else:
             attribute = self.protocol.convert_case(attribute)
         return attribute
@@ -475,7 +503,7 @@ def equals(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('eq', attribute, word)
+        return self.logical_operation("eq", attribute, word)
 
     def unequal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         """ Return an unequal check
@@ -484,7 +512,7 @@ def unequal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('ne', attribute, word)
+        return self.logical_operation("ne", attribute, word)
 
     def greater(self, attribute: str, word: FilterWord) -> LogicalFilter:
         """ Return a 'greater than' check
@@ -493,7 +521,7 @@ def greater(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('gt', attribute, word)
+        return self.logical_operation("gt", attribute, word)
 
     def greater_equal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         """ Return a 'greater than or equal to' check
@@ -502,7 +530,7 @@ def greater_equal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('ge', attribute, word)
+        return self.logical_operation("ge", attribute, word)
 
     def less(self, attribute: str, word: FilterWord) -> LogicalFilter:
         """ Return a 'less than' check
@@ -511,7 +539,7 @@ def less(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('lt', attribute, word)
+        return self.logical_operation("lt", attribute, word)
 
     def less_equal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         """ Return a 'less than or equal to' check
@@ -520,7 +548,7 @@ def less_equal(self, attribute: str, word: FilterWord) -> LogicalFilter:
         :param word: word to compare with
         :return: a QueryFilter instance that can render the OData this logical operation
         """
-        return self.logical_operation('le', attribute, word)
+        return self.logical_operation("le", attribute, word)
 
     def function_operation(self, operation: str, attribute: str, word: FilterWord) -> FunctionFilter:
         """ Apply a function operation
@@ -539,7 +567,7 @@ def contains(self, attribute: str, word: FilterWord) -> FunctionFilter:
         :param word: value to feed the function
         :return: a QueryFilter instance that can render the OData function operation
         """
-        return self.function_operation('contains', attribute, word)
+        return self.function_operation("contains", attribute, word)
 
     def startswith(self, attribute: str, word: FilterWord) -> FunctionFilter:
         """ Adds a startswith word check
@@ -548,7 +576,7 @@ def startswith(self, attribute: str, word: FilterWord) -> FunctionFilter:
         :param word: value to feed the function
         :return: a QueryFilter instance that can render the OData function operation
         """
-        return self.function_operation('startswith', attribute, word)
+        return self.function_operation("startswith", attribute, word)
 
     def endswith(self, attribute: str, word: FilterWord) -> FunctionFilter:
         """ Adds a endswith word check
@@ -557,7 +585,7 @@ def endswith(self, attribute: str, word: FilterWord) -> FunctionFilter:
         :param word: value to feed the function
         :return: a QueryFilter instance that can render the OData function operation
         """
-        return self.function_operation('endswith', attribute, word)
+        return self.function_operation("endswith", attribute, word)
 
     def iterable_operation(self, operation: str, collection: str, filter_instance: QueryFilter,
                            *, item_name: str = "a") -> IterableFilter:
@@ -598,7 +626,7 @@ def any(self, collection: str, filter_instance: QueryFilter, *, item_name: str =
         :return: a QueryFilter instance that can render the OData iterable operation
         """
 
-        return self.iterable_operation('any', collection=collection,
+        return self.iterable_operation("any", collection=collection,
                                        filter_instance=filter_instance, item_name=item_name)
 
 
@@ -618,7 +646,7 @@ def all(self, collection: str, filter_instance: QueryFilter, *, item_name: str =
         :return: a QueryFilter instance that can render the OData iterable operation
         """
 
-        return self.iterable_operation('all', collection=collection,
+        return self.iterable_operation("all", collection=collection,
                                        filter_instance=filter_instance, item_name=item_name)
 
     @staticmethod
@@ -635,7 +663,7 @@ def chain_and(self, *filter_instances: QueryFilter, group: bool = False) -> Quer
         """
         if not all(isinstance(item, QueryFilter) for item in filter_instances):
             raise ValueError("'filter_instances' parameter must contain only QueryFilter instances")
-        chain = ChainFilter(operation='and', filter_instances=list(filter_instances))
+        chain = ChainFilter(operation="and", filter_instances=list(filter_instances))
         if group:
             return self.group(chain)
         else:
@@ -650,7 +678,7 @@ def chain_or(self, *filter_instances: QueryFilter, group: bool = False) -> Query
         """
         if not all(isinstance(item, QueryFilter) for item in filter_instances):
             raise ValueError("'filter_instances' parameter must contain only QueryFilter instances")
-        chain = ChainFilter(operation='or', filter_instances=list(filter_instances))
+        chain = ChainFilter(operation="or", filter_instances=list(filter_instances))
         if group:
             return self.group(chain)
         else:

O365/utils/utils.py

@@ -1306,3 +1306,21 @@ def close_group(self):
         else:
             raise RuntimeError("No filters present. Can't close a group")
         return self
+
+    def get_filter_by_attribute(self, attribute):
+        """ Returns a filter word applied to an attribute """
+
+        attribute = attribute.lower()
+
+        # iterate over the filters to find the corresponding attribute
+        for query_data in self._filters:
+            if not isinstance(query_data, list):
+                continue
+            filter_attribute = query_data[0]
+            # the 2nd position contains the filter data
+            # and the 3rd position in filter_data contains the value
+            word = query_data[2][3]
+
+            if filter_attribute.lower().startswith(attribute):
+                return word
+        return None