sqlrules 0.1.0__py3-none-any.whl

sqlrules/__init__.py

@@ -0,0 +1,37 @@
+from sqlrules.compiler import Compiler, compile, flatten, where
+from sqlrules.errors import (
+    ConfigurationError,
+    InternalCompilerError,
+    InvalidModelError,
+    InvalidTranslatorError,
+    MissingColumnError,
+    RegistryError,
+    SQLRulesError,
+    TranslatorError,
+    UnsupportedConstraintError,
+)
+from sqlrules.ir import CompilationContext, Constraint, FieldDescriptor
+from sqlrules.translators import SQLRulesWarning
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CompilationContext",
+    "Compiler",
+    "ConfigurationError",
+    "Constraint",
+    "FieldDescriptor",
+    "InternalCompilerError",
+    "InvalidModelError",
+    "InvalidTranslatorError",
+    "MissingColumnError",
+    "RegistryError",
+    "SQLRulesError",
+    "SQLRulesWarning",
+    "TranslatorError",
+    "UnsupportedConstraintError",
+    "__version__",
+    "compile",
+    "flatten",
+    "where",
+]

sqlrules/columns.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.errors import MissingColumnError
+
+
+def _as_column_element(value: Any) -> ColumnElement[Any] | None:
+    """Return a ColumnElement if *value* is (or unwraps to) one."""
+    if isinstance(value, ColumnElement):
+        return value
+    clause_element = getattr(value, "__clause_element__", None)
+    if callable(clause_element):
+        try:
+            unwrapped = clause_element()
+        except Exception:  # pragma: no cover - defensive
+            return None
+        if isinstance(unwrapped, ColumnElement):
+            return unwrapped
+    return None
+
+
+def _candidates(field_name: str, aliases: Sequence[str] | None) -> list[str]:
+    """Build lookup names: aliases first (when set), then the field name."""
+    ordered: list[str] = []
+    if aliases:
+        for alias in aliases:
+            if alias and alias not in ordered:
+                ordered.append(alias)
+    if field_name not in ordered:
+        ordered.append(field_name)
+    return ordered
+
+
+def resolve_column(
+    field_name: str,
+    table: Any,
+    column_map: Mapping[str, ColumnElement[Any]] | None = None,
+    *,
+    alias: str | None = None,
+    aliases: Sequence[str] | None = None,
+) -> ColumnElement[Any]:
+    alias_list: list[str] = []
+    if aliases:
+        alias_list.extend(aliases)
+    elif alias:
+        alias_list.append(alias)
+
+    candidates = _candidates(field_name, alias_list)
+
+    if column_map:
+        for candidate in candidates:
+            if candidate in column_map:
+                column = _as_column_element(column_map[candidate])
+                if column is not None:
+                    return column
+
+    columns = getattr(table, "c", None)
+    if columns is not None:
+        for candidate in candidates:
+            if candidate in columns:
+                column = _as_column_element(columns[candidate])
+                if column is not None:
+                    return column
+
+    # ORM mapped classes expose columns as attributes; only accept clause elements.
+    for candidate in candidates:
+        attr = getattr(table, candidate, None)
+        column = _as_column_element(attr)
+        if column is not None:
+            return column
+
+    raise MissingColumnError(field=field_name)

