inputlayer-client-dev 0.1.0__py3-none-any.whl

inputlayer/migrations/operations.py

@@ -0,0 +1,298 @@
+"""Migration operations - atomic schema/rule changes with forward and backward commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class CreateRelation:
+    """Create a new relation with a typed schema."""
+
+    name: str
+    columns: list[tuple[str, str]]  # [(col_name, datalog_type), ...]
+
+    def forward_commands(self) -> list[str]:
+        parts = ", ".join(f"{col}: {tp}" for col, tp in self.columns)
+        return [f"+{self.name}({parts})"]
+
+    def backward_commands(self) -> list[str]:
+        return [f".rel drop {self.name}"]
+
+    def describe(self) -> str:
+        return f"Create relation {self.name}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": "CreateRelation", "name": self.name, "columns": self.columns}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CreateRelation:
+        return cls(name=d["name"], columns=[tuple(c) for c in d["columns"]])
+
+
+@dataclass(frozen=True)
+class DropRelation:
+    """Drop an existing relation (stores columns for reversibility)."""
+
+    name: str
+    columns: list[tuple[str, str]]
+
+    def forward_commands(self) -> list[str]:
+        return [f".rel drop {self.name}"]
+
+    def backward_commands(self) -> list[str]:
+        parts = ", ".join(f"{col}: {tp}" for col, tp in self.columns)
+        return [f"+{self.name}({parts})"]
+
+    def describe(self) -> str:
+        return f"Drop relation {self.name}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": "DropRelation", "name": self.name, "columns": self.columns}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> DropRelation:
+        return cls(name=d["name"], columns=[tuple(c) for c in d["columns"]])
+
+
+@dataclass(frozen=True)
+class CreateRule:
+    """Create a new rule with one or more clauses."""
+
+    name: str
+    clauses: list[str]  # Compiled Datalog strings
+
+    def forward_commands(self) -> list[str]:
+        return list(self.clauses)
+
+    def backward_commands(self) -> list[str]:
+        return [f".rule drop {self.name}"]
+
+    def describe(self) -> str:
+        n = len(self.clauses)
+        return f"Create rule {self.name} ({n} clause{'s' if n != 1 else ''})"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": "CreateRule", "name": self.name, "clauses": self.clauses}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CreateRule:
+        return cls(name=d["name"], clauses=d["clauses"])
+
+
+@dataclass(frozen=True)
+class DropRule:
+    """Drop an existing rule (stores clauses for reversibility)."""
+
+    name: str
+    clauses: list[str]
+
+    def forward_commands(self) -> list[str]:
+        return [f".rule drop {self.name}"]
+
+    def backward_commands(self) -> list[str]:
+        return list(self.clauses)
+
+    def describe(self) -> str:
+        return f"Drop rule {self.name}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": "DropRule", "name": self.name, "clauses": self.clauses}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> DropRule:
+        return cls(name=d["name"], clauses=d["clauses"])
+
+
+@dataclass(frozen=True)
+class ReplaceRule:
+    """Replace a rule's clauses (drop + recreate)."""
+
+    name: str
+    old_clauses: list[str]
+    new_clauses: list[str]
+
+    def forward_commands(self) -> list[str]:
+        return [f".rule drop {self.name}"] + list(self.new_clauses)
+
+    def backward_commands(self) -> list[str]:
+        return [f".rule drop {self.name}"] + list(self.old_clauses)
+
+    def describe(self) -> str:
+        return f"Replace rule {self.name}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": "ReplaceRule",
+            "name": self.name,
+            "old_clauses": self.old_clauses,
+            "new_clauses": self.new_clauses,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> ReplaceRule:
+        return cls(
+            name=d["name"],
+            old_clauses=d["old_clauses"],
+            new_clauses=d["new_clauses"],
+        )
+
+
+@dataclass(frozen=True)
+class CreateIndex:
+    """Create an HNSW vector index."""
+
+    name: str
+    relation: str
+    column: str
+    metric: str = "cosine"
+    m: int = 16
+    ef_construction: int = 100
+    ef_search: int = 50
+
+    def forward_commands(self) -> list[str]:
+        return [
+            f".index create {self.name} on {self.relation}({self.column}) "
+            f"type hnsw metric {self.metric} "
+            f"m {self.m} ef_construction {self.ef_construction} "
+            f"ef_search {self.ef_search}"
+        ]
+
+    def backward_commands(self) -> list[str]:
+        return [f".index drop {self.name}"]
+
+    def describe(self) -> str:
+        return f"Create index {self.name} on {self.relation}({self.column})"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": "CreateIndex",
+            "name": self.name,
+            "relation": self.relation,
+            "column": self.column,
+            "metric": self.metric,
+            "m": self.m,
+            "ef_construction": self.ef_construction,
+            "ef_search": self.ef_search,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CreateIndex:
+        return cls(
+            name=d["name"],
+            relation=d["relation"],
+            column=d["column"],
+            metric=d.get("metric", "cosine"),
+            m=d.get("m", 16),
+            ef_construction=d.get("ef_construction", 100),
+            ef_search=d.get("ef_search", 50),
+        )
+
+
+@dataclass(frozen=True)
+class DropIndex:
+    """Drop an HNSW vector index (stores params for reversibility)."""
+
+    name: str
+    relation: str
+    column: str
+    metric: str = "cosine"
+    m: int = 16
+    ef_construction: int = 100
+    ef_search: int = 50
+
+    def forward_commands(self) -> list[str]:
+        return [f".index drop {self.name}"]
+
+    def backward_commands(self) -> list[str]:
+        return [
+            f".index create {self.name} on {self.relation}({self.column}) "
+            f"type hnsw metric {self.metric} "
+            f"m {self.m} ef_construction {self.ef_construction} "
+            f"ef_search {self.ef_search}"
+        ]
+
+    def describe(self) -> str:
+        return f"Drop index {self.name}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": "DropIndex",
+            "name": self.name,
+            "relation": self.relation,
+            "column": self.column,
+            "metric": self.metric,
+            "m": self.m,
+            "ef_construction": self.ef_construction,
+            "ef_search": self.ef_search,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> DropIndex:
+        return cls(
+            name=d["name"],
+            relation=d["relation"],
+            column=d["column"],
+            metric=d.get("metric", "cosine"),
+            m=d.get("m", 16),
+            ef_construction=d.get("ef_construction", 100),
+            ef_search=d.get("ef_search", 50),
+        )
+
+
+@dataclass(frozen=True)
+class RunDatalog:
+    """Execute arbitrary Datalog commands (escape hatch)."""
+
+    forward: list[str]
+    backward: list[str]
+
+    def forward_commands(self) -> list[str]:
+        return list(self.forward)
+
+    def backward_commands(self) -> list[str]:
+        return list(self.backward)
+
+    def describe(self) -> str:
+        n = len(self.forward)
+        return f"Run {n} custom Datalog command{'s' if n != 1 else ''}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"type": "RunDatalog", "forward": self.forward, "backward": self.backward}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> RunDatalog:
+        return cls(forward=d["forward"], backward=d["backward"])
+
+
+# Union type for all operations
+Operation = (
+    CreateRelation
+    | DropRelation
+    | CreateRule
+    | DropRule
+    | ReplaceRule
+    | CreateIndex
+    | DropIndex
+    | RunDatalog
+)
+
+_OPERATION_REGISTRY: dict[str, type] = {
+    "CreateRelation": CreateRelation,
+    "DropRelation": DropRelation,
+    "CreateRule": CreateRule,
+    "DropRule": DropRule,
+    "ReplaceRule": ReplaceRule,
+    "CreateIndex": CreateIndex,
+    "DropIndex": DropIndex,
+    "RunDatalog": RunDatalog,
+}
+
+
+def operation_from_dict(d: dict[str, Any]) -> Operation:
+    """Deserialize an operation from a dict."""
+    cls = _OPERATION_REGISTRY.get(d["type"])
+    if cls is None:
+        raise ValueError(f"Unknown operation type: {d['type']}")
+    return cls.from_dict(d)

