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

sqlrules/__init__.py

@@ -5,6 +5,7 @@ from sqlrules.errors import (
     InvalidModelError,
     InvalidTranslatorError,
     MissingColumnError,
+    PluginError,
     RegistryError,
     SQLRulesError,
     TranslatorError,
@@ -18,11 +19,13 @@ from sqlrules.ir import (
     FieldIR,
     ModelIR,
 )
+from sqlrules.plugins import PLUGIN_API_VERSION, SQLRulesPlugin
 from sqlrules.translators import SQLRulesWarning
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
+    "PLUGIN_API_VERSION",
     "CompilationContext",
     "Compiler",
     "ConfigurationError",
@@ -35,8 +38,10 @@ __all__ = [
     "InvalidTranslatorError",
     "MissingColumnError",
     "ModelIR",
+    "PluginError",
     "RegistryError",
     "SQLRulesError",
+    "SQLRulesPlugin",
     "SQLRulesWarning",
     "TranslatorError",
     "UnsupportedConstraintError",

sqlrules/compiler.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from itertools import chain
 from typing import Any
 
@@ -18,8 +18,10 @@ from sqlrules.ir import (
     DiagnosticsCollector,
     FieldIR,
     ModelIR,
+    OnConflict,
     OnUnsupported,
 )
+from sqlrules.plugins import SQLRulesPlugin, validate_plugin
 from sqlrules.translators import TranslatorRegistry, default_registry
 
 RulesDict = dict[str, list[ColumnElement[bool]]]
@@ -30,20 +32,45 @@ class Compiler:
         self,
         *,
         registry: TranslatorRegistry | None = None,
+        plugins: Sequence[SQLRulesPlugin] | None = None,
+        on_conflict: OnConflict = "raise",
         on_unsupported: OnUnsupported = "raise",
+        dialect: str | None = None,
         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()
+        if on_conflict not in {"raise", "replace", "ignore"}:
+            raise ConfigurationError(option="on_conflict", value=on_conflict)
+
+        base = registry if registry is not None else default_registry()
+        plugin_list = list(plugins or ())
+        resolved: TranslatorRegistry
+        if plugin_list:
+            # Copy so plugins cannot mutate a caller-owned or shared registry.
+            aware = _PluginAwareRegistry(
+                base.copy(),
+                default_on_conflict=on_conflict,
+            )
+            for plugin in plugin_list:
+                validate_plugin(plugin).register(aware)
+            # Freeze to a plain registry after registration.
+            resolved = aware.copy()
+        else:
+            resolved = base
+        self.registry = resolved
+
         self.on_unsupported = on_unsupported
+        self.on_conflict = on_conflict
+        self.dialect = dialect
         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,
+            dialect=dialect,
         )
 
     @property
@@ -83,6 +110,7 @@ class Compiler:
         self.context = CompilationContext(
             on_unsupported=self.on_unsupported,
             collector=self._collector,
+            dialect=self.dialect,
         )
 
         rules: RulesDict = {}
@@ -120,6 +148,43 @@ class Compiler:
         return self.bind(self.compile_model(model), table, column_map=column_map)
 
 
+class _PluginAwareRegistry(TranslatorRegistry):
+    """Registry that applies Compiler.on_conflict as the default for register()."""
+
+    def __init__(
+        self,
+        base: TranslatorRegistry,
+        *,
+        default_on_conflict: OnConflict,
+    ) -> None:
+        super().__init__()
+        self._translators = dict(base._translators)
+        self._default_on_conflict = default_on_conflict
+
+    def register(
+        self,
+        operator_name: str,
+        translator: Any,
+        *,
+        replace: bool = False,
+    ) -> None:
+        on_conflict: OnConflict = "replace" if replace else self._default_on_conflict
+        self.register_constraint(operator_name, translator, on_conflict=on_conflict)
+
+    def register_constraint(
+        self,
+        operator_name: str,
+        translator: Any,
+        *,
+        on_conflict: OnConflict | None = None,
+    ) -> None:
+        super().register_constraint(
+            operator_name,
+            translator,
+            on_conflict=on_conflict if on_conflict is not None else self._default_on_conflict,
+        )
+
+
 def compile(
     model: type[BaseModel],
     table: Any,

sqlrules/conformance.py

@@ -0,0 +1,146 @@
+"""Plugin conformance helpers for official and third-party plugins."""
+
+from __future__ import annotations
+
+import contextlib
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field
+from sqlalchemy import Column, MetaData, String, Table
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.compiler import Compiler
+from sqlrules.errors import PluginError, RegistryError
+from sqlrules.plugins import PLUGIN_API_VERSION, SQLRulesPlugin, validate_plugin
+from sqlrules.translators import TranslatorRegistry, default_registry
+
+
+def assert_plugin_api_compatible(plugin: SQLRulesPlugin) -> None:
+    """Raise PluginError if the plugin does not match the current plugin API."""
+    validate_plugin(plugin)
+
+
+def assert_register_conflict_raise(plugin: SQLRulesPlugin) -> None:
+    """Registering the same plugin twice with on_conflict='raise' must fail.
+
+    Plugins that only add new operators (not in the default registry) are
+    registered twice against a fresh default registry; the second pass must
+    raise RegistryError for any overlapping operator.
+    """
+    validate_plugin(plugin)
+    registry = default_registry()
+    plugin.register(registry)
+    try:
+        plugin.register(registry)
+    except RegistryError:
+        return
+    raise AssertionError(
+        f"Plugin {plugin.name!r} did not raise RegistryError on duplicate registration"
+    )
+
+
+def assert_register_idempotent_ignore(plugin: SQLRulesPlugin) -> None:
+    """Registering twice with on_conflict='ignore' must succeed and keep builtins."""
+    validate_plugin(plugin)
+    builtins = default_registry().operators()
+    compiler = Compiler(plugins=[plugin], on_conflict="ignore", cache=False)
+    first_ops = compiler.registry.operators()
+    # Re-apply via a second compiler with the same plugin.
+    compiler2 = Compiler(
+        registry=compiler.registry.copy(),
+        plugins=[plugin],
+        on_conflict="ignore",
+        cache=False,
+    )
+    assert compiler2.registry.operators() == first_ops
+    assert builtins <= compiler2.registry.operators()
+
+
+def assert_builtins_preserved(
+    plugin: SQLRulesPlugin,
+    *,
+    on_conflict: str = "raise",
+) -> None:
+    """Plugins must not drop built-in operators."""
+    validate_plugin(plugin)
+    builtins = default_registry().operators()
+    compiler = Compiler(plugins=[plugin], on_conflict=on_conflict, cache=False)  # type: ignore[arg-type]
+    missing = builtins - compiler.registry.operators()
+    if missing:
+        raise AssertionError(
+            f"Plugin {plugin.name!r} removed built-in operators: {sorted(missing)}"
+        )
+
+
+def assert_translates_operator(
+    plugin: SQLRulesPlugin,
+    *,
+    operator: str,
+    model: type[BaseModel] | None = None,
+    table: Any | None = None,
+    field: str = "name",
+) -> ColumnElement[bool]:
+    """Compile with the plugin and assert ``operator`` yields a ColumnElement."""
+    validate_plugin(plugin)
+
+    if model is None:
+
+        class PatternFilter(BaseModel):
+            name: Annotated[str, Field(pattern=r"^a")]
+
+        model = PatternFilter
+
+    if table is None:
+        table = Table("items", MetaData(), Column("name", String))
+
+    compiler = Compiler(plugins=[plugin], on_conflict="replace", cache=False)
+    if operator not in compiler.registry:
+        raise AssertionError(f"Plugin {plugin.name!r} did not register operator {operator!r}")
+
+    rules = compiler.compile(model, table)
+    if field not in rules or not rules[field]:
+        raise AssertionError(f"Plugin {plugin.name!r}: expected expressions for field {field!r}")
+
+    expression = rules[field][0]
+    if not isinstance(expression, ColumnElement):
+        raise AssertionError(
+            f"Plugin {plugin.name!r}: translator for {operator!r} "
+            f"returned {type(expression)!r}, expected ColumnElement"
+        )
+
+    # Deterministic compile smoke check (dialect-neutral string form).
+    compiled_a = str(expression.compile(compile_kwargs={"literal_binds": True}))
+    compiled_b = str(expression.compile(compile_kwargs={"literal_binds": True}))
+    if compiled_a != compiled_b:
+        raise AssertionError(f"Plugin {plugin.name!r}: non-deterministic compile for {operator!r}")
+    return expression
+
+
+def run_basic_conformance(plugin: SQLRulesPlugin, *, operator: str = "pattern") -> None:
+    """Run the standard conformance checks for a dialect/translator plugin."""
+    if getattr(plugin, "api_version", None) != PLUGIN_API_VERSION:
+        raise PluginError(
+            message=(
+                f"Plugin {getattr(plugin, 'name', plugin)!r} api_version mismatch "
+                f"(expected {PLUGIN_API_VERSION!r})."
+            ),
+            plugin=plugin,
+        )
+    assert_plugin_api_compatible(plugin)
+    assert_builtins_preserved(plugin, on_conflict="replace")
+    assert_register_idempotent_ignore(plugin)
+    assert_translates_operator(plugin, operator=operator)
+
+    # Conflict under raise: only meaningful if the plugin re-registers an op
+    # already present after the first registration.
+    registry = default_registry()
+    plugin.register(registry)
+    with contextlib.suppress(RegistryError):
+        # If the plugin uses on_conflict="replace" internally, duplicate
+        # registration may succeed; that is acceptable for dialect overrides.
+        plugin.register(registry)
+
+
+def registry_without_builtins() -> TranslatorRegistry:
+    """Empty registry for isolated translator unit tests."""
+    return TranslatorRegistry()

sqlrules/errors.py

@@ -85,12 +85,28 @@ class ConfigurationError(SQLRulesError):
     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}."
-        )
+        if self.option == "on_unsupported":
+            return (
+                f"Invalid configuration value for {self.option!r}: {self.value!r}. "
+                "Use one of: 'raise', 'warn', 'ignore'."
+            )
+        if self.option == "on_conflict":
+            return (
+                f"Invalid configuration value for {self.option!r}: {self.value!r}. "
+                "Use one of: 'raise', 'replace', 'ignore'."
+            )
+        return f"Invalid configuration value for {self.option!r}: {self.value!r}."
+
+
+@dataclass(slots=True)
+class PluginError(SQLRulesError):
+    """Raised when a plugin fails validation or registration."""
+
+    message: str
+    plugin: Any = None
+
+    def __str__(self) -> str:
+        return self.message
 
 
 class InternalCompilerError(SQLRulesError):