sqlrules/compiler.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from itertools import chain
+from typing import Any
+
+from pydantic import BaseModel
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.columns import resolve_column
+from sqlrules.constraints import ensure_supported_type, extract_constraints
+from sqlrules.errors import ConfigurationError
+from sqlrules.inspectors import inspect_model
+from sqlrules.ir import CompilationContext, OnUnsupported
+from sqlrules.translators import TranslatorRegistry, default_registry
+
+RulesDict = dict[str, list[ColumnElement[bool]]]
+
+
+class Compiler:
+    def __init__(
+        self,
+        *,
+        registry: TranslatorRegistry | None = None,
+        on_unsupported: OnUnsupported = "raise",
+    ) -> None:
+        if on_unsupported not in {"raise", "warn", "ignore"}:
+            raise ConfigurationError(option="on_unsupported", value=on_unsupported)
+        self.registry = registry or default_registry()
+        self.context = CompilationContext(on_unsupported=on_unsupported)
+
+    def compile(
+        self,
+        model: type[BaseModel],
+        table: Any,
+        *,
+        column_map: Mapping[str, ColumnElement[Any]] | None = None,
+    ) -> RulesDict:
+        rules: RulesDict = {}
+
+        for field in inspect_model(model):
+            ensure_supported_type(field)
+            constraints = extract_constraints(field)
+            if not constraints:
+                continue
+
+            column = resolve_column(
+                field.name,
+                table,
+                column_map,
+                alias=field.alias,
+                aliases=field.aliases,
+            )
+
+            expressions: list[ColumnElement[bool]] = []
+            for constraint in constraints:
+                expression = self.registry.translate(constraint, column, self.context)
+                if expression is not None:
+                    expressions.append(expression)
+
+            if expressions:
+                rules[field.name] = expressions
+
+        return rules
+
+
+def compile(
+    model: type[BaseModel],
+    table: Any,
+    *,
+    column_map: Mapping[str, ColumnElement[Any]] | None = None,
+    on_unsupported: OnUnsupported = "raise",
+) -> RulesDict:
+    return Compiler(on_unsupported=on_unsupported).compile(model, table, column_map=column_map)
+
+
+def flatten(rules: RulesDict) -> list[ColumnElement[bool]]:
+    return list(chain.from_iterable(rules.values()))
+
+
+def where(rules: RulesDict) -> list[ColumnElement[bool]]:
+    return flatten(rules)

