sqlrules 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

sqlrules/__init__.py

@@ -10,21 +10,31 @@ from sqlrules.errors import (
     TranslatorError,
     UnsupportedConstraintError,
 )
-from sqlrules.ir import CompilationContext, Constraint, FieldDescriptor
+from sqlrules.ir import (
+    CompilationContext,
+    Constraint,
+    Diagnostic,
+    FieldDescriptor,
+    FieldIR,
+    ModelIR,
+)
 from sqlrules.translators import SQLRulesWarning
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "CompilationContext",
     "Compiler",
     "ConfigurationError",
     "Constraint",
+    "Diagnostic",
     "FieldDescriptor",
+    "FieldIR",
     "InternalCompilerError",
     "InvalidModelError",
     "InvalidTranslatorError",
     "MissingColumnError",
+    "ModelIR",
     "RegistryError",
     "SQLRulesError",
     "SQLRulesWarning",

sqlrules/cache.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import threading
+from typing import Any
+from weakref import WeakKeyDictionary
+
+from sqlrules.ir import ModelIR
+
+
+class ModelIRCache:
+    """Thread-safe in-process cache of Phase-1 ModelIR keyed by model class.
+
+    Cached values are immutable and may be shared across threads. Column
+    objects are never stored here.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._store: WeakKeyDictionary[type[Any], ModelIR] = WeakKeyDictionary()
+
+    def get(self, model: type[Any]) -> ModelIR | None:
+        with self._lock:
+            return self._store.get(model)
+
+    def put(self, model: type[Any], model_ir: ModelIR) -> ModelIR:
+        with self._lock:
+            self._store[model] = model_ir
+            return model_ir
+
+    def clear(self) -> None:
+        with self._lock:
+            self._store.clear()
+
+
+# Shared default cache for Compiler instances with cache=True.
+_default_cache = ModelIRCache()
+
+
+def default_cache() -> ModelIRCache:
+    return _default_cache

sqlrules/columns.py

@@ -55,8 +55,9 @@ def resolve_column(
         for candidate in candidates:
             if candidate in column_map:
                 column = _as_column_element(column_map[candidate])
-                if column is not None:
-                    return column
+                if column is None:
+                    raise MissingColumnError(field=field_name)
+                return column
 
     columns = getattr(table, "c", None)
     if columns is not None:

sqlrules/compiler.py

@@ -7,11 +7,19 @@ from typing import Any
 from pydantic import BaseModel
 from sqlalchemy.sql.elements import ColumnElement
 
+from sqlrules.cache import ModelIRCache, default_cache
 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.ir import (
+    CompilationContext,
+    Diagnostic,
+    DiagnosticsCollector,
+    FieldIR,
+    ModelIR,
+    OnUnsupported,
+)
 from sqlrules.translators import TranslatorRegistry, default_registry
 
 RulesDict = dict[str, list[ColumnElement[bool]]]
@@ -23,46 +31,94 @@ class Compiler:
         *,
         registry: TranslatorRegistry | None = None,
         on_unsupported: OnUnsupported = "raise",
+        cache: bool = True,
+        model_cache: ModelIRCache | None = None,
     ) -> 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.on_unsupported = on_unsupported
+        self.cache_enabled = cache
+        self._model_cache = model_cache if model_cache is not None else default_cache()
+        self._collector = DiagnosticsCollector()
+        self.context = CompilationContext(
+            on_unsupported=on_unsupported,
+            collector=self._collector,
+        )
+
+    @property
+    def diagnostics(self) -> tuple[Diagnostic, ...]:
+        """Diagnostics from the most recent ``compile`` / ``bind`` call."""
+        return self._collector.snapshot()
+
+    def compile_model(self, model: type[BaseModel]) -> ModelIR:
+        """Phase 1: inspect the model and extract constraint IR (no table binding)."""
+        self._collector.clear()
+        if self.cache_enabled:
+            cached = self._model_cache.get(model)
+            if cached is not None:
+                return cached
+
+        fields: list[FieldIR] = []
+        for descriptor in inspect_model(model):
+            ensure_supported_type(descriptor)
+            constraints = tuple(extract_constraints(descriptor))
+            fields.append(FieldIR(descriptor=descriptor, constraints=constraints))
+
+        model_ir = ModelIR(model=model, fields=tuple(fields))
+        if self.cache_enabled:
+            return self._model_cache.put(model, model_ir)
+        return model_ir
+
+    def bind(
         self,
-        model: type[BaseModel],
+        model_ir: ModelIR,
         table: Any,
         *,
         column_map: Mapping[str, ColumnElement[Any]] | None = None,
     ) -> RulesDict:
-        rules: RulesDict = {}
+        """Phase 2: resolve columns and translate IR into SQLAlchemy expressions."""
+        self._collector.clear()
+        # Refresh context in case on_unsupported was mutated (should not be).
+        self.context = CompilationContext(
+            on_unsupported=self.on_unsupported,
+            collector=self._collector,
+        )
 
-        for field in inspect_model(model):
-            ensure_supported_type(field)
-            constraints = extract_constraints(field)
-            if not constraints:
+        rules: RulesDict = {}
+        for field_ir in model_ir.fields:
+            if not field_ir.constraints:
                 continue
 
+            descriptor = field_ir.descriptor
             column = resolve_column(
-                field.name,
+                descriptor.name,
                 table,
                 column_map,
-                alias=field.alias,
-                aliases=field.aliases,
+                alias=descriptor.alias,
+                aliases=descriptor.aliases,
             )
 
             expressions: list[ColumnElement[bool]] = []
-            for constraint in constraints:
+            for constraint in field_ir.constraints:
                 expression = self.registry.translate(constraint, column, self.context)
                 if expression is not None:
                     expressions.append(expression)
 
             if expressions:
-                rules[field.name] = expressions
+                rules[descriptor.name] = expressions
 
         return rules
 
+    def compile(
+        self,
+        model: type[BaseModel],
+        table: Any,
+        *,
+        column_map: Mapping[str, ColumnElement[Any]] | None = None,
+    ) -> RulesDict:
+        return self.bind(self.compile_model(model), table, column_map=column_map)
+
 
 def compile(
     model: type[BaseModel],
@@ -70,8 +126,11 @@ def compile(
     *,
     column_map: Mapping[str, ColumnElement[Any]] | None = None,
     on_unsupported: OnUnsupported = "raise",
+    cache: bool = True,
 ) -> RulesDict:
-    return Compiler(on_unsupported=on_unsupported).compile(model, table, column_map=column_map)
+    return Compiler(on_unsupported=on_unsupported, cache=cache).compile(
+        model, table, column_map=column_map
+    )
 
 
 def flatten(rules: RulesDict) -> list[ColumnElement[bool]]:

sqlrules/constraints.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from enum import Enum
@@ -23,11 +24,14 @@ 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})
+_SUPPORTED_TYPES: frozenset[type[Any]] = frozenset(
+    {bool, int, float, Decimal, str, date, datetime, time, UUID}
+)
+_UNSUPPORTED_TYPES: frozenset[type[Any]] = frozenset({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"})
+_TEMPORAL_TYPES: frozenset[type[Any]] = frozenset({date, datetime, time})
 _VALIDATOR_TYPE_NAMES = frozenset(
     {
         "AfterValidator",
@@ -38,6 +42,33 @@ _VALIDATOR_TYPE_NAMES = frozenset(
         "Strict",
     }
 )
+# Keys that map to IR constraint operators.
+_CONSTRAINT_KEYS: frozenset[str] = frozenset(
+    {
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "multiple_of",
+        "min_length",
+        "max_length",
+        "pattern",
+        "max_digits",
+        "decimal_places",
+    }
+)
+# Pydantic / StringConstraints flags that are validation-only (not SQL operators).
+_IGNORED_METADATA_KEYS: frozenset[str] = frozenset(
+    {
+        "strip_whitespace",
+        "to_upper",
+        "to_lower",
+        "strict",
+        "allow_inf_nan",
+        "ascii_only",
+        "coerce_numbers_to_str",
+    }
+)
 
 
 def _unwrap_annotation(annotation: Any) -> tuple[Any, tuple[Any, ...]]:
@@ -96,7 +127,7 @@ def _concrete_type(field: FieldDescriptor) -> Any:
 
 
 def ensure_supported_type(field: FieldDescriptor) -> None:
-    """Raise when a field annotation is outside the v0.1 support matrix."""
+    """Raise when a field annotation is outside the support matrix."""
     annotation = _concrete_type(field)
     origin = get_origin(annotation)
 
@@ -127,7 +158,7 @@ def ensure_supported_type(field: FieldDescriptor) -> None:
             field=field.name,
             operator=type_name,
             value=annotation,
-            suggestion=f"Type {type_name!r} is not supported in SQLRules 0.1.",
+            suggestion=f"Type {type_name!r} is not supported by SQLRules.",
         )
 
     # Unions with multiple non-None members and other unknown annotations.
@@ -136,10 +167,41 @@ def ensure_supported_type(field: FieldDescriptor) -> None:
         field=field.name,
         operator="type",
         value=annotation,
-        suggestion=f"Annotation {type_name} is outside the SQLRules 0.1 type support matrix.",
+        suggestion=f"Annotation {type_name} is outside the SQLRules type support matrix.",
+    )
+
+
+def _normalize_pattern(field_name: str, pattern: Any) -> str:
+    if isinstance(pattern, str):
+        return pattern
+    if isinstance(pattern, re.Pattern):
+        return str(pattern.pattern)
+    raise UnsupportedConstraintError(
+        field=field_name,
+        operator="pattern",
+        value=pattern,
+        suggestion="pattern must be a str or re.Pattern.",
     )
 
 
+def _constraints_from_mapping(field_name: str, data: dict[str, Any]) -> list[Constraint]:
+    """Map whitelisted metadata keys into IR; ignore validation-only flags."""
+    constraints: list[Constraint] = []
+    for key, value in data.items():
+        if value is None or key in _IGNORED_METADATA_KEYS:
+            continue
+        if key == "pattern":
+            constraints.append(
+                Constraint(field_name, "pattern", _normalize_pattern(field_name, value))
+            )
+        elif key in _CONSTRAINT_KEYS:
+            constraints.append(Constraint(field_name, key, value))
+        else:
+            # Unknown keys remain unsupported operators (fail-fast).
+            constraints.append(Constraint(field_name, key, value))
+    return constraints
+
+
 def _unsupported_constraints(field_name: str, item: Any) -> list[Constraint]:
     if isinstance(item, Predicate):
         return [Constraint(field_name, "predicate", item.func)]
@@ -154,11 +216,25 @@ def _unsupported_constraints(field_name: str, item: Any) -> list[Constraint]:
             )
         ]
 
+    # First-class pattern attribute (e.g. _PydanticGeneralMetadata(pattern=...)).
+    pattern = getattr(item, "pattern", None)
+    if pattern is not None and isinstance(pattern, (str, re.Pattern)):
+        constraints = _constraints_from_mapping(
+            field_name,
+            {
+                key: value
+                for key, value in getattr(item, "__dict__", {}).items()
+                if key != "pattern" and value is not None
+            },
+        )
+        constraints.append(
+            Constraint(field_name, "pattern", _normalize_pattern(field_name, pattern))
+        )
+        return constraints
+
     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 _constraints_from_mapping(field_name, data)
 
     return [Constraint(field_name, type_name, item)]
 
@@ -191,12 +267,29 @@ def _reject_type_operator_mismatch(field: FieldDescriptor, constraint: Constrain
         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."),
+        )
+
+    if annotation is UUID and constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion=("UUID fields only support Literal/Enum-style constraints in SQLRules."),
+        )
+
+    if annotation in _TEMPORAL_TYPES and constraint.operator == "multiple_of":
         raise UnsupportedConstraintError(
             field=field.name,
             operator=constraint.operator,
             value=constraint.value,
             suggestion=(
-                "Bool fields only support Literal/equality-style constraints in SQLRules 0.1."
+                "multiple_of is not valid for date/datetime/time fields; "
+                "use gt/ge/lt/le range constraints."
             ),
         )
 
@@ -216,6 +309,14 @@ def _reject_type_operator_mismatch(field: FieldDescriptor, constraint: Constrain
             suggestion="Numeric comparison constraints are not valid for str fields.",
         )
 
+    if constraint.operator == "pattern" and annotation is not str:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion="pattern constraints require a str field annotation.",
+        )
+
 
 def extract_constraints(field: FieldDescriptor) -> list[Constraint]:
     constraints: list[Constraint] = []
@@ -250,7 +351,7 @@ def extract_constraints(field: FieldDescriptor) -> list[Constraint]:
         constraints.append(Constraint(field.name, "enum", values))
 
     for constraint in constraints:
-        if constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS:
+        if constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS | {"pattern"}:
             _reject_type_operator_mismatch(field, constraint)
 
     return constraints

sqlrules/errors.py

@@ -39,7 +39,7 @@ class UnsupportedConstraintError(SQLRulesError):
 
     def __str__(self) -> str:
         message = (
-            f"Field {self.field!r}: constraint {self.operator!r} is not supported by SQLRules 0.1."
+            f"Field {self.field!r}: constraint {self.operator!r} is not supported by SQLRules."
         )
         if self.suggestion:
             return f"{message} {self.suggestion}"

sqlrules/inspectors.py

@@ -24,7 +24,7 @@ def _field_aliases(field: Any) -> tuple[str | None, tuple[str, ...]]:
 
     for attr in ("validation_alias", "serialization_alias"):
         value = getattr(field, attr, None)
-        # AliasPath / AliasChoices are not used for column binding in 0.1.
+        # AliasPath / AliasChoices are not used for column binding.
         if isinstance(value, (AliasPath, AliasChoices)):
             continue
         candidate = _string_alias(value)

sqlrules/ir.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any, Literal
 
 OnUnsupported = Literal["raise", "warn", "ignore"]
+DiagnosticSeverity = Literal["warning", "info"]
 
 
 @dataclass(frozen=True, slots=True)
@@ -22,7 +23,65 @@ class FieldDescriptor:
     aliases: tuple[str, ...] = ()
 
 
+@dataclass(frozen=True, slots=True)
+class Diagnostic:
+    severity: DiagnosticSeverity
+    field: str
+    operator: str
+    value: Any = None
+    message: str = ""
+
+
+@dataclass(slots=True)
+class DiagnosticsCollector:
+    """Mutable collector; snapshots are immutable tuples."""
+
+    _items: list[Diagnostic] = field(default_factory=list)
+
+    def add(self, diagnostic: Diagnostic) -> None:
+        self._items.append(diagnostic)
+
+    def clear(self) -> None:
+        self._items.clear()
+
+    def snapshot(self) -> tuple[Diagnostic, ...]:
+        return tuple(self._items)
+
+
 @dataclass(frozen=True, slots=True)
 class CompilationContext:
     on_unsupported: OnUnsupported = "raise"
-    diagnostics: tuple[str, ...] = field(default_factory=tuple)
+    collector: DiagnosticsCollector | None = None
+
+    def record(
+        self,
+        *,
+        severity: DiagnosticSeverity,
+        field: str,
+        operator: str,
+        value: Any = None,
+        message: str = "",
+    ) -> None:
+        if self.collector is None:
+            return
+        self.collector.add(
+            Diagnostic(
+                severity=severity,
+                field=field,
+                operator=operator,
+                value=value,
+                message=message,
+            )
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class FieldIR:
+    descriptor: FieldDescriptor
+    constraints: tuple[Constraint, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelIR:
+    model: type[Any]
+    fields: tuple[FieldIR, ...]

sqlrules/translators.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import operator
+import sys
+import types
 import warnings
 from collections.abc import Callable
 from typing import Any, cast
@@ -18,6 +20,19 @@ class SQLRulesWarning(UserWarning):
     """Warning emitted when an unsupported constraint is skipped."""
 
 
+def _warning_stacklevel() -> int:
+    """Stacklevel that attributes warnings to the first frame outside sqlrules."""
+    frame: types.FrameType | None = sys._getframe(1)
+    level = 1
+    while frame is not None:
+        module = frame.f_globals.get("__name__", "")
+        if not (isinstance(module, str) and module.startswith("sqlrules")):
+            return level
+        frame = frame.f_back
+        level += 1
+    return 2
+
+
 def _binary(op: Callable[[Any, Any], Any]) -> Translator:
     def translate(
         constraint: Constraint,
@@ -104,6 +119,10 @@ class TranslatorRegistry:
     ) -> ColumnElement[bool] | None:
         translator = self.lookup(constraint.operator)
         if translator is None:
+            message = (
+                f"Field {constraint.field!r}: constraint {constraint.operator!r} "
+                "is not supported and will be skipped."
+            )
             if context.on_unsupported == "raise":
                 raise UnsupportedConstraintError(
                     field=constraint.field,
@@ -112,15 +131,21 @@ class TranslatorRegistry:
                     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,
+                context.record(
+                    severity="warning",
+                    field=constraint.field,
+                    operator=constraint.operator,
+                    value=constraint.value,
+                    message=message,
+                )
+                warnings.warn(message, SQLRulesWarning, stacklevel=_warning_stacklevel())
+            else:
+                context.record(
+                    severity="info",
+                    field=constraint.field,
+                    operator=constraint.operator,
+                    value=constraint.value,
+                    message=message,
                 )
             return None
 
@@ -147,4 +172,5 @@ def default_registry() -> TranslatorRegistry:
     registry.register("max_length", _max_length)
     registry.register("literal", _in_values)
     registry.register("enum", _in_values)
+    # pattern is extracted into IR but has no portable core translator.
     return registry

{sqlrules-0.1.0.dist-info → sqlrules-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrules
-Version: 0.1.0
+Version: 0.2.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
@@ -29,11 +29,13 @@ Requires-Dist: annotated-types>=0.6
 Requires-Dist: pydantic>=2.0
 Requires-Dist: sqlalchemy>=2.0
 Provides-Extra: dev
+Requires-Dist: build>=1.2; 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'
+Requires-Dist: twine>=5.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # SQLRules
@@ -79,7 +81,7 @@ pip install sqlrules
 
 Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
 
-## Supported constraints (0.1)
+## Supported constraints (0.2)
 
 | Constraint | SQLAlchemy expression |
 |---|---|
@@ -89,6 +91,8 @@ Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
 | `Literal[...]` | `column.in_(...)` |
 | `Enum` | `column.in_(...)` |
 
+`pattern` is extracted into IR but has no portable core translator.
+
 Unsupported constraints raise `UnsupportedConstraintError` by default.
 Use `on_unsupported="warn"` or `"ignore"` to change that policy for unknown
 constraint operators (unsupported types always raise).
@@ -96,7 +100,7 @@ constraint operators (unsupported types always raise).
 ## Public API
 
 ```python
-sqlrules.compile(model, table, *, column_map=None, on_unsupported="raise")
+sqlrules.compile(model, table, *, column_map=None, on_unsupported="raise", cache=True)
 sqlrules.where(rules)    # flatten all expressions
 sqlrules.flatten(rules)  # alias of where()
 ```
@@ -120,6 +124,7 @@ pip install -e ".[dev]"
 pytest
 ruff check .
 mypy src/sqlrules
+python -m benchmarks.bench_compile
 ```
 
 ## License

sqlrules-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sqlrules/__init__.py,sha256=33UBpq4vkVgxLh6m9EU4RNM1gFRdnnZwXtYuZHJjvY4,982
+sqlrules/cache.py,sha256=9NBDunUMvQR3bsx9QxIiO8L8JNbpI1tdLlFNapUZMj8,1051
+sqlrules/columns.py,sha256=TcDhFG8wxgKC3-kwXhOBP27Ekrlfncm-WWrUkMLCplo,2428
+sqlrules/compiler.py,sha256=UgtZfhCGFyt1bMu25koGaCkcd-Z9Lcer5KDF6JIe-bM,4621
+sqlrules/constraints.py,sha256=YcI2TstNoW9GGR4TfoWBzMlmKKNPsqNjTdUr3Cd3rk8,12349
+sqlrules/errors.py,sha256=SOfRXfhwb9wIyrPjukVP_alKEV83hlORyngN0NuCD_8,2533
+sqlrules/inspectors.py,sha256=mEi7ixA1aQe7lyZtcFvLHVqVsAXt_tm60YNgJrYbrp8,1700
+sqlrules/ir.py,sha256=Lq53l4ELGzrYZ0ZqM_fqeLau1kSrod91zjEUIO7_JE4,1945
+sqlrules/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules/translators.py,sha256=f21pBuDk6r5xKstnEgRiL8ZubFjo5QvbeHJDzOY10nU,5818
+sqlrules-0.2.0.dist-info/METADATA,sha256=28Q8NuNDJLpREon9qGQruaR66_34QQtbTsy4Pr-2kIE,3988
+sqlrules-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sqlrules-0.2.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules-0.2.0.dist-info/RECORD,,

sqlrules-0.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-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,,