sqlrules/ir.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any, Literal
 
 OnUnsupported = Literal["raise", "warn", "ignore"]
+OnConflict = Literal["raise", "replace", "ignore"]
 DiagnosticSeverity = Literal["warning", "info"]
 
 
@@ -30,6 +31,7 @@ class Diagnostic:
     operator: str
     value: Any = None
     message: str = ""
+    code: str = ""
 
 
 @dataclass(slots=True)
@@ -52,6 +54,7 @@ class DiagnosticsCollector:
 class CompilationContext:
     on_unsupported: OnUnsupported = "raise"
     collector: DiagnosticsCollector | None = None
+    dialect: str | None = None
 
     def record(
         self,
@@ -61,6 +64,7 @@ class CompilationContext:
         operator: str,
         value: Any = None,
         message: str = "",
+        code: str = "",
     ) -> None:
         if self.collector is None:
             return
@@ -71,6 +75,7 @@ class CompilationContext:
                 operator=operator,
                 value=value,
                 message=message,
+                code=code,
             )
         )
 

sqlrules/plugins.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+from sqlrules.errors import PluginError
+from sqlrules.translators import TranslatorRegistry
+
+PLUGIN_API_VERSION = "1"
+
+
+@runtime_checkable
+class SQLRulesPlugin(Protocol):
+    """Explicit extension that registers translators onto a registry."""
+
+    name: str
+    api_version: str
+
+    def register(self, registry: TranslatorRegistry) -> None:
+        """Register constraint translators on ``registry``."""
+
+
+def validate_plugin(plugin: Any) -> SQLRulesPlugin:
+    """Validate a plugin object against the versioned plugin API."""
+    if not isinstance(plugin, SQLRulesPlugin):
+        raise PluginError(
+            message=(
+                f"Plugin {plugin!r} does not implement SQLRulesPlugin "
+                "(requires name, api_version, and register(registry))."
+            ),
+            plugin=plugin,
+        )
+
+    name = getattr(plugin, "name", None)
+    if not isinstance(name, str) or not name:
+        raise PluginError(
+            message=f"Plugin {plugin!r} must declare a non-empty string name.",
+            plugin=plugin,
+        )
+
+    api_version = getattr(plugin, "api_version", None)
+    if api_version != PLUGIN_API_VERSION:
+        raise PluginError(
+            message=(
+                f"Plugin {name!r} declares api_version={api_version!r}, "
+                f"but SQLRules plugin API is {PLUGIN_API_VERSION!r}."
+            ),
+            plugin=plugin,
+        )
+
+    register = getattr(plugin, "register", None)
+    if not callable(register):
+        raise PluginError(
+            message=f"Plugin {name!r} must provide a callable register(registry) method.",
+            plugin=plugin,
+        )
+
+    return plugin

