exdrf 0.0.1.dev0__py3-none-any.whl

exdrf/sa_fi_item.py

@@ -0,0 +1,69 @@
+"""SQLAlchemy-oriented filter list items (Qt-free)."""
+
+from typing import TYPE_CHECKING, Any
+
+from attrs import define
+
+from exdrf.sa_filter_op import FiOp
+
+if TYPE_CHECKING:
+    from sqlalchemy import Select
+
+
+@define
+class SqBaseFiItem:
+    """An item in the list of filters.
+
+    The model simply calls the apply method of the filter with the initial
+    selection or the selection after the previous filter.
+    """
+
+    def apply(self, selection: "Select") -> "Select":
+        """Apply this filter item to the selection.
+
+        Args:
+            selection: The SQLAlchemy select statement to apply the filter to.
+
+        Returns:
+            A new select statement with the filter applied.
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses.
+        """
+        raise NotImplementedError
+
+
+@define
+class SqFiItem(SqBaseFiItem):
+    """A concrete filter item that applies an operator to a field.
+
+    Attributes:
+        field: The field (column descriptor) to filter on; often a Qt model
+            field or other object whose paired operator implements
+            ``apply_filter``.
+        op: The filter operator to apply.
+        value: The value to compare against.
+    """
+
+    field: Any
+    op: FiOp
+    value: Any
+
+    def apply(self, selection: "Select") -> "Select":
+        """Apply this filter item to the selection.
+
+        Uses the operator's apply_filter method to apply the filter to the
+        given selection.
+
+        Args:
+            selection: The SQLAlchemy select statement to apply the filter to.
+
+        Returns:
+            A new select statement with the filter applied.
+        """
+        return self.op.apply_filter(
+            selector=self.field,
+            value=self.value,
+            selection=selection,
+            item=self,
+        )

exdrf/sa_filter_op.py

