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

inputlayer/migrations/autodetector.py

@@ -0,0 +1,120 @@
+"""Autodetector - diff two ModelStates to produce a list of Operations."""
+
+from __future__ import annotations
+
+from inputlayer.migrations.operations import (
+    CreateIndex,
+    CreateRelation,
+    CreateRule,
+    DropIndex,
+    DropRelation,
+    DropRule,
+    Operation,
+    ReplaceRule,
+)
+from inputlayer.migrations.state import ModelState
+
+
+def detect_changes(old: ModelState, new: ModelState) -> list[Operation]:
+    """Diff two states and return an ordered list of operations.
+
+    Ordering:
+    1. Create new relations (needed before rules can reference them)
+    2. Drop old rules (before relations they depend on are dropped)
+    3. Replace modified rules
+    4. Create new rules
+    5. Drop removed relations
+    6. Handle indexes (drop removed, create new)
+    """
+    ops: list[Operation] = []
+
+    old_rels = set(old.relations)
+    new_rels = set(new.relations)
+    old_rules = set(old.rules)
+    new_rules = set(new.rules)
+    old_idxs = set(old.indexes)
+    new_idxs = set(new.indexes)
+
+    # 1. Create new relations
+    for name in sorted(new_rels - old_rels):
+        ops.append(CreateRelation(name=name, columns=new.relations[name]))
+
+    # 2. Modified relations (columns changed) → drop + recreate
+    #    InputLayer can't ALTER, so this is destructive
+    for name in sorted(old_rels & new_rels):
+        if old.relations[name] != new.relations[name]:
+            ops.append(DropRelation(name=name, columns=old.relations[name]))
+            ops.append(CreateRelation(name=name, columns=new.relations[name]))
+
+    # 3. Drop rules that no longer exist
+    for name in sorted(old_rules - new_rules):
+        ops.append(DropRule(name=name, clauses=old.rules[name]))
+
+    # 4. Replace modified rules
+    for name in sorted(old_rules & new_rules):
+        if old.rules[name] != new.rules[name]:
+            ops.append(ReplaceRule(
+                name=name,
+                old_clauses=old.rules[name],
+                new_clauses=new.rules[name],
+            ))
+
+    # 5. Create new rules
+    for name in sorted(new_rules - old_rules):
+        ops.append(CreateRule(name=name, clauses=new.rules[name]))
+
+    # 6. Drop removed relations (after their rules are gone)
+    for name in sorted(old_rels - new_rels):
+        ops.append(DropRelation(name=name, columns=old.relations[name]))
+
+    # 7. Drop removed indexes
+    for name in sorted(old_idxs - new_idxs):
+        info = old.indexes[name]
+        ops.append(DropIndex(
+            name=name,
+            relation=info["relation"],
+            column=info["column"],
+            metric=info.get("metric", "cosine"),
+            m=info.get("m", 16),
+            ef_construction=info.get("ef_construction", 100),
+            ef_search=info.get("ef_search", 50),
+        ))
+
+    # 8. Modified indexes → drop + recreate
+    for name in sorted(old_idxs & new_idxs):
+        if old.indexes[name] != new.indexes[name]:
+            old_info = old.indexes[name]
+            ops.append(DropIndex(
+                name=name,
+                relation=old_info["relation"],
+                column=old_info["column"],
+                metric=old_info.get("metric", "cosine"),
+                m=old_info.get("m", 16),
+                ef_construction=old_info.get("ef_construction", 100),
+                ef_search=old_info.get("ef_search", 50),
+            ))
+            new_info = new.indexes[name]
+            ops.append(CreateIndex(
+                name=name,
+                relation=new_info["relation"],
+                column=new_info["column"],
+                metric=new_info.get("metric", "cosine"),
+                m=new_info.get("m", 16),
+                ef_construction=new_info.get("ef_construction", 100),
+                ef_search=new_info.get("ef_search", 50),
+            ))
+
+    # 9. Create new indexes
+    for name in sorted(new_idxs - old_idxs):
+        info = new.indexes[name]
+        ops.append(CreateIndex(
+            name=name,
+            relation=info["relation"],
+            column=info["column"],
+            metric=info.get("metric", "cosine"),
+            m=info.get("m", 16),
+            ef_construction=info.get("ef_construction", 100),
+            ef_search=info.get("ef_search", 50),
+        ))
+
+    return ops

