zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/models/v2/base/filter.py

@@ -13,6 +13,7 @@
 #  permissions and limitations under the License.
 """Base filter model definitions."""
 
+import json
 from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import (
@@ -30,8 +31,13 @@ from typing import (
 )
 from uuid import UUID
 
-from pydantic import BaseModel, Field, root_validator, validator
-from pydantic.typing import get_args
+from pydantic import (
+    BaseModel,
+    Field,
+    field_validator,
+    model_validator,
+)
+from sqlalchemy import Float, and_, asc, cast, desc
 from sqlmodel import SQLModel
 
 from zenml.constants import (
@@ -43,11 +49,13 @@ from zenml.constants import (
 from zenml.enums import GenericFilterOps, LogicalOperators, SorterOps
 from zenml.exceptions import ValidationError
 from zenml.logger import get_logger
+from zenml.utils.pydantic_utils import before_validator_handler
+from zenml.utils.typing_utils import get_args
 
 if TYPE_CHECKING:
-    from sqlalchemy.sql.elements import BinaryExpression, BooleanClauseList
+    from sqlalchemy.sql.elements import ColumnElement
 
-    from zenml.zen_stores.schemas import BaseSchema
+    from zenml.zen_stores.schemas import BaseSchema, NamedSchema
 
     AnySchema = TypeVar("AnySchema", bound=BaseSchema)
 
@@ -56,6 +64,11 @@ logger = get_logger(__name__)
 
 AnyQuery = TypeVar("AnyQuery", bound=Any)
 
+ONEOF_ERROR = (
+    "When you are using the 'oneof:' filtering make sure that the "
+    "provided value is a json formatted list."
+)
+
 
 class Filter(BaseModel, ABC):
     """Filter for all fields.
@@ -73,14 +86,15 @@ class Filter(BaseModel, ABC):
 
     operation: GenericFilterOps
     column: str
-    value: Any
+    value: Optional[Any] = None
 
-    @validator("operation", pre=True)
-    def validate_operation(cls, op: str) -> str:
+    @field_validator("operation", mode="before")
+    @classmethod
+    def validate_operation(cls, value: Any) -> Any:
         """Validate that the operation is a valid op for the field type.
 
         Args:
-            op: The operation of this filter.
+            value: The operation of this filter.
 
         Returns:
             The operation if it is valid.
@@ -88,18 +102,18 @@ class Filter(BaseModel, ABC):
         Raises:
             ValueError: If the operation is not valid for this field type.
         """
-        if op not in cls.ALLOWED_OPS:
+        if value not in cls.ALLOWED_OPS:
             raise ValueError(
                 f"This datatype can not be filtered using this operation: "
-                f"'{op}'. The allowed operations are: {cls.ALLOWED_OPS}"
+                f"'{value}'. The allowed operations are: {cls.ALLOWED_OPS}"
             )
         else:
-            return op
+            return value
 
     def generate_query_conditions(
         self,
         table: Type[SQLModel],
-    ) -> Union["BinaryExpression[Any]", "BooleanClauseList[Any]"]:
+    ) -> "ColumnElement[bool]":
         """Generate the query conditions for the database.
 
         This method converts the Filter class into an appropriate SQLModel
@@ -134,7 +148,10 @@ class Filter(BaseModel, ABC):
 class BoolFilter(Filter):
     """Filter for all Boolean fields."""
 
-    ALLOWED_OPS: ClassVar[List[str]] = [GenericFilterOps.EQUALS]
+    ALLOWED_OPS: ClassVar[List[str]] = [
+        GenericFilterOps.EQUALS,
+        GenericFilterOps.NOT_EQUALS,
+    ]
 
     def generate_query_conditions_from_column(self, column: Any) -> Any:
         """Generate query conditions for a boolean column.
@@ -145,6 +162,9 @@ class BoolFilter(Filter):
         Returns:
             A list of query conditions.
         """
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            return column != self.value
+
         return column == self.value
 
 
@@ -153,11 +173,32 @@ class StrFilter(Filter):
 
     ALLOWED_OPS: ClassVar[List[str]] = [
         GenericFilterOps.EQUALS,
+        GenericFilterOps.NOT_EQUALS,
         GenericFilterOps.STARTSWITH,
         GenericFilterOps.CONTAINS,
         GenericFilterOps.ENDSWITH,
+        GenericFilterOps.ONEOF,
+        GenericFilterOps.GT,
+        GenericFilterOps.GTE,
+        GenericFilterOps.LT,
+        GenericFilterOps.LTE,
     ]
 
+    @model_validator(mode="after")
+    def check_value_if_operation_oneof(self) -> "StrFilter":
+        """Validator to check if value is a list if oneof operation is used.
+
+        Raises:
+            ValueError: If the value is not a list
+
+        Returns:
+            self
+        """
+        if self.operation == GenericFilterOps.ONEOF:
+            if not isinstance(self.value, list):
+                raise ValueError(ONEOF_ERROR)
+        return self
+
     def generate_query_conditions_from_column(self, column: Any) -> Any:
         """Generate query conditions for a string column.
 
@@ -166,6 +207,9 @@ class StrFilter(Filter):
 
         Returns:
             A list of query conditions.
+
+        Raises:
+            ValueError: the comparison of the column to a numeric value fails.
         """
         if self.operation == GenericFilterOps.CONTAINS:
             return column.like(f"%{self.value}%")
@@ -173,12 +217,68 @@ class StrFilter(Filter):
             return column.startswith(f"{self.value}")
         if self.operation == GenericFilterOps.ENDSWITH:
             return column.endswith(f"{self.value}")
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            return column != self.value
+        if self.operation == GenericFilterOps.ONEOF:
+            return column.in_(self.value)
+        if self.operation in {
+            GenericFilterOps.GT,
+            GenericFilterOps.LT,
+            GenericFilterOps.GTE,
+            GenericFilterOps.LTE,
+        }:
+            try:
+                numeric_column = cast(column, Float)
+
+                assert self.value is not None
+
+                if self.operation == GenericFilterOps.GT:
+                    return and_(
+                        numeric_column, numeric_column > float(self.value)
+                    )
+                if self.operation == GenericFilterOps.LT:
+                    return and_(
+                        numeric_column, numeric_column < float(self.value)
+                    )
+                if self.operation == GenericFilterOps.GTE:
+                    return and_(
+                        numeric_column, numeric_column >= float(self.value)
+                    )
+                if self.operation == GenericFilterOps.LTE:
+                    return and_(
+                        numeric_column, numeric_column <= float(self.value)
+                    )
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to compare the column '{column}' to the "
+                    f"value '{self.value}' (must be numeric): {e}"
+                )
+
         return column == self.value
 
 
 class UUIDFilter(StrFilter):
     """Filter for all uuid fields which are mostly treated like strings."""
 
+    @field_validator("value", mode="before")
+    @classmethod
+    def _remove_hyphens_from_value(cls, value: Any) -> Any:
+        """Remove hyphens from the value to enable string comparisons.
+
+        Args:
+            value: The filter value.
+
+        Returns:
+            The filter value with removed hyphens.
+        """
+        if isinstance(value, str):
+            return value.replace("-", "")
+
+        if isinstance(value, list):
+            return [str(v).replace("-", "") for v in value]
+
+        return value
+
     def generate_query_conditions_from_column(self, column: Any) -> Any:
         """Generate query conditions for a UUID column.
 
@@ -191,10 +291,21 @@ class UUIDFilter(StrFilter):
         import sqlalchemy
         from sqlalchemy_utils.functions import cast_if
 
+        from zenml.utils import uuid_utils
+
         # For equality checks, compare the UUID directly
         if self.operation == GenericFilterOps.EQUALS:
+            if not uuid_utils.is_valid_uuid(self.value):
+                return False
+
             return column == self.value
 
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            if not uuid_utils.is_valid_uuid(self.value):
+                return True
+
+            return column != self.value
+
         # For all other operations, cast and handle the column as string
         return super().generate_query_conditions_from_column(
             column=cast_if(column, sqlalchemy.String)
@@ -204,10 +315,11 @@ class UUIDFilter(StrFilter):
 class NumericFilter(Filter):
     """Filter for all numeric fields."""
 
-    value: Union[float, datetime]
+    value: Union[float, datetime] = Field(union_mode="left_to_right")
 
     ALLOWED_OPS: ClassVar[List[str]] = [
         GenericFilterOps.EQUALS,
+        GenericFilterOps.NOT_EQUALS,
         GenericFilterOps.GT,
         GenericFilterOps.GTE,
         GenericFilterOps.LT,
@@ -215,10 +327,10 @@ class NumericFilter(Filter):
     ]
 
     def generate_query_conditions_from_column(self, column: Any) -> Any:
-        """Generate query conditions for a UUID column.
+        """Generate query conditions for a numeric column.
 
         Args:
-            column: The UUID column of an SQLModel table on which to filter.
+            column: The numeric column of an SQLModel table on which to filter.
 
         Returns:
             A list of query conditions.
@@ -231,6 +343,53 @@ class NumericFilter(Filter):
             return column <= self.value
         if self.operation == GenericFilterOps.LT:
             return column < self.value
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            return column != self.value
+        return column == self.value
+
+
+class DatetimeFilter(Filter):
+    """Filter for all datetime fields."""
+
+    value: Union[datetime, Tuple[datetime, datetime]] = Field(
+        union_mode="left_to_right"
+    )
+
+    ALLOWED_OPS: ClassVar[List[str]] = [
+        GenericFilterOps.EQUALS,
+        GenericFilterOps.NOT_EQUALS,
+        GenericFilterOps.GT,
+        GenericFilterOps.GTE,
+        GenericFilterOps.LT,
+        GenericFilterOps.LTE,
+        GenericFilterOps.IN,
+    ]
+
+    def generate_query_conditions_from_column(self, column: Any) -> Any:
+        """Generate query conditions for a datetime column.
+
+        Args:
+            column: The datetime column of an SQLModel table on which to filter.
+
+        Returns:
+            A list of query conditions.
+        """
+        if self.operation == GenericFilterOps.IN:
+            assert isinstance(self.value, tuple)
+            lower_bound, upper_bound = self.value
+            return column.between(lower_bound, upper_bound)
+
+        assert isinstance(self.value, datetime)
+        if self.operation == GenericFilterOps.GTE:
+            return column >= self.value
+        if self.operation == GenericFilterOps.GT:
+            return column > self.value
+        if self.operation == GenericFilterOps.LTE:
+            return column <= self.value
+        if self.operation == GenericFilterOps.LT:
+            return column < self.value
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            return column != self.value
         return column == self.value
 
 
@@ -260,6 +419,7 @@ class BaseFilter(BaseModel):
         "size",
         "logical_operator",
     ]
+    CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = []
 
     # List of fields that are not even mentioned as options in the CLI.
     CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = []
@@ -284,27 +444,29 @@ class BaseFilter(BaseModel):
         le=PAGE_SIZE_MAXIMUM,
         description="Page size",
     )
-
     id: Optional[Union[UUID, str]] = Field(
-        default=None, description="Id for this resource"
+        default=None,
+        description="Id for this resource",
+        union_mode="left_to_right",
     )
     created: Optional[Union[datetime, str]] = Field(
-        default=None, description="Created"
+        default=None, description="Created", union_mode="left_to_right"
     )
     updated: Optional[Union[datetime, str]] = Field(
-        default=None, description="Updated"
+        default=None, description="Updated", union_mode="left_to_right"
     )
 
     _rbac_configuration: Optional[
         Tuple[UUID, Dict[str, Optional[Set[UUID]]]]
     ] = None
 
-    @validator("sort_by", pre=True)
-    def validate_sort_by(cls, v: str) -> str:
+    @field_validator("sort_by", mode="before")
+    @classmethod
+    def validate_sort_by(cls, value: Any) -> Any:
         """Validate that the sort_column is a valid column with a valid operand.
 
         Args:
-            v: The sort_by field value.
+            value: The sort_by field value.
 
         Returns:
             The validated sort_by field value.
@@ -316,13 +478,13 @@ class BaseFilter(BaseModel):
         # Somehow pydantic allows you to pass in int values, which will be
         #  interpreted as string, however within the validator they are still
         #  integers, which don't have a .split() method
-        if not isinstance(v, str):
+        if not isinstance(value, str):
             raise ValidationError(
                 f"str type expected for the sort_by field. "
-                f"Received a {type(v)}"
+                f"Received a {type(value)}"
             )
-        column = v
-        split_value = v.split(":", 1)
+        column = value
+        split_value = value.split(":", 1)
         if len(split_value) == 2:
             column = split_value[1]
 
@@ -334,31 +496,35 @@ class BaseFilter(BaseModel):
                     SorterOps.values(),
                     column,
                 )
-                v = column
+                value = column
 
-        if column in cls.FILTER_EXCLUDE_FIELDS:
+        if column in cls.CUSTOM_SORTING_OPTIONS:
+            return value
+        elif column in cls.FILTER_EXCLUDE_FIELDS:
             raise ValueError(
-                f"This resource can not be sorted by this field: '{v}'"
+                f"This resource can not be sorted by this field: '{value}'"
             )
-        elif column in cls.__fields__:
-            return v
+        if column in cls.model_fields:
+            return value
         else:
             raise ValueError(
                 "You can only sort by valid fields of this resource"
             )
 
-    @root_validator(pre=True)
-    def filter_ops(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @model_validator(mode="before")
+    @classmethod
+    @before_validator_handler
+    def filter_ops(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """Parse incoming filters to ensure all filters are legal.
 
         Args:
-            values: The values of the class.
+            data: The values of the class.
 
         Returns:
             The values of the class.
         """
-        cls._generate_filter_list(values)
-        return values
+        cls._generate_filter_list(data)
+        return data
 
     @property
     def list_of_filters(self) -> List[Filter]:
@@ -368,7 +534,7 @@ class BaseFilter(BaseModel):
             A list of Filter models.
         """
         return self._generate_filter_list(
-            {key: getattr(self, key) for key in self.__fields__}
+            {key: getattr(self, key) for key in self.model_fields}
         )
 
     @property
@@ -403,14 +569,14 @@ class BaseFilter(BaseModel):
             column_allowed_ids: Set of IDs per column to limit the query to.
                 If given, the remaining filters will be applied to entities
                 within this set only. If `None`, the remaining filters will
-                applied to all entries in the table.
+                be applied to all entries in the table.
         """
         self._rbac_configuration = (authenticated_user_id, column_allowed_ids)
 
     def generate_rbac_filter(
         self,
         table: Type["AnySchema"],
-    ) -> Optional["BooleanClauseList[Any]"]:
+    ) -> Optional["ColumnElement[bool]"]:
         """Generates an optional RBAC filter.
 
         Args:
@@ -474,7 +640,7 @@ class BaseFilter(BaseModel):
             value, operator = cls._resolve_operator(value)
 
             # Define the filter
-            filter = cls._define_filter(
+            filter = FilterGenerator(cls).define_filter(
                 column=key, value=value, operator=operator
             )
             list_of_filters.append(filter)
@@ -495,6 +661,10 @@ class BaseFilter(BaseModel):
 
         Returns:
             A tuple of the filter value and the operator.
+
+        Raises:
+            ValueError: when we try to use the `oneof` operator with the wrong
+                value.
         """
         operator = GenericFilterOps.EQUALS  # Default operator
         if isinstance(value, str):
@@ -505,11 +675,204 @@ class BaseFilter(BaseModel):
             ):
                 value = split_value[1]
                 operator = GenericFilterOps(split_value[0])
+
+            if operator == operator.ONEOF:
+                try:
+                    value = json.loads(value)
+                    if not isinstance(value, list):
+                        raise ValueError
+                except ValueError:
+                    raise ValueError(ONEOF_ERROR)
+
         return value, operator
 
-    @classmethod
-    def _define_filter(
-        cls, column: str, value: Any, operator: GenericFilterOps
+    def generate_name_or_id_query_conditions(
+        self,
+        value: Union[UUID, str],
+        table: Type["NamedSchema"],
+        additional_columns: Optional[List[str]] = None,
+    ) -> "ColumnElement[bool]":
+        """Generate filter conditions for name or id of a table.
+
+        Args:
+            value: The filter value.
+            table: The table to filter.
+            additional_columns: Additional table columns that should also
+                filtered for the given value as part of the or condition.
+
+        Returns:
+            The query conditions.
+        """
+        from sqlmodel import or_
+
+        value, operator = BaseFilter._resolve_operator(value)
+        value = str(value)
+
+        conditions = []
+
+        filter_ = FilterGenerator(table).define_filter(
+            column="id", value=value, operator=operator
+        )
+        conditions.append(filter_.generate_query_conditions(table=table))
+
+        filter_ = FilterGenerator(table).define_filter(
+            column="name", value=value, operator=operator
+        )
+        conditions.append(filter_.generate_query_conditions(table=table))
+
+        for column in additional_columns or []:
+            filter_ = FilterGenerator(table).define_filter(
+                column=column, value=value, operator=operator
+            )
+            conditions.append(filter_.generate_query_conditions(table=table))
+
+        return or_(*conditions)
+
+    @staticmethod
+    def generate_custom_query_conditions_for_column(
+        value: Any,
+        table: Type[SQLModel],
+        column: str,
+    ) -> "ColumnElement[bool]":
+        """Generate custom filter conditions for a column of a table.
+
+        Args:
+            value: The filter value.
+            table: The table which contains the column.
+            column: The column name.
+
+        Returns:
+            The query conditions.
+        """
+        value, operator = BaseFilter._resolve_operator(value)
+        filter_ = FilterGenerator(table).define_filter(
+            column=column, value=value, operator=operator
+        )
+        return filter_.generate_query_conditions(table=table)
+
+    @property
+    def offset(self) -> int:
+        """Returns the offset needed for the query on the data persistence layer.
+
+        Returns:
+            The offset for the query.
+        """
+        return self.size * (self.page - 1)
+
+    def generate_filter(
+        self, table: Type["AnySchema"]
+    ) -> Union["ColumnElement[bool]"]:
+        """Generate the filter for the query.
+
+        Args:
+            table: The Table that is being queried from.
+
+        Returns:
+            The filter expression for the query.
+
+        Raises:
+            RuntimeError: If a valid logical operator is not supplied.
+        """
+        from sqlmodel import and_, or_
+
+        filters = []
+        for column_filter in self.list_of_filters:
+            filters.append(
+                column_filter.generate_query_conditions(table=table)
+            )
+        for custom_filter in self.get_custom_filters(table):
+            filters.append(custom_filter)
+        if self.logical_operator == LogicalOperators.OR:
+            return or_(False, *filters)
+        elif self.logical_operator == LogicalOperators.AND:
+            return and_(True, *filters)
+        else:
+            raise RuntimeError("No valid logical operator was supplied.")
+
+    def get_custom_filters(
+        self, table: Type["AnySchema"]
+    ) -> List["ColumnElement[bool]"]:
+        """Get custom filters.
+
+        This can be overridden by subclasses to define custom filters that are
+        not based on the columns of the underlying table.
+
+        Args:
+            table: The query table.
+
+        Returns:
+            A list of custom filters.
+        """
+        return []
+
+    def apply_filter(
+        self,
+        query: AnyQuery,
+        table: Type["AnySchema"],
+    ) -> AnyQuery:
+        """Applies the filter to a query.
+
+        Args:
+            query: The query to which to apply the filter.
+            table: The query table.
+
+        Returns:
+            The query with filter applied.
+        """
+        rbac_filter = self.generate_rbac_filter(table=table)
+
+        if rbac_filter is not None:
+            query = query.where(rbac_filter)
+
+        filters = self.generate_filter(table=table)
+
+        if filters is not None:
+            query = query.where(filters)
+
+        return query
+
+    def apply_sorting(
+        self,
+        query: AnyQuery,
+        table: Type["AnySchema"],
+    ) -> AnyQuery:
+        """Apply sorting to the query.
+
+        Args:
+            query: The query to which to apply the sorting.
+            table: The query table.
+
+        Returns:
+            The query with sorting applied.
+        """
+        column, operand = self.sorting_params
+
+        if operand == SorterOps.DESCENDING:
+            sort_clause = desc(getattr(table, column))  # type: ignore[var-annotated]
+        else:
+            sort_clause = asc(getattr(table, column))
+
+        # We always add the `id` column as a tiebreaker to ensure a stable,
+        # repeatable order of items, otherwise subsequent pages might contain
+        # the same items.
+        query = query.order_by(sort_clause, asc(table.id))  # type: ignore[arg-type]
+
+        return query
+
+
+class FilterGenerator:
+    """Helper class to define filters for a class."""
+
+    def __init__(self, model_class: Type[BaseModel]) -> None:
+        """Initialize the object.
+
+        Args:
+            model_class: The model class for which to define filters.
+        """
+        self._model_class = model_class
+
+    def define_filter(
+        self, column: str, value: Any, operator: GenericFilterOps
     ) -> Filter:
         """Define a filter for a given column.
 
@@ -522,23 +885,23 @@ class BaseFilter(BaseModel):
             A Filter object.
         """
         # Create datetime filters
-        if cls.is_datetime_field(column):
-            return cls._define_datetime_filter(
+        if self.is_datetime_field(column):
+            return self._define_datetime_filter(
                 column=column,
                 value=value,
                 operator=operator,
             )
 
         # Create UUID filters
-        if cls.is_uuid_field(column):
-            return cls._define_uuid_filter(
+        if self.is_uuid_field(column):
+            return self._define_uuid_filter(
                 column=column,
                 value=value,
                 operator=operator,
             )
 
         # Create int filters
-        if cls.is_int_field(column):
+        if self.is_int_field(column):
             return NumericFilter(
                 operation=GenericFilterOps(operator),
                 column=column,
@@ -546,25 +909,26 @@ class BaseFilter(BaseModel):
             )
 
         # Create bool filters
-        if cls.is_bool_field(column):
-            return cls._define_bool_filter(
+        if self.is_bool_field(column):
+            return self._define_bool_filter(
                 column=column,
                 value=value,
                 operator=operator,
             )
 
         # Create str filters
-        if cls.is_str_field(column):
-            return StrFilter(
-                operation=GenericFilterOps(operator),
+        if self.is_str_field(column):
+            return self._define_str_filter(
+                operator=GenericFilterOps(operator),
                 column=column,
                 value=value,
             )
 
         # Handle unsupported datatypes
         logger.warning(
-            f"The Datatype {cls.__fields__[column].type_} might not be "
-            "supported for filtering. Defaulting to a string filter."
+            f"The Datatype {self._model_class.model_fields[column].annotation} "
+            "might not be supported for filtering. Defaulting to a string "
+            "filter."
         )
         return StrFilter(
             operation=GenericFilterOps(operator),
@@ -572,8 +936,37 @@ class BaseFilter(BaseModel):
             value=str(value),
         )
 
-    @classmethod
-    def is_datetime_field(cls, k: str) -> bool:
+    def check_field_annotation(self, k: str, type_: Any) -> bool:
+        """Checks whether a model field has a certain annotation.
+
+        Args:
+            k: The name of the field.
+            type_: The type to check.
+
+        Raises:
+            ValueError: if the model field within does not have an annotation.
+
+        Returns:
+            True if the annotation of the field matches the given type, False
+            otherwise.
+        """
+        try:
+            annotation = self._model_class.model_fields[k].annotation
+
+            if annotation is not None:
+                return (
+                    issubclass(type_, get_args(annotation))
+                    or annotation is type_
+                )
+            else:
+                raise ValueError(
+                    f"The field '{k}' inside the model {self._model_class.__name__} "
+                    "does not have an annotation."
+                )
+        except TypeError:
+            return False
+
+    def is_datetime_field(self, k: str) -> bool:
         """Checks if it's a datetime field.
 
         Args:
@@ -582,43 +975,31 @@ class BaseFilter(BaseModel):
         Returns:
             True if the field is a datetime field, False otherwise.
         """
-        return (
-            issubclass(datetime, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ is datetime
-        )
+        return self.check_field_annotation(k=k, type_=datetime)
 
-    @classmethod
-    def is_uuid_field(cls, k: str) -> bool:
-        """Checks if it's a uuid field.
+    def is_uuid_field(self, k: str) -> bool:
+        """Checks if it's a UUID field.
 
         Args:
             k: The key to check.
 
         Returns:
-            True if the field is a uuid field, False otherwise.
+            True if the field is a UUID field, False otherwise.
         """
-        return (
-            issubclass(UUID, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ is UUID
-        )
+        return self.check_field_annotation(k=k, type_=UUID)
 
-    @classmethod
-    def is_int_field(cls, k: str) -> bool:
-        """Checks if it's a int field.
+    def is_int_field(self, k: str) -> bool:
+        """Checks if it's an int field.
 
         Args:
             k: The key to check.
 
         Returns:
-            True if the field is a int field, False otherwise.
+            True if the field is an int field, False otherwise.
         """
-        return (
-            issubclass(int, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ is int
-        )
+        return self.check_field_annotation(k=k, type_=int)
 
-    @classmethod
-    def is_bool_field(cls, k: str) -> bool:
+    def is_bool_field(self, k: str) -> bool:
         """Checks if it's a bool field.
 
         Args:
@@ -627,13 +1008,9 @@ class BaseFilter(BaseModel):
         Returns:
             True if the field is a bool field, False otherwise.
         """
-        return (
-            issubclass(bool, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ is bool
-        )
+        return self.check_field_annotation(k=k, type_=bool)
 
-    @classmethod
-    def is_str_field(cls, k: str) -> bool:
+    def is_str_field(self, k: str) -> bool:
         """Checks if it's a string field.
 
         Args:
@@ -642,13 +1019,9 @@ class BaseFilter(BaseModel):
         Returns:
             True if the field is a string field, False otherwise.
         """
-        return (
-            issubclass(str, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ is str
-        )
+        return self.check_field_annotation(k=k, type_=str)
 
-    @classmethod
-    def is_sort_by_field(cls, k: str) -> bool:
+    def is_sort_by_field(self, k: str) -> bool:
         """Checks if it's a sort by field.
 
         Args:
@@ -657,15 +1030,12 @@ class BaseFilter(BaseModel):
         Returns:
             True if the field is a sort by field, False otherwise.
         """
-        return (
-            issubclass(str, get_args(cls.__fields__[k].type_))
-            or cls.__fields__[k].type_ == str
-        ) and k == "sort_by"
+        return self.check_field_annotation(k=k, type_=str) and k == "sort_by"
 
     @staticmethod
     def _define_datetime_filter(
         column: str, value: Any, operator: GenericFilterOps
-    ) -> NumericFilter:
+    ) -> DatetimeFilter:
         """Define a datetime filter for a given column.
 
         Args:
@@ -680,10 +1050,17 @@ class BaseFilter(BaseModel):
             ValueError: If the value is not a valid datetime.
         """
         try:
+            filter_value: Union[datetime, Tuple[datetime, datetime]]
             if isinstance(value, datetime):
-                datetime_value = value
+                filter_value = value
+            elif "," in value:
+                lower_bound, upper_bound = value.split(",", 1)
+                filter_value = (
+                    datetime.strptime(lower_bound, FILTERING_DATETIME_FORMAT),
+                    datetime.strptime(upper_bound, FILTERING_DATETIME_FORMAT),
+                )
             else:
-                datetime_value = datetime.strptime(
+                filter_value = datetime.strptime(
                     value, FILTERING_DATETIME_FORMAT
                 )
         except ValueError as e:
@@ -691,10 +1068,27 @@ class BaseFilter(BaseModel):
                 "The datetime filter only works with values in the following "
                 f"format: {FILTERING_DATETIME_FORMAT}"
             ) from e
-        datetime_filter = NumericFilter(
+
+        if operator == GenericFilterOps.IN and not isinstance(
+            filter_value, tuple
+        ):
+            raise ValueError(
+                "Two comma separated datetime values are required for the `in` "
+                "operator."
+            )
+
+        if operator != GenericFilterOps.IN and not isinstance(
+            filter_value, datetime
+        ):
+            raise ValueError(
+                "Only a single datetime value is allowed for operator "
+                f"{operator}."
+            )
+
+        datetime_filter = DatetimeFilter(
             operation=GenericFilterOps(operator),
             column=column,
-            value=datetime_value,
+            value=filter_value,
         )
         return datetime_filter
 
@@ -713,19 +1107,10 @@ class BaseFilter(BaseModel):
             A Filter object.
 
         Raises:
-            ValueError: If the value is not a valid UUID.
+            ValueError: If the value for a oneof filter is not a list.
         """
-        # For equality checks, ensure that the value is a valid UUID.
-        if operator == GenericFilterOps.EQUALS and not isinstance(value, UUID):
-            try:
-                UUID(value)
-            except ValueError as e:
-                raise ValueError(
-                    "Invalid value passed as UUID query parameter."
-                ) from e
-
-        # Cast the value to string for further comparisons.
-        value = str(value)
+        if operator == GenericFilterOps.ONEOF and not isinstance(value, list):
+            raise ValueError(ONEOF_ERROR)
 
         # Generate the filter.
         uuid_filter = UUIDFilter(
@@ -735,6 +1120,38 @@ class BaseFilter(BaseModel):
         )
         return uuid_filter
 
+    @staticmethod
+    def _define_str_filter(
+        column: str, value: Any, operator: GenericFilterOps
+    ) -> StrFilter:
+        """Define a str filter for a given column.
+
+        Args:
+            column: The column to filter on.
+            value: The UUID value by which to filter.
+            operator: The operator to use for filtering.
+
+        Returns:
+            A Filter object.
+
+        Raises:
+            ValueError: If the value is not a proper value.
+        """
+        # For equality checks, ensure that the value is a valid UUID.
+        if operator == GenericFilterOps.ONEOF and not isinstance(value, list):
+            raise ValueError(
+                "If you are using `oneof:` as a filtering op, the value needs "
+                "to be a json formatted list string."
+            )
+
+        # Generate the filter.
+        str_filter = StrFilter(
+            operation=GenericFilterOps(operator),
+            column=column,
+            value=value,
+        )
+        return str_filter
+
     @staticmethod
     def _define_bool_filter(
         column: str, value: Any, operator: GenericFilterOps
@@ -760,89 +1177,3 @@ class BaseFilter(BaseModel):
             column=column,
             value=bool(value),
         )
-
-    @property
-    def offset(self) -> int:
-        """Returns the offset needed for the query on the data persistence layer.
-
-        Returns:
-            The offset for the query.
-        """
-        return self.size * (self.page - 1)
-
-    def generate_filter(
-        self, table: Type[SQLModel]
-    ) -> Union["BinaryExpression[Any]", "BooleanClauseList[Any]"]:
-        """Generate the filter for the query.
-
-        Args:
-            table: The Table that is being queried from.
-
-        Returns:
-            The filter expression for the query.
-
-        Raises:
-            RuntimeError: If a valid logical operator is not supplied.
-        """
-        from sqlalchemy import and_
-        from sqlmodel import or_
-
-        filters = []
-        for column_filter in self.list_of_filters:
-            filters.append(
-                column_filter.generate_query_conditions(table=table)
-            )
-        for custom_filter in self.get_custom_filters():
-            filters.append(custom_filter)
-        if self.logical_operator == LogicalOperators.OR:
-            return or_(False, *filters)
-        elif self.logical_operator == LogicalOperators.AND:
-            return and_(True, *filters)
-        else:
-            raise RuntimeError("No valid logical operator was supplied.")
-
-    def get_custom_filters(
-        self,
-    ) -> List[Union["BinaryExpression[Any]", "BooleanClauseList[Any]"]]:
-        """Get custom filters.
-
-        This can be overridden by subclasses to define custom filters that are
-        not based on the columns of the underlying table.
-
-        Returns:
-            A list of custom filters.
-        """
-        return []
-
-    def apply_filter(
-        self,
-        query: AnyQuery,
-        table: Type["AnySchema"],
-    ) -> AnyQuery:
-        """Applies the filter to a query.
-
-        Args:
-            query: The query to which to apply the filter.
-            table: The query table.
-
-        Returns:
-            The query with filter applied.
-        """
-        rbac_filter = self.generate_rbac_filter(table=table)
-
-        if rbac_filter is not None:
-            query = query.where(rbac_filter)
-
-        filters = self.generate_filter(table=table)
-
-        if filters is not None:
-            query = query.where(filters)
-
-        return query
-
-    class Config:
-        """Pydantic configuration class."""
-
-        # all attributes with leading underscore are private and therefore
-        # are mutable and not included in serialization
-        underscore_attrs_are_private = True