sqlrules/constraints.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from types import UnionType
+from typing import Annotated, Any, Literal, Union, get_args, get_origin
+from uuid import UUID
+
+from annotated_types import (
+    Ge,
+    GroupedMetadata,
+    Gt,
+    Le,
+    Lt,
+    MaxLen,
+    MinLen,
+    MultipleOf,
+    Predicate,
+)
+from pydantic.fields import FieldInfo
+
+from sqlrules.errors import UnsupportedConstraintError
+from sqlrules.ir import Constraint, FieldDescriptor
+
+_SUPPORTED_TYPES: frozenset[type[Any]] = frozenset({bool, int, float, Decimal, str, date, datetime})
+_UNSUPPORTED_TYPES: frozenset[type[Any]] = frozenset({UUID, time, timedelta})
+_UNSUPPORTED_ORIGINS: frozenset[Any] = frozenset({list, dict, tuple, set, frozenset})
+_LENGTH_OPERATORS: frozenset[str] = frozenset({"min_length", "max_length"})
+_NUMERIC_OPERATORS: frozenset[str] = frozenset({"gt", "ge", "lt", "le", "multiple_of"})
+_VALIDATOR_TYPE_NAMES = frozenset(
+    {
+        "AfterValidator",
+        "BeforeValidator",
+        "PlainValidator",
+        "WrapValidator",
+        "FieldValidator",
+        "Strict",
+    }
+)
+
+
+def _unwrap_annotation(annotation: Any) -> tuple[Any, tuple[Any, ...]]:
+    """Unwrap Optional/Union[..., None] and Annotated layers.
+
+    Returns the concrete annotation and any metadata collected from Annotated
+    wrappers (used when Pydantic leaves field.metadata empty for
+    ``Annotated[T, ...] | None``).
+    """
+    collected: list[Any] = []
+    current = annotation
+
+    while True:
+        origin = get_origin(current)
+        if origin is Annotated:
+            args = get_args(current)
+            if not args:
+                break
+            current = args[0]
+            collected.extend(args[1:])
+            continue
+        if origin is Union or origin is UnionType:
+            non_none = [arg for arg in get_args(current) if arg is not type(None)]
+            if len(non_none) == 1:
+                current = non_none[0]
+                continue
+        break
+
+    return current, tuple(collected)
+
+
+def _iter_metadata(metadata: Any) -> Any:
+    for item in metadata:
+        if item is None:
+            continue
+        if isinstance(item, GroupedMetadata):
+            yield from _iter_metadata(item)
+        elif isinstance(item, FieldInfo):
+            # Annotated[..., Field(...)] | None leaves FieldInfo in the annotation
+            # metadata when field.metadata is empty.
+            yield from _iter_metadata(item.metadata)
+        else:
+            yield item
+
+
+def _field_metadata(field: FieldDescriptor) -> tuple[Any, ...]:
+    if field.metadata:
+        return field.metadata
+    _, annotated_metadata = _unwrap_annotation(field.annotation)
+    return annotated_metadata
+
+
+def _concrete_type(field: FieldDescriptor) -> Any:
+    annotation, _ = _unwrap_annotation(field.annotation)
+    return annotation
+
+
+def ensure_supported_type(field: FieldDescriptor) -> None:
+    """Raise when a field annotation is outside the v0.1 support matrix."""
+    annotation = _concrete_type(field)
+    origin = get_origin(annotation)
+
+    if origin is Literal:
+        return
+
+    if origin in _UNSUPPORTED_ORIGINS:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=getattr(origin, "__name__", str(origin)),
+            value=annotation,
+            suggestion=(
+                "Remove the field or wait for a future SQLRules release with container support."
+            ),
+        )
+
+    if isinstance(annotation, type) and issubclass(annotation, Enum):
+        return
+
+    if annotation in _SUPPORTED_TYPES:
+        return
+
+    if annotation in _UNSUPPORTED_TYPES or (
+        isinstance(annotation, type) and annotation in _UNSUPPORTED_TYPES
+    ):
+        type_name = getattr(annotation, "__name__", str(annotation))
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=type_name,
+            value=annotation,
+            suggestion=f"Type {type_name!r} is not supported in SQLRules 0.1.",
+        )
+
+    # Unions with multiple non-None members and other unknown annotations.
+    type_name = getattr(annotation, "__name__", repr(annotation))
+    raise UnsupportedConstraintError(
+        field=field.name,
+        operator="type",
+        value=annotation,
+        suggestion=f"Annotation {type_name} is outside the SQLRules 0.1 type support matrix.",
+    )
+
+
+def _unsupported_constraints(field_name: str, item: Any) -> list[Constraint]:
+    if isinstance(item, Predicate):
+        return [Constraint(field_name, "predicate", item.func)]
+
+    type_name = type(item).__name__
+    if type_name in _VALIDATOR_TYPE_NAMES:
+        return [
+            Constraint(
+                field_name,
+                type_name,
+                getattr(item, "func", getattr(item, "strict", item)),
+            )
+        ]
+
+    data = getattr(item, "__dict__", None)
+    if isinstance(data, dict) and data:
+        return [
+            Constraint(field_name, key, value) for key, value in data.items() if value is not None
+        ]
+
+    return [Constraint(field_name, type_name, item)]
+
+
+def _reject_type_operator_mismatch(field: FieldDescriptor, constraint: Constraint) -> None:
+    annotation = _concrete_type(field)
+    origin = get_origin(annotation)
+
+    if origin is Literal:
+        if (
+            constraint.operator not in {"literal", "enum"}
+            and constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS
+        ):
+            raise UnsupportedConstraintError(
+                field=field.name,
+                operator=constraint.operator,
+                value=constraint.value,
+                suggestion=(f"Constraint {constraint.operator!r} is not valid for Literal fields."),
+            )
+        return
+
+    if isinstance(annotation, type) and issubclass(annotation, Enum):
+        if constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS:
+            raise UnsupportedConstraintError(
+                field=field.name,
+                operator=constraint.operator,
+                value=constraint.value,
+                suggestion=f"Constraint {constraint.operator!r} is not valid for Enum fields.",
+            )
+        return
+
+    if annotation is bool and constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion=(
+                "Bool fields only support Literal/equality-style constraints in SQLRules 0.1."
+            ),
+        )
+
+    if constraint.operator in _LENGTH_OPERATORS and annotation is not str:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion="Length constraints require a str field annotation.",
+        )
+
+    if constraint.operator in _NUMERIC_OPERATORS and annotation is str:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion="Numeric comparison constraints are not valid for str fields.",
+        )
+
+
+def extract_constraints(field: FieldDescriptor) -> list[Constraint]:
+    constraints: list[Constraint] = []
+
+    for item in _iter_metadata(_field_metadata(field)):
+        if isinstance(item, Gt):
+            constraints.append(Constraint(field.name, "gt", item.gt))
+        elif isinstance(item, Ge):
+            constraints.append(Constraint(field.name, "ge", item.ge))
+        elif isinstance(item, Lt):
+            constraints.append(Constraint(field.name, "lt", item.lt))
+        elif isinstance(item, Le):
+            constraints.append(Constraint(field.name, "le", item.le))
+        elif isinstance(item, MultipleOf):
+            constraints.append(Constraint(field.name, "multiple_of", item.multiple_of))
+        elif isinstance(item, MinLen):
+            constraints.append(Constraint(field.name, "min_length", item.min_length))
+        elif isinstance(item, MaxLen):
+            constraints.append(Constraint(field.name, "max_length", item.max_length))
+        else:
+            constraints.extend(_unsupported_constraints(field.name, item))
+
+    annotation = _concrete_type(field)
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    if origin is Literal:
+        constraints.append(Constraint(field.name, "literal", args))
+
+    if isinstance(annotation, type) and issubclass(annotation, Enum):
+        values = tuple(member.value for member in annotation)
+        constraints.append(Constraint(field.name, "enum", values))
+
+    for constraint in constraints:
+        if constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS:
+            _reject_type_operator_mismatch(field, constraint)
+
+    return constraints