@@ -0,0 +1,324 @@
+"""SQLAlchemy filter operators shared by Qt and non-Qt code."""
+
+import logging
+from functools import partial
+from typing import TYPE_CHECKING, Any, Union
+
+from attrs import define, field
+from sqlalchemy import String
+from sqlalchemy import cast as al_cast
+from sqlalchemy.sql.operators import (
+    _operator_fn,
+    comparison_op,
+    eq,
+    ge,
+    gt,
+    ilike_op,
+    in_op,
+    le,
+    lt,
+    ne,
+    regexp_match_op,
+)
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from sqlalchemy.sql.selectable import Select
+
+
+@define
+class FiOp:
+    """Base class for operators.
+
+    Attributes:
+        uniq: The name of the operator.
+        predicate: The predicate function used by the operator.
+    """
+
+    uniq: str
+    predicate: Any
+
+    def apply_filter(
+        self,
+        *,
+        selector: Any,
+        value: Any,
+        selection: "Select[Any]",
+        item: Any,
+    ) -> "Select[Any]":
+        """Append ``predicate(selector, value)`` as a WHERE clause.
+
+        Args:
+            selector: Column or SQL expression passed as the predicate's first
+                argument (same role as in Qt ``QtField.apply_filter``).
+            value: Value passed as the predicate's second argument.
+            selection: Existing SELECT to constrain.
+            item: The originating filter item (for API symmetry with Qt-side
+                call patterns).
+
+        Returns:
+            ``selection`` with the predicate applied via ``WHERE``.
+        """
+        expr = self.predicate(selector, value)
+        return selection.where(expr)
+
+
+@define
+class EqFiOp(FiOp):
+    """General equality operator.
+
+    Attributes:
+        uniq: The name of the operator, set to "eq".
+        predicate: The equality predicate function.
+    """
+
+    uniq: str = field(default="eq", init=False)
+    predicate: Any = field(default=eq)
+
+
+@define
+class NotEqFiOp(FiOp):
+    """Not equal operator.
+
+    Attributes:
+        uniq: The name of the operator, set to "not_eq".
+        predicate: The not equal predicate function.
+    """
+
+    uniq: str = field(default="not_eq", init=False)
+    predicate: Any = field(default=ne)
+
+
+@define
+class ILikeFiOp(FiOp):
+    """Case-insensitive pattern matching operator.
+
+    The provided text should be found inside the target.
+
+    Attributes:
+        uniq: The name of the operator, set to "ilike".
+        predicate: The ILIKE predicate function that handles type
+            casting for non-string columns.
+    """
+
+    uniq: str = field(default="ilike", init=False)
+
+    @staticmethod
+    def _predicate(column: Any, value: Any) -> Any:
+        """Return the ILIKE operator for a column and value.
+
+        Handles type casting for non-string columns to String type.
+        Returns False if the column is not a SQLAlchemy column.
+
+        Args:
+            column: The SQLAlchemy column to apply the operator to.
+            value: The value to match against.
+
+        Returns:
+            The ILIKE operator expression or False if column is invalid.
+        """
+        # op = filter_op_registry[item.op]
+        if hasattr(column, "type"):
+            col_type = column.type.__class__.__name__
+            if col_type not in ("String",):
+                column = al_cast(column, String)
+        else:
+            logger.warning(
+                "ILIKE default implementation only works with "
+                "SQLAlchemy columns. Got: %s (type: %s)",
+                column,
+                type(column),
+            )
+            return False
+
+        return ilike_op(column, value)
+
+    predicate: Any = field(default=_predicate)
+
+
+@define
+class RegexFiOp(FiOp):
+    """Regular expression matching operator.
+
+    The provided pattern should match the target using regex.
+
+    The search is case insensitive (i) and we're using the
+    multi-line (m) flag (^ matches the start of each line, $ matches the end
+    of each line instead of them applying to the whole string).
+
+    Attributes:
+        uniq: The name of the operator, set to "regex".
+        predicate: The regex match predicate function.
+    """
+
+    uniq: str = field(default="regex", init=False)
+    predicate: Any = field(default=partial(regexp_match_op, flags="im"))
+
+
+@comparison_op
+@_operator_fn
+def is_none(a: Any, b: Any) -> Any:
+    """Check if a SQLAlchemy column expression is None.
+
+    Args:
+        a: The column expression to check.
+        b: Unused parameter (required by operator interface).
+
+    Returns:
+        A SQLAlchemy comparison expression checking if a is None.
+    """
+    return a.is_(None)
+
+
+@define
+class IsNoneFiOp(FiOp):
+    """Operator that checks if the target is None.
+
+    Attributes:
+        uniq: The name of the operator, set to "none".
+        predicate: The is None predicate function.
+    """
+
+    uniq: str = field(default="none", init=False)
+    predicate: Any = field(default=is_none)
+
+
+@define
+class GreaterFiOp(FiOp):
+    """Greater than operator.
+
+    The target should be larger than the value.
+
+    Attributes:
+        uniq: The name of the operator, set to "gt".
+        predicate: The greater than predicate function.
+    """
+
+    uniq: str = field(default="gt", init=False)
+    predicate: Any = field(default=gt)
+
+
+@define
+class SmallerFiOp(FiOp):
+    """Less than operator.
+
+    The target should be smaller than the value.
+
+    Attributes:
+        uniq: The name of the operator, set to "lt".
+        predicate: The less than predicate function.
+    """
+
+    uniq: str = field(default="lt", init=False)
+    predicate: Any = field(default=lt)
+
+
+@define
+class GreaterOrEqFiOp(FiOp):
+    """Greater than or equal operator.
+
+    Attributes:
+        uniq: The name of the operator, set to "ge".
+        predicate: The greater-or-equal predicate function.
+    """
+
+    uniq: str = field(default="ge", init=False)
+    predicate: Any = field(default=ge)
+
+
+@define
+class LessOrEqFiOp(FiOp):
+    """Less than or equal operator.
+
+    Attributes:
+        uniq: The name of the operator, set to "le".
+        predicate: The less-or-equal predicate function.
+    """
+
+    uniq: str = field(default="le", init=False)
+    predicate: Any = field(default=le)
+
+
+@define
+class InFiOp(FiOp):
+    """In operator for membership testing.
+
+    The target needs to be one of the values.
+
+    This can be used when the selector is simple and the `column` method
+    can be used to construct the filter. For more complex cases use
+    the `InExFiOp` class.
+
+    Attributes:
+        uniq: The name of the operator, set to "in".
+        predicate: The in predicate function.
+    """
+
+    uniq: str = field(default="in", init=False)
+    predicate: Any = field(default=in_op)
+
+
+@define
+class FiOpRegistry:
+    """Registry for operators.
+
+    Attributes:
+        _registry: The registry of operators.
+    """
+
+    _registry: dict[str, FiOp] = field(factory=dict, repr=False)
+
+    def __attrs_post_init__(self) -> None:
+        """Initialize the registry with all operator instances and aliases.
+
+        Registers all operator classes and their symbolic aliases (e.g.,
+        "==" for "eq", ">" for "gt").
+        """
+        self._registry = {
+            "eq": EqFiOp(),
+            "not_eq": NotEqFiOp(),
+            "ilike": ILikeFiOp(),
+            "regex": RegexFiOp(),
+            "none": IsNoneFiOp(),
+            "gt": GreaterFiOp(),
+            "lt": SmallerFiOp(),
+            "ge": GreaterOrEqFiOp(),
+            "le": LessOrEqFiOp(),
+            "in": InFiOp(),
+        }
+        self._registry["=="] = self._registry["eq"]
+        self._registry["~="] = self._registry["ilike"]
+        self._registry[">"] = self._registry["gt"]
+        self._registry["<"] = self._registry["lt"]
+        self._registry[">="] = self._registry["ge"]
+        self._registry["<="] = self._registry["le"]
+        self._registry["!="] = self._registry["not_eq"]
+        self._registry["ne"] = self._registry["not_eq"]
+        self._registry["gte"] = self._registry["ge"]
+        self._registry["lte"] = self._registry["le"]
+
+    def __getitem__(self, key: str) -> FiOp:
+        """Return the operator by name.
+
+        Args:
+            key: The name of the operator.
+
+        Returns:
+            The operator.
+        """
+        return self._registry[key]
+
+    def get(self, key: str) -> Union[FiOp, None]:
+        """Return the operator by name.
+
+        Args:
+            key: The name of the operator.
+
+        Returns:
+            The operator.
+        """
+        return self._registry.get(key, None)
+
+
+filter_op_registry = FiOpRegistry()