inputlayer/migrations/cli.py

@@ -0,0 +1,254 @@
+"""CLI entry point for the migration system."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import inspect
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from inputlayer.migrations.autodetector import detect_changes
+from inputlayer.migrations.loader import get_latest_state, get_next_number, load_migrations
+from inputlayer.migrations.state import ModelState
+from inputlayer.migrations.writer import generate_migration
+
+
+def _discover_models(module_path: str) -> tuple[list, list, list]:
+    """Import a module and discover Relation, Derived, and HnswIndex objects.
+
+    Returns (relations, derived, indexes).
+    """
+    from inputlayer.derived import Derived
+    from inputlayer.index import HnswIndex
+    from inputlayer.relation import Relation
+
+    mod = importlib.import_module(module_path)
+
+    relations = []
+    derived = []
+    indexes = []
+
+    for _name, obj in inspect.getmembers(mod):
+        if isinstance(obj, HnswIndex):
+            indexes.append(obj)
+        elif isinstance(obj, type) and issubclass(obj, Derived) and obj is not Derived:
+            derived.append(obj)
+        elif isinstance(obj, type) and issubclass(obj, Relation) and obj is not Relation and not issubclass(obj, Derived):
+            relations.append(obj)
+
+    return relations, derived, indexes
+
+
+def _cmd_makemigrations(args: argparse.Namespace) -> int:
+    """Generate a new migration file by diffing current models against last state."""
+    migrations_dir = Path(args.migrations_dir)
+    migrations_dir.mkdir(parents=True, exist_ok=True)
+
+    # Discover models
+    relations, derived_list, indexes = _discover_models(args.models)
+
+    if not relations and not derived_list and not indexes:
+        print(f"No models found in {args.models}")
+        return 1
+
+    # Build current state
+    new_state = ModelState.from_models(
+        relations=relations,
+        derived=derived_list,
+        indexes=indexes,
+    )
+
+    # Load previous state
+    old_state_dict = get_latest_state(migrations_dir)
+    old_state = ModelState.from_dict(old_state_dict)
+
+    # Detect changes
+    operations = detect_changes(old_state, new_state)
+
+    if not operations:
+        print("No changes detected.")
+        return 0
+
+    # Generate migration file
+    number = get_next_number(migrations_dir)
+    migrations = load_migrations(migrations_dir)
+    deps = [migrations[-1].name] if migrations else []
+
+    filename, content = generate_migration(
+        number,
+        operations,
+        new_state.to_dict(),
+        deps,
+        name_suffix=args.name if hasattr(args, "name") and args.name else None,
+    )
+
+    filepath = migrations_dir / filename
+    filepath.write_text(content)
+
+    print(f"Created migration: {filepath}")
+    for op in operations:
+        print(f"  - {op.describe()}")
+
+    return 0
+
+
+def _cmd_migrate(args: argparse.Namespace) -> int:
+    """Apply pending migrations."""
+    from inputlayer.client_sync import InputLayerSync
+    from inputlayer.migrations.executor import migrate
+    from inputlayer.migrations.recorder import MigrationRecorder
+
+    migrations_dir = Path(args.migrations_dir)
+    migrations = load_migrations(migrations_dir)
+
+    if not migrations:
+        print("No migrations found.")
+        return 0
+
+    client = InputLayerSync(
+        args.url,
+        username=args.username,
+        password=args.password,
+        api_key=args.api_key,
+    )
+    with client:
+        kg = client.knowledge_graph(args.kg)
+        recorder = MigrationRecorder(kg)
+        applied = migrate(kg, migrations, recorder)
+
+    if applied:
+        print(f"Applied {len(applied)} migration(s):")
+        for name in applied:
+            print(f"  [X] {name}")
+    else:
+        print("No migrations to apply.")
+
+    return 0
+
+
+def _cmd_revert(args: argparse.Namespace) -> int:
+    """Revert migrations back to a target."""
+    from inputlayer.client_sync import InputLayerSync
+    from inputlayer.migrations.executor import revert_to
+    from inputlayer.migrations.recorder import MigrationRecorder
+
+    migrations_dir = Path(args.migrations_dir)
+    migrations = load_migrations(migrations_dir)
+
+    client = InputLayerSync(
+        args.url,
+        username=args.username,
+        password=args.password,
+        api_key=args.api_key,
+    )
+    with client:
+        kg = client.knowledge_graph(args.kg)
+        recorder = MigrationRecorder(kg)
+        reverted = revert_to(kg, migrations, recorder, args.target)
+
+    if reverted:
+        print(f"Reverted {len(reverted)} migration(s):")
+        for name in reverted:
+            print(f"  [ ] {name}")
+    else:
+        print("Nothing to revert.")
+
+    return 0
+
+
+def _cmd_showmigrations(args: argparse.Namespace) -> int:
+    """Show migration status."""
+    from inputlayer.client_sync import InputLayerSync
+    from inputlayer.migrations.recorder import MigrationRecorder
+
+    migrations_dir = Path(args.migrations_dir)
+    migrations = load_migrations(migrations_dir)
+
+    if not migrations:
+        print("No migrations found.")
+        return 0
+
+    client = InputLayerSync(
+        args.url,
+        username=args.username,
+        password=args.password,
+        api_key=args.api_key,
+    )
+    with client:
+        kg = client.knowledge_graph(args.kg)
+        recorder = MigrationRecorder(kg)
+        recorder.ensure_schema()
+        applied = set(recorder.get_applied())
+
+    for m in migrations:
+        mark = "X" if m.name in applied else " "
+        print(f"  [{mark}] {m.name}")
+
+    return 0
+
+
+def _add_connection_args(parser: argparse.ArgumentParser) -> None:
+    """Add common connection arguments to a subparser."""
+    parser.add_argument("--url", required=True, help="WebSocket URL (e.g. ws://localhost:8080/ws)")
+    parser.add_argument("--kg", required=True, help="Knowledge graph name")
+    parser.add_argument("--username", default=None, help="Username for authentication")
+    parser.add_argument("--password", default=None, help="Password for authentication")
+    parser.add_argument("--api-key", dest="api_key", default=None, help="API key for authentication")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="inputlayer-migrate",
+        description="InputLayer migration management tool",
+    )
+    parser.add_argument(
+        "--migrations-dir",
+        default="migrations",
+        help="Directory for migration files (default: ./migrations)",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # makemigrations
+    make = subparsers.add_parser("makemigrations", help="Generate a new migration")
+    make.add_argument("--models", required=True, help="Python module path containing models (e.g. myapp.models)")
+    make.add_argument("--name", default=None, help="Custom migration name suffix")
+    make.set_defaults(func=_cmd_makemigrations)
+
+    # migrate
+    mig = subparsers.add_parser("migrate", help="Apply pending migrations")
+    _add_connection_args(mig)
+    mig.set_defaults(func=_cmd_migrate)
+
+    # revert
+    rev = subparsers.add_parser("revert", help="Revert migrations to a target")
+    _add_connection_args(rev)
+    rev.add_argument("target", help="Migration name to revert to (e.g. 0001_initial)")
+    rev.set_defaults(func=_cmd_revert)
+
+    # showmigrations
+    show = subparsers.add_parser("showmigrations", help="Show migration status")
+    _add_connection_args(show)
+    show.set_defaults(func=_cmd_showmigrations)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 1
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

inputlayer/migrations/executor.py

@@ -0,0 +1,95 @@
+"""Migration executor - apply and revert migrations against a KG."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from inputlayer.migrations.loader import MigrationInfo
+from inputlayer.migrations.recorder import KGExecutor, MigrationRecorder
+
+
+class MigrationError(Exception):
+    """Raised when a migration fails to apply or revert."""
+
+
+def apply_migration(kg: KGExecutor, migration: MigrationInfo) -> None:
+    """Apply a single migration's forward operations."""
+    for op in migration.operations:
+        for cmd in op.forward_commands():
+            kg.execute(cmd)
+
+
+def revert_migration(kg: KGExecutor, migration: MigrationInfo) -> None:
+    """Revert a single migration's operations in reverse order."""
+    for op in reversed(migration.operations):
+        for cmd in op.backward_commands():
+            kg.execute(cmd)
+
+
+def migrate(
+    kg: KGExecutor,
+    migrations: list[MigrationInfo],
+    recorder: MigrationRecorder,
+    *,
+    target: str | None = None,
+) -> list[str]:
+    """Apply unapplied migrations up to target (or all if target is None).
+
+    Returns list of applied migration names.
+    """
+    recorder.ensure_schema()
+    applied = set(recorder.get_applied())
+    applied_names: list[str] = []
+
+    for m in migrations:
+        if m.name in applied:
+            continue
+        if target is not None and m.name == target:
+            break
+
+        apply_migration(kg, m)
+        recorder.record_applied(m.name)
+        applied_names.append(m.name)
+
+        if target is not None and m.name == target:
+            break
+
+    return applied_names
+
+
+def revert_to(
+    kg: KGExecutor,
+    migrations: list[MigrationInfo],
+    recorder: MigrationRecorder,
+    target: str,
+) -> list[str]:
+    """Revert migrations back to (but not including) target.
+
+    Returns list of reverted migration names.
+    """
+    recorder.ensure_schema()
+    applied = set(recorder.get_applied())
+
+    # Find target index
+    target_idx = None
+    for i, m in enumerate(migrations):
+        if m.name == target:
+            target_idx = i
+            break
+
+    if target_idx is None:
+        raise MigrationError(f"Migration {target!r} not found")
+
+    # Revert in reverse order: everything after target that's applied
+    to_revert = [
+        m for m in reversed(migrations[target_idx + 1:])
+        if m.name in applied
+    ]
+
+    reverted_names: list[str] = []
+    for m in to_revert:
+        revert_migration(kg, m)
+        recorder.record_reverted(m.name)
+        reverted_names.append(m.name)
+
+    return reverted_names