sqlrules/errors.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+class SQLRulesError(Exception):
+    """Base class for all public SQLRules exceptions."""
+
+
+@dataclass(slots=True)
+class InvalidModelError(SQLRulesError):
+    model: Any
+
+    def __str__(self) -> str:
+        return (
+            f"Expected a Pydantic BaseModel subclass, got {self.model!r}. "
+            "Pass a model class such as class UserFilter(BaseModel): ..."
+        )
+
+
+@dataclass(slots=True)
+class MissingColumnError(SQLRulesError):
+    field: str
+
+    def __str__(self) -> str:
+        return (
+            f"No SQLAlchemy column found for field {self.field!r}. "
+            "Provide a matching table column, ORM attribute, or column_map entry."
+        )
+
+
+@dataclass(slots=True)
+class UnsupportedConstraintError(SQLRulesError):
+    field: str
+    operator: str
+    value: Any = None
+    suggestion: str | None = None
+
+    def __str__(self) -> str:
+        message = (
+            f"Field {self.field!r}: constraint {self.operator!r} is not supported by SQLRules 0.1."
+        )
+        if self.suggestion:
+            return f"{message} {self.suggestion}"
+        return f"{message} Remove the constraint, or set on_unsupported='warn'/'ignore'."
+
+
+@dataclass(slots=True)
+class TranslatorError(SQLRulesError):
+    field: str
+    operator: str
+    message: str
+
+    def __str__(self) -> str:
+        return (
+            f"Translator failed for field {self.field!r}, "
+            f"operator {self.operator!r}: {self.message}"
+        )
+
+
+@dataclass(slots=True)
+class InvalidTranslatorError(SQLRulesError):
+    operator: str
+    translator: Any
+
+    def __str__(self) -> str:
+        return (
+            f"Invalid translator for operator {self.operator!r}: {self.translator!r}. "
+            "Translators must be callables returning a SQLAlchemy boolean expression."
+        )
+
+
+@dataclass(slots=True)
+class RegistryError(SQLRulesError):
+    message: str
+
+    def __str__(self) -> str:
+        return self.message
+
+
+@dataclass(slots=True)
+class ConfigurationError(SQLRulesError):
+    option: str
+    value: Any
+
+    def __str__(self) -> str:
+        return (
+            f"Invalid configuration value for {self.option!r}: {self.value!r}. "
+            "Use one of: 'raise', 'warn', 'ignore'."
+            if self.option == "on_unsupported"
+            else f"Invalid configuration value for {self.option!r}: {self.value!r}."
+        )
+
+
+class InternalCompilerError(SQLRulesError):
+    """Unexpected internal compiler failure."""