sqlrules/translators.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import operator
 import sys
 import types
@@ -10,8 +11,13 @@ 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
+from sqlrules.errors import (
+    InvalidTranslatorError,
+    RegistryError,
+    TranslatorError,
+    UnsupportedConstraintError,
+)
+from sqlrules.ir import CompilationContext, Constraint, OnConflict
 
 Translator = Callable[[Constraint, ColumnElement[Any], CompilationContext], ColumnElement[bool]]
 
@@ -93,6 +99,32 @@ def _in_values(
     return cast(ColumnElement[bool], column.in_(constraint.value))
 
 
+def _validate_translator(operator_name: str, translator: Any) -> Translator:
+    if not callable(translator):
+        raise InvalidTranslatorError(operator=operator_name, translator=translator)
+    try:
+        signature = inspect.signature(translator)
+    except (TypeError, ValueError):
+        return cast(Translator, translator)
+
+    params = list(signature.parameters.values())
+    if any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params):
+        return cast(Translator, translator)
+
+    positional = [
+        p
+        for p in params
+        if p.kind
+        in (
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        )
+    ]
+    if len(positional) < 3:
+        raise InvalidTranslatorError(operator=operator_name, translator=translator)
+    return cast(Translator, translator)
+
+
 class TranslatorRegistry:
     def __init__(self) -> None:
         self._translators: dict[str, Translator] = {}