inputlayer/migrations/recorder.py

@@ -0,0 +1,44 @@
+"""Migration recorder - track applied migrations in the DB."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Protocol
+
+
+class KGExecutor(Protocol):
+    """Minimal interface for executing Datalog commands."""
+
+    def execute(self, datalog: str) -> object: ...
+
+
+MIGRATION_RELATION = "__inputlayer_migrations__"
+
+
+class MigrationRecorder:
+    """Track which migrations have been applied using an internal relation."""
+
+    def __init__(self, kg: KGExecutor) -> None:
+        self._kg = kg
+
+    def ensure_schema(self) -> None:
+        """Create the migration tracking relation if it doesn't exist."""
+        self._kg.execute(f"+{MIGRATION_RELATION}(name: string, applied_at: string)")
+
+    def get_applied(self) -> list[str]:
+        """Return sorted list of applied migration names."""
+        result = self._kg.execute(f"?Name, At <- {MIGRATION_RELATION}(Name, At)")
+        rows = getattr(result, "rows", []) or []
+        return sorted(str(row[0]) for row in rows)
+
+    def record_applied(self, name: str) -> None:
+        """Record that a migration has been applied."""
+        now = datetime.now(timezone.utc).isoformat()
+        self._kg.execute(f'+{MIGRATION_RELATION}("{name}", "{now}")')
+
+    def record_reverted(self, name: str) -> None:
+        """Remove the record for a reverted migration."""
+        self._kg.execute(
+            f'-{MIGRATION_RELATION}(Name, At) <- '
+            f'{MIGRATION_RELATION}(Name, At), Name = "{name}"'
+        )