sqlrules/inspectors.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import AliasChoices, AliasPath, BaseModel
+
+from sqlrules.errors import InvalidModelError
+from sqlrules.ir import FieldDescriptor
+
+
+def _string_alias(value: Any) -> str | None:
+    if isinstance(value, str):
+        return value
+    return None
+
+
+def _field_aliases(field: Any) -> tuple[str | None, tuple[str, ...]]:
+    """Return primary alias and extra string alias candidates for column binding."""
+    aliases: list[str] = []
+
+    primary = _string_alias(field.alias)
+    if primary:
+        aliases.append(primary)
+
+    for attr in ("validation_alias", "serialization_alias"):
+        value = getattr(field, attr, None)
+        # AliasPath / AliasChoices are not used for column binding in 0.1.
+        if isinstance(value, (AliasPath, AliasChoices)):
+            continue
+        candidate = _string_alias(value)
+        if candidate and candidate not in aliases:
+            aliases.append(candidate)
+
+    primary_alias = aliases[0] if aliases else None
+    return primary_alias, tuple(aliases)
+
+
+def inspect_model(model: type[BaseModel]) -> list[FieldDescriptor]:
+    if not isinstance(model, type) or not issubclass(model, BaseModel):
+        raise InvalidModelError(model=model)
+
+    descriptors: list[FieldDescriptor] = []
+    for name, field in model.model_fields.items():
+        primary_alias, aliases = _field_aliases(field)
+        descriptors.append(
+            FieldDescriptor(
+                name=name,
+                alias=primary_alias,
+                aliases=aliases,
+                annotation=field.annotation,
+                metadata=tuple(field.metadata),
+            )
+        )
+    return descriptors

sqlrules/ir.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+OnUnsupported = Literal["raise", "warn", "ignore"]
+
+
+@dataclass(frozen=True, slots=True)
+class Constraint:
+    field: str
+    operator: str
+    value: Any
+
+
+@dataclass(frozen=True, slots=True)
+class FieldDescriptor:
+    name: str
+    alias: str | None
+    annotation: Any
+    metadata: tuple[Any, ...] = ()
+    aliases: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class CompilationContext:
+    on_unsupported: OnUnsupported = "raise"
+    diagnostics: tuple[str, ...] = field(default_factory=tuple)