inputlayer/migrations/loader.py

@@ -0,0 +1,91 @@
+"""Migration loader - discover and import migration files from a directory."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from inputlayer.migrations import Migration
+
+
+@dataclass
+class MigrationInfo:
+    """Metadata about a loaded migration file."""
+
+    name: str           # e.g. "0001_initial"
+    number: int         # e.g. 1
+    filename: str       # e.g. "0001_initial.py"
+    dependencies: list[str]
+    operations: list    # list[Operation]
+    state: dict[str, Any]
+
+    @property
+    def module_name(self) -> str:
+        return self.name
+
+
+_MIGRATION_RE = re.compile(r"^(\d{4})_.+\.py$")
+
+
+def load_migrations(directory: str | Path) -> list[MigrationInfo]:
+    """Discover and load all migration files from a directory.
+
+    Returns migrations sorted by number.
+    """
+    directory = Path(directory)
+    if not directory.is_dir():
+        return []
+
+    migrations: list[MigrationInfo] = []
+    for entry in sorted(directory.iterdir()):
+        if not entry.is_file():
+            continue
+        match = _MIGRATION_RE.match(entry.name)
+        if not match:
+            continue
+
+        number = int(match.group(1))
+        name = entry.stem  # e.g. "0001_initial"
+
+        # Import the module dynamically
+        spec = importlib.util.spec_from_file_location(f"migrations.{name}", entry)
+        if spec is None or spec.loader is None:
+            continue
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Extract the M class
+        m_cls = getattr(module, "M", None)
+        if m_cls is None or not (isinstance(m_cls, type) and issubclass(m_cls, Migration)):
+            continue
+
+        migrations.append(MigrationInfo(
+            name=name,
+            number=number,
+            filename=entry.name,
+            dependencies=list(getattr(m_cls, "dependencies", [])),
+            operations=list(getattr(m_cls, "operations", [])),
+            state=dict(getattr(m_cls, "state", {})),
+        ))
+
+    return sorted(migrations, key=lambda m: m.number)
+
+
+def get_latest_state(directory: str | Path) -> dict[str, Any]:
+    """Get the state from the most recent migration, or empty if none exist."""
+    migrations = load_migrations(directory)
+    if not migrations:
+        return {"relations": {}, "rules": {}, "indexes": {}}
+    return migrations[-1].state
+
+
+def get_next_number(directory: str | Path) -> int:
+    """Get the next migration number."""
+    migrations = load_migrations(directory)
+    if not migrations:
+        return 1
+    return migrations[-1].number + 1