inputlayer/migrations/state.py

@@ -0,0 +1,107 @@
+"""ModelState - snapshot of the full schema for diffing and embedding in migrations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from inputlayer.derived import Derived
+    from inputlayer.index import HnswIndex
+    from inputlayer.relation import Relation
+
+
+@dataclass
+class ModelState:
+    """Snapshot of all relations, rules, and indexes at a point in time."""
+
+    relations: dict[str, list[tuple[str, str]]] = field(default_factory=dict)
+    rules: dict[str, list[str]] = field(default_factory=dict)
+    indexes: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+    @classmethod
+    def from_models(
+        cls,
+        relations: list[type[Relation]] | None = None,
+        derived: list[type[Derived]] | None = None,
+        indexes: list[HnswIndex] | None = None,
+    ) -> ModelState:
+        """Build state by introspecting Python model classes."""
+        from inputlayer.compiler import compile_rule
+        from inputlayer.relation import Relation as RelBase
+        from inputlayer.types import python_type_to_datalog
+
+        state = cls()
+
+        # Process plain relations
+        for rel_cls in relations or []:
+            name = RelBase._resolve_name(rel_cls)
+            cols = RelBase._get_columns(rel_cls)
+            col_types = RelBase._get_column_types(rel_cls)
+            state.relations[name] = [
+                (col, python_type_to_datalog(col_types[col])) for col in cols
+            ]
+
+        # Process derived relations (schema + rules)
+        for der_cls in derived or []:
+            name = RelBase._resolve_name(der_cls)
+            cols = RelBase._get_columns(der_cls)
+            col_types = RelBase._get_column_types(der_cls)
+            state.relations[name] = [
+                (col, python_type_to_datalog(col_types[col])) for col in cols
+            ]
+
+            # Compile each rule clause to Datalog
+            compiled_clauses = []
+            head_columns = cols
+            for clause in der_cls.rules:
+                datalog = compile_rule(
+                    name,
+                    head_columns,
+                    clause.select_map,
+                    clause.relations,
+                    clause.condition,
+                    persistent=True,
+                )
+                compiled_clauses.append(datalog)
+            state.rules[name] = compiled_clauses
+
+        # Process indexes
+        for idx in indexes or []:
+            rel_name = RelBase._resolve_name(idx.relation)
+            state.indexes[idx.name] = {
+                "relation": rel_name,
+                "column": idx.column,
+                "metric": idx.metric,
+                "m": idx.m,
+                "ef_construction": idx.ef_construction,
+                "ef_search": idx.ef_search,
+            }
+
+        return state
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to a plain dict for embedding in migration files."""
+        return {
+            "relations": {
+                name: [list(c) for c in cols]
+                for name, cols in self.relations.items()
+            },
+            "rules": dict(self.rules),
+            "indexes": dict(self.indexes),
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> ModelState:
+        """Deserialize from a dict."""
+        return cls(
+            relations={
+                name: [tuple(c) for c in cols]
+                for name, cols in d.get("relations", {}).items()
+            },
+            rules=d.get("rules", {}),
+            indexes=d.get("indexes", {}),
+        )
+
+    def is_empty(self) -> bool:
+        return not self.relations and not self.rules and not self.indexes

inputlayer/migrations/writer.py

@@ -0,0 +1,183 @@
+"""Migration file writer - generates Python source for migration files."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from inputlayer.migrations.operations import (
+    CreateIndex,
+    CreateRelation,
+    CreateRule,
+    DropIndex,
+    DropRelation,
+    DropRule,
+    Operation,
+    ReplaceRule,
+    RunDatalog,
+)
+
+
+def _repr_str_list(items: list[str], indent: str = "            ") -> str:
+    """Render a list of strings as a formatted Python list."""
+    if not items:
+        return "[]"
+    if len(items) == 1:
+        return f"[{items[0]!r}]"
+    lines = [f"{indent}{item!r}," for item in items]
+    return "[\n" + "\n".join(lines) + f"\n{indent[:-4]}]"
+
+
+def _repr_columns(cols: list[tuple[str, str]], indent: str = "            ") -> str:
+    """Render column list as Python source."""
+    if not cols:
+        return "[]"
+    lines = [f'{indent}("{c}", "{t}"),' for c, t in cols]
+    return "[\n" + "\n".join(lines) + f"\n{indent[:-4]}]"
+
+
+def _render_operation(op: Operation) -> str:
+    """Render a single operation as a Python constructor call."""
+    if isinstance(op, CreateRelation):
+        cols = _repr_columns(op.columns)
+        return f'ops.CreateRelation(\n            name="{op.name}",\n            columns={cols},\n        )'
+    if isinstance(op, DropRelation):
+        cols = _repr_columns(op.columns)
+        return f'ops.DropRelation(\n            name="{op.name}",\n            columns={cols},\n        )'
+    if isinstance(op, CreateRule):
+        clauses = _repr_str_list(op.clauses)
+        return f'ops.CreateRule(\n            name="{op.name}",\n            clauses={clauses},\n        )'
+    if isinstance(op, DropRule):
+        clauses = _repr_str_list(op.clauses)
+        return f'ops.DropRule(\n            name="{op.name}",\n            clauses={clauses},\n        )'
+    if isinstance(op, ReplaceRule):
+        old = _repr_str_list(op.old_clauses)
+        new = _repr_str_list(op.new_clauses)
+        return (
+            f'ops.ReplaceRule(\n'
+            f'            name="{op.name}",\n'
+            f'            old_clauses={old},\n'
+            f'            new_clauses={new},\n'
+            f'        )'
+        )
+    if isinstance(op, CreateIndex):
+        return (
+            f'ops.CreateIndex(\n'
+            f'            name="{op.name}",\n'
+            f'            relation="{op.relation}",\n'
+            f'            column="{op.column}",\n'
+            f'            metric="{op.metric}",\n'
+            f'            m={op.m},\n'
+            f'            ef_construction={op.ef_construction},\n'
+            f'            ef_search={op.ef_search},\n'
+            f'        )'
+        )
+    if isinstance(op, DropIndex):
+        return (
+            f'ops.DropIndex(\n'
+            f'            name="{op.name}",\n'
+            f'            relation="{op.relation}",\n'
+            f'            column="{op.column}",\n'
+            f'            metric="{op.metric}",\n'
+            f'            m={op.m},\n'
+            f'            ef_construction={op.ef_construction},\n'
+            f'            ef_search={op.ef_search},\n'
+            f'        )'
+        )
+    if isinstance(op, RunDatalog):
+        fwd = _repr_str_list(op.forward)
+        bwd = _repr_str_list(op.backward)
+        return f'ops.RunDatalog(\n            forward={fwd},\n            backward={bwd},\n        )'
+    raise TypeError(f"Unknown operation type: {type(op).__name__}")
+
+
+def _render_state(state: dict[str, Any]) -> str:
+    """Render state dict as formatted Python source."""
+    lines = ["    state = {"]
+
+    # Relations
+    lines.append('        "relations": {')
+    for name, cols in sorted(state.get("relations", {}).items()):
+        col_strs = [f'("{c}", "{t}")' for c, t in cols]
+        lines.append(f'            "{name}": [{", ".join(col_strs)}],')
+    lines.append("        },")
+
+    # Rules
+    lines.append('        "rules": {')
+    for name, clauses in sorted(state.get("rules", {}).items()):
+        if len(clauses) == 1:
+            lines.append(f'            "{name}": [{clauses[0]!r}],')
+        else:
+            lines.append(f'            "{name}": [')
+            for c in clauses:
+                lines.append(f"                {c!r},")
+            lines.append("            ],")
+    lines.append("        },")
+
+    # Indexes
+    lines.append('        "indexes": {')
+    for name, info in sorted(state.get("indexes", {}).items()):
+        lines.append(f'            "{name}": {{')
+        for k, v in info.items():
+            lines.append(f'                "{k}": {v!r},')
+        lines.append("            },")
+    lines.append("        },")
+
+    lines.append("    }")
+    return "\n".join(lines)
+
+
+def generate_migration(
+    number: int,
+    operations: list[Operation],
+    state: dict[str, Any],
+    dependencies: list[str],
+    *,
+    name_suffix: str | None = None,
+) -> tuple[str, str]:
+    """Generate a migration file.
+
+    Returns (filename, content).
+    """
+    if number == 1 and name_suffix is None:
+        name_suffix = "initial"
+    elif name_suffix is None:
+        name_suffix = "auto"
+
+    filename = f"{number:04d}_{name_suffix}.py"
+
+    # Build content
+    lines = [
+        f"# Migration: {filename}",
+        "# Auto-generated by inputlayer-migrate",
+        "",
+        "from inputlayer.migrations import Migration",
+        "from inputlayer.migrations import operations as ops",
+        "",
+        "",
+        "class M(Migration):",
+    ]
+
+    # Dependencies
+    if dependencies:
+        deps_str = ", ".join(f'"{d}"' for d in dependencies)
+        lines.append(f"    dependencies = [{deps_str}]")
+    else:
+        lines.append("    dependencies = []")
+    lines.append("")
+
+    # Operations
+    if operations:
+        lines.append("    operations = [")
+        for op in operations:
+            rendered = _render_operation(op)
+            lines.append(f"        {rendered},")
+        lines.append("    ]")
+    else:
+        lines.append("    operations = []")
+    lines.append("")
+
+    # State
+    lines.append(_render_state(state))
+    lines.append("")
+
+    return filename, "\n".join(lines)