@@ -104,13 +136,46 @@ class TranslatorRegistry:
         *,
         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
+        self.register_constraint(
+            operator_name,
+            translator,
+            on_conflict="replace" if replace else "raise",
+        )
+
+    def register_constraint(
+        self,
+        operator_name: str,
+        translator: Translator,
+        *,
+        on_conflict: OnConflict = "raise",
+    ) -> None:
+        if on_conflict not in {"raise", "replace", "ignore"}:
+            raise RegistryError(
+                f"Invalid on_conflict value {on_conflict!r}. "
+                "Use one of: 'raise', 'replace', 'ignore'."
+            )
+        validated = _validate_translator(operator_name, translator)
+        if operator_name in self._translators:
+            if on_conflict == "raise":
+                raise RegistryError(f"Translator for {operator_name!r} is already registered.")
+            if on_conflict == "ignore":
+                return
+        self._translators[operator_name] = validated
 
     def lookup(self, operator_name: str) -> Translator | None:
         return self._translators.get(operator_name)
 
+    def operators(self) -> frozenset[str]:
+        return frozenset(self._translators)
+
+    def __contains__(self, operator_name: object) -> bool:
+        return isinstance(operator_name, str) and operator_name in self._translators
+
+    def copy(self) -> TranslatorRegistry:
+        clone = TranslatorRegistry()
+        clone._translators = dict(self._translators)
+        return clone
+
     def translate(
         self,
         constraint: Constraint,
@@ -137,6 +202,7 @@ class TranslatorRegistry:
                     operator=constraint.operator,
                     value=constraint.value,
                     message=message,
+                    code="unsupported_constraint",
                 )
                 warnings.warn(message, SQLRulesWarning, stacklevel=_warning_stacklevel())
             else:
@@ -146,6 +212,7 @@ class TranslatorRegistry:
                     operator=constraint.operator,
                     value=constraint.value,
                     message=message,
+                    code="unsupported_constraint",
                 )
             return None
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrules
-Version: 0.2.0
+Version: 0.3.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
@@ -81,7 +81,22 @@ pip install sqlrules
 
 Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
 