exdrf/utils.py

@@ -0,0 +1,17 @@
+from textwrap import wrap
+from typing import List
+
+import inflect
+
+inflect_e = inflect.engine()
+
+
+def doc_lines(text: str) -> List[str]:
+    """Get the docstring as a set of lines."""
+    docs = (text or "").split("\n")
+    result = []
+    for i, d in enumerate(docs):
+        if i > 0:
+            result.append("")
+        result.extend(wrap(d.strip(), width=70))
+    return result

exdrf/validator.py

@@ -0,0 +1,45 @@
+from typing import Any, Generic, Optional, TypeVar
+
+from attrs import define, field
+
+T = TypeVar("T")
+
+
+@define
+class ValidationResult(Generic[T]):
+    """Validation result class.
+
+    Attributes:
+        result: A code indicating the error.
+        reason: The error message if validation fails.
+        value: The validated value of type T if validation succeeds.
+    """
+
+    reason: Optional[str] = field(default=None)
+    error: Optional[str] = field(default=None)
+    value: Optional[T] = field(default=None)
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if the validation result is valid."""
+        return self.error is None
+
+    @property
+    def is_invalid(self) -> bool:
+        """Check if the validation result is invalid."""
+        return not self.is_valid
+
+
+class Validator(Generic[T]):
+    """A class that can validate a value."""
+
+    def validate_value(self, in_value: Any) -> ValidationResult[T]:
+        """Validate the input value.
+
+        Args:
+            in_value: The value to validate.
+
+        Returns:
+            ValidationResult: The result of the validation.
+        """
+        raise NotImplementedError("Subclasses must implement validate_value method.")