sqlrules/translators.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import operator
+import warnings
+from collections.abc import Callable
+from typing import Any, cast
+
+from sqlalchemy import func
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.errors import RegistryError, TranslatorError, UnsupportedConstraintError
+from sqlrules.ir import CompilationContext, Constraint
+
+Translator = Callable[[Constraint, ColumnElement[Any], CompilationContext], ColumnElement[bool]]
+
+
+class SQLRulesWarning(UserWarning):
+    """Warning emitted when an unsupported constraint is skipped."""
+
+
+def _binary(op: Callable[[Any, Any], Any]) -> Translator:
+    def translate(
+        constraint: Constraint,
+        column: ColumnElement[Any],
+        context: CompilationContext,
+    ) -> ColumnElement[bool]:
+        return cast(ColumnElement[bool], op(column, constraint.value))
+
+    return translate
+
+
+def _multiple_of(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    value = constraint.value
+    try:
+        non_positive = value <= 0
+    except TypeError as exc:
+        raise UnsupportedConstraintError(
+            field=constraint.field,
+            operator="multiple_of",
+            value=value,
+            suggestion="multiple_of requires a positive numeric value.",
+        ) from exc
+    if non_positive:
+        raise UnsupportedConstraintError(
+            field=constraint.field,
+            operator="multiple_of",
+            value=value,
+            suggestion="multiple_of requires a positive numeric value.",
+        )
+    return cast(ColumnElement[bool], (column % value) == 0)
+
+
+def _min_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    return cast(ColumnElement[bool], func.length(column) >= constraint.value)
+
+
+def _max_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    return cast(ColumnElement[bool], func.length(column) <= constraint.value)
+
+
+def _in_values(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    return cast(ColumnElement[bool], column.in_(constraint.value))
+
+
+class TranslatorRegistry:
+    def __init__(self) -> None:
+        self._translators: dict[str, Translator] = {}
+
+    def register(
+        self,
+        operator_name: str,
+        translator: Translator,
+        *,
+        replace: bool = False,
+    ) -> None:
+        if not replace and operator_name in self._translators:
+            raise RegistryError(f"Translator for {operator_name!r} is already registered.")
+        self._translators[operator_name] = translator
+
+    def lookup(self, operator_name: str) -> Translator | None:
+        return self._translators.get(operator_name)
+
+    def translate(
+        self,
+        constraint: Constraint,
+        column: ColumnElement[Any],
+        context: CompilationContext,
+    ) -> ColumnElement[bool] | None:
+        translator = self.lookup(constraint.operator)
+        if translator is None:
+            if context.on_unsupported == "raise":
+                raise UnsupportedConstraintError(
+                    field=constraint.field,
+                    operator=constraint.operator,
+                    value=constraint.value,
+                    suggestion=("Remove the constraint, or set on_unsupported='warn'/'ignore'."),
+                )
+            if context.on_unsupported == "warn":
+                # sqlrules.compile → Compiler.compile → translate → warn
+                # stacklevel=4 attributes the warning to the caller's code.
+                warnings.warn(
+                    (
+                        f"Field {constraint.field!r}: constraint {constraint.operator!r} "
+                        "is not supported and will be skipped."
+                    ),
+                    SQLRulesWarning,
+                    stacklevel=4,
+                )
+            return None
+
+        try:
+            return translator(constraint, column, context)
+        except UnsupportedConstraintError:
+            raise
+        except Exception as exc:  # pragma: no cover - defensive wrapper
+            raise TranslatorError(
+                field=constraint.field,
+                operator=constraint.operator,
+                message=str(exc),
+            ) from exc
+
+
+def default_registry() -> TranslatorRegistry:
+    registry = TranslatorRegistry()
+    registry.register("gt", _binary(operator.gt))
+    registry.register("ge", _binary(operator.ge))
+    registry.register("lt", _binary(operator.lt))
+    registry.register("le", _binary(operator.le))
+    registry.register("multiple_of", _multiple_of)
+    registry.register("min_length", _min_length)
+    registry.register("max_length", _max_length)
+    registry.register("literal", _in_values)
+    registry.register("enum", _in_values)
+    return registry

sqlrules-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: sqlrules
+Version: 0.1.0
+Summary: Compile constrained Pydantic models into SQLAlchemy WHERE-rule dictionaries.
+Project-URL: Homepage, https://github.com/eddiethedean/sqlrules
+Project-URL: Documentation, https://github.com/eddiethedean/sqlrules#readme
+Project-URL: Repository, https://github.com/eddiethedean/sqlrules
+Project-URL: Changelog, https://github.com/eddiethedean/sqlrules/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/eddiethedean/sqlrules/issues
+Author: SQLRules Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: compiler,constraints,filters,pydantic,sqlalchemy,where
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: annotated-types>=0.6
+Requires-Dist: pydantic>=2.0
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=3.7; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# SQLRules
+
+**Compile constrained Pydantic models into SQLAlchemy WHERE-rule dictionaries.**
+
+One package. One job. Deterministic output. Zero database dependency.
+
+```python
+from typing import Annotated
+from pydantic import BaseModel, Field
+from sqlalchemy import Table, Column, Integer, String, MetaData
+
+import sqlrules
+
+metadata = MetaData()
+
+users = Table(
+    "users",
+    metadata,
+    Column("age", Integer),
+    Column("name", String),
+)
+
+class UserFilter(BaseModel):
+    age: Annotated[int, Field(ge=18, le=65)]
+    name: Annotated[str, Field(min_length=2)]
+
+rules = sqlrules.compile(UserFilter, users)
+# {
+#     "age": [users.c.age >= 18, users.c.age <= 65],
+#     "name": [func.length(users.c.name) >= 2],
+# }
+
+stmt = users.select().where(*sqlrules.where(rules))
+```
+
+## Install
+
+```bash
+pip install sqlrules
+```
+
+Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
+
+## Supported constraints (0.1)
+
+| Constraint | SQLAlchemy expression |
+|---|---|
+| `gt` / `ge` / `lt` / `le` | `column > / >= / < / <= value` |
+| `multiple_of` | `column % value == 0` |
+| `min_length` / `max_length` | `func.length(column) >= / <= value` |
+| `Literal[...]` | `column.in_(...)` |
+| `Enum` | `column.in_(...)` |
+
+Unsupported constraints raise `UnsupportedConstraintError` by default.
+Use `on_unsupported="warn"` or `"ignore"` to change that policy for unknown
+constraint operators (unsupported types always raise).
+
+## Public API
+
+```python
+sqlrules.compile(model, table, *, column_map=None, on_unsupported="raise")
+sqlrules.where(rules)    # flatten all expressions
+sqlrules.flatten(rules)  # alias of where()
+```
+
+## Non-goals
+
+SQLRules is not an ORM, validator, query builder, SQL string generator,
+migration tool, or database client. It only compiles supported Pydantic
+constraints into SQLAlchemy expressions.
+
+## Documentation
+
+See [`docs/index.md`](docs/index.md) for the full documentation set,
+including the [spec](docs/SPEC.md), [API](docs/API.md),
+[architecture](docs/ARCHITECTURE.md), and [roadmap](docs/ROADMAP.md).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+mypy src/sqlrules
+```
+
+## License
+
+MIT

sqlrules-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+sqlrules/__init__.py,sha256=51kBzKMVXNdUUgWNYzKcSFJfPA3ZlX2OiFUfZ7aljss,875
+sqlrules/columns.py,sha256=AKLzYvYkHC-jIMPXMDLj37kUUPU3hIHCDoZYhwa9064,2373
+sqlrules/compiler.py,sha256=iIPNGq5TN2cQ21HtrG6uRaYqksDfdvKE9h5KrnjHZu4,2529
+sqlrules/constraints.py,sha256=oSgNzzstRxyskeKddQTNo6Cbgc_tXnx8A4KYY7_a4po,8921
+sqlrules/errors.py,sha256=5R-tj_TROF_aWBcB-zB-e2crmAri3hhEH7bZlslyN5w,2537
+sqlrules/inspectors.py,sha256=h6TsUVyLTyNie0up3ZM1QLReYtKBlHBcwDbJxbS8gGs,1707
+sqlrules/ir.py,sha256=gdz9u2pnVM8WTjdUCTq1MdKA3U_NV3paVwqZqG1pc8Q,623
+sqlrules/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules/translators.py,sha256=mKTcSPMZewqpjVRf58iGyZJlATTyYFZmklLz3qXNIjs,4955
+sqlrules-0.1.0.dist-info/METADATA,sha256=d9QCDHGEdUA_mr_mSFReh8wGcdaGV-3-Lj1Wdk7doZo,3788
+sqlrules-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sqlrules-0.1.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules-0.1.0.dist-info/RECORD,,

sqlrules-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlrules-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SQLRules Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.