-## Supported constraints (0.2)
+Optional dialect plugins:
+
+```bash
+pip install sqlrules-postgresql   # pattern → PostgreSQL ~
+pip install sqlrules-sqlite       # pattern → SQLite REGEXP
+```
+
+```python
+from sqlrules import Compiler
+from sqlrules_postgresql import PostgresPlugin
+
+compiler = Compiler(plugins=[PostgresPlugin()], dialect="postgresql")
+rules = compiler.compile(UserFilter, users)
+```
+
+## Supported constraints (0.3)
 
 | Constraint | SQLAlchemy expression |
 |---|---|
@@ -92,6 +107,8 @@ Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
 | `Enum` | `column.in_(...)` |
 
 `pattern` is extracted into IR but has no portable core translator.
+Use a custom registry translator or a dialect plugin
+(`sqlrules-postgresql`, `sqlrules-sqlite`).
 
 Unsupported constraints raise `UnsupportedConstraintError` by default.
 Use `on_unsupported="warn"` or `"ignore"` to change that policy for unknown
@@ -103,6 +120,14 @@ constraint operators (unsupported types always 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()
+
+compiler = sqlrules.Compiler(
+    plugins=[...],           # optional SQLRulesPlugin instances
+    on_conflict="raise",     # raise | replace | ignore
+    dialect=None,            # optional hint for translators
+    on_unsupported="raise",
+    cache=True,
+)
 ```
 
 ## Non-goals
@@ -115,13 +140,15 @@ constraints into SQLAlchemy expressions.
 
 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).
+[plugin system](docs/PLUGIN_SYSTEM.md), [architecture](docs/ARCHITECTURE.md),
+and [roadmap](docs/ROADMAP.md).
 
 ## Development
 
 ```bash
 pip install -e ".[dev]"
-pytest
+pip install -e packages/sqlrules-postgresql -e packages/sqlrules-sqlite
+pytest tests packages/sqlrules-postgresql/tests packages/sqlrules-sqlite/tests
 ruff check .
 mypy src/sqlrules
 python -m benchmarks.bench_compile

sqlrules-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+sqlrules/__init__.py,sha256=IEIU4ESvzydICwS2CnqXzIz9KA5PiQvHw-FlMybfkvM,1130
+sqlrules/cache.py,sha256=9NBDunUMvQR3bsx9QxIiO8L8JNbpI1tdLlFNapUZMj8,1051
+sqlrules/columns.py,sha256=TcDhFG8wxgKC3-kwXhOBP27Ekrlfncm-WWrUkMLCplo,2428
+sqlrules/compiler.py,sha256=sVlpcP5qv-BUjKSNwd4Q6I3aQvqVOgDo89EAwxTqo5I,6799
+sqlrules/conformance.py,sha256=QV3lTfVtj0vcWUfP8NO_RD7HBon-sANSGdIpVttn_xM,5469
+sqlrules/constraints.py,sha256=YcI2TstNoW9GGR4TfoWBzMlmKKNPsqNjTdUr3Cd3rk8,12349
+sqlrules/errors.py,sha256=qcSCcnL19kvfzAd1eMN1pVVNbV3cg1WLb94uGna8w-M,2989
+sqlrules/inspectors.py,sha256=mEi7ixA1aQe7lyZtcFvLHVqVsAXt_tm60YNgJrYbrp8,1700
+sqlrules/ir.py,sha256=ekZ6HLxrJofGvlxZwh2BZty5oV1uzJQjSfZf0GXb6z8,2097
+sqlrules/plugins.py,sha256=ClXVdISpgNzVQkQCJk9ptgnXxqWLwi99EBcNP9wYXyI,1740
+sqlrules/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules/translators.py,sha256=aw8Q8hgfNUqdUEosUXgMW4IqTTBNUtSA-Yc2aCiPKNs,7949
+sqlrules-0.3.0.dist-info/METADATA,sha256=DcOg6uAGJlk2brXQloOv09vEWJbBvOfu1EfMsP9mlAY,4898
+sqlrules-0.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sqlrules-0.3.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules-0.3.0.dist-info/RECORD,,

sqlrules-0.2.0.dist-info/RECORD

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