cinchdb 0.1.0__py3-none-any.whl

cinchdb/core/path_utils.py

@@ -0,0 +1,153 @@
+"""Path utilities for CinchDB."""
+
+from pathlib import Path
+from typing import List
+
+
+def get_project_root(start_path: Path) -> Path:
+    """Find the project root by looking for .cinchdb directory.
+
+    Args:
+        start_path: Path to start searching from
+
+    Returns:
+        Path to project root
+
+    Raises:
+        FileNotFoundError: If no project root found
+    """
+    current = Path(start_path).resolve()
+
+    while current != current.parent:
+        if (current / ".cinchdb").exists():
+            return current
+        current = current.parent
+
+    raise FileNotFoundError(f"No CinchDB project found from {start_path}")
+
+
+def get_database_path(project_root: Path, database: str) -> Path:
+    """Get path to a database directory.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+
+    Returns:
+        Path to database directory
+    """
+    return project_root / ".cinchdb" / "databases" / database
+
+
+def get_branch_path(project_root: Path, database: str, branch: str) -> Path:
+    """Get path to a branch directory.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+
+    Returns:
+        Path to branch directory
+    """
+    return get_database_path(project_root, database) / "branches" / branch
+
+
+def get_tenant_path(
+    project_root: Path, database: str, branch: str, tenant: str
+) -> Path:
+    """Get path to tenant directory.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+        tenant: Tenant name
+
+    Returns:
+        Path to tenant directory
+    """
+    return get_branch_path(project_root, database, branch) / "tenants"
+
+
+def get_tenant_db_path(
+    project_root: Path, database: str, branch: str, tenant: str
+) -> Path:
+    """Get path to tenant database file.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+        tenant: Tenant name
+
+    Returns:
+        Path to tenant database file
+    """
+    return get_tenant_path(project_root, database, branch, tenant) / f"{tenant}.db"
+
+
+def ensure_directory(path: Path) -> None:
+    """Ensure a directory exists, creating it if necessary.
+
+    Args:
+        path: Directory path to ensure exists
+    """
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def list_databases(project_root: Path) -> List[str]:
+    """List all databases in a project.
+
+    Args:
+        project_root: Project root directory
+
+    Returns:
+        List of database names
+    """
+    db_dir = project_root / ".cinchdb" / "databases"
+    if not db_dir.exists():
+        return []
+
+    return sorted([d.name for d in db_dir.iterdir() if d.is_dir()])
+
+
+def list_branches(project_root: Path, database: str) -> List[str]:
+    """List all branches in a database.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+
+    Returns:
+        List of branch names
+    """
+    branches_dir = get_database_path(project_root, database) / "branches"
+    if not branches_dir.exists():
+        return []
+
+    return sorted([b.name for b in branches_dir.iterdir() if b.is_dir()])
+
+
+def list_tenants(project_root: Path, database: str, branch: str) -> List[str]:
+    """List all tenants in a branch.
+
+    Args:
+        project_root: Project root directory
+        database: Database name
+        branch: Branch name
+
+    Returns:
+        List of tenant names
+    """
+    tenants_dir = get_branch_path(project_root, database, branch) / "tenants"
+    if not tenants_dir.exists():
+        return []
+
+    # Only list .db files, not WAL or SHM files
+    tenants = []
+    for f in tenants_dir.iterdir():
+        if f.is_file() and f.suffix == ".db":
+            tenants.append(f.stem)
+
+    return sorted(tenants)

cinchdb/managers/__init__.py

@@ -0,0 +1,26 @@
+"""CinchDB managers."""
+
+from cinchdb.managers.branch import BranchManager
+from cinchdb.managers.tenant import TenantManager
+from cinchdb.managers.change_tracker import ChangeTracker
+from cinchdb.managers.change_applier import ChangeApplier
+from cinchdb.managers.change_comparator import ChangeComparator
+from cinchdb.managers.merge_manager import MergeManager, MergeError
+from cinchdb.managers.table import TableManager
+from cinchdb.managers.column import ColumnManager
+from cinchdb.managers.view import ViewModel
+from cinchdb.managers.codegen import CodegenManager
+
+__all__ = [
+    "BranchManager",
+    "TenantManager",
+    "ChangeTracker",
+    "ChangeApplier",
+    "ChangeComparator",
+    "MergeManager",
+    "MergeError",
+    "TableManager",
+    "ColumnManager",
+    "ViewModel",
+    "CodegenManager",
+]

cinchdb/managers/branch.py

@@ -0,0 +1,167 @@
+"""Branch management for CinchDB."""
+
+import json
+import shutil
+from pathlib import Path
+from typing import List, Dict, Any
+from datetime import datetime, timezone
+
+from cinchdb.config import Config
+from cinchdb.models import Branch
+from cinchdb.core.path_utils import (
+    get_database_path,
+    get_branch_path,
+    list_branches,
+)
+
+
+class BranchManager:
+    """Manages branches within a database."""
+
+    def __init__(self, project_root: Path, database: str):
+        """Initialize branch manager.
+
+        Args:
+            project_root: Path to project root
+            database: Database name
+        """
+        self.project_root = Path(project_root)
+        self.database = database
+        self.db_path = get_database_path(self.project_root, database)
+
+    def list_branches(self) -> List[Branch]:
+        """List all branches in the database.
+
+        Returns:
+            List of Branch objects
+        """
+        branch_names = list_branches(self.project_root, self.database)
+        branches = []
+
+        for name in branch_names:
+            metadata = self.get_branch_metadata(name)
+            branch = Branch(
+                name=name,
+                database=self.database,
+                parent_branch=metadata.get("parent_branch"),
+                is_main=(name == "main"),
+                metadata=metadata,
+            )
+            branches.append(branch)
+
+        return branches
+
+    def create_branch(self, source_branch: str, new_branch_name: str) -> Branch:
+        """Create a new branch from an existing branch.
+
+        Args:
+            source_branch: Name of branch to copy from
+            new_branch_name: Name for the new branch
+
+        Returns:
+            Created Branch object
+
+        Raises:
+            ValueError: If source doesn't exist or new branch already exists
+        """
+        # Validate source branch exists
+        if source_branch not in list_branches(self.project_root, self.database):
+            raise ValueError(f"Source branch '{source_branch}' does not exist")
+
+        # Validate new branch doesn't exist
+        if new_branch_name in list_branches(self.project_root, self.database):
+            raise ValueError(f"Branch '{new_branch_name}' already exists")
+
+        # Get paths
+        source_path = get_branch_path(self.project_root, self.database, source_branch)
+        new_path = get_branch_path(self.project_root, self.database, new_branch_name)
+
+        # Copy entire branch directory
+        shutil.copytree(source_path, new_path)
+
+        # Update metadata for new branch
+        metadata = self.get_branch_metadata(new_branch_name)
+        metadata["parent_branch"] = source_branch
+        metadata["created_at"] = datetime.now(timezone.utc).isoformat()
+        self.update_branch_metadata(new_branch_name, metadata)
+
+        # New branch inherits all changes from source branch
+        # (changes.json is already copied by copytree, so nothing to do here)
+
+        return Branch(
+            name=new_branch_name,
+            database=self.database,
+            parent_branch=source_branch,
+            is_main=False,
+            metadata=metadata,
+        )
+
+    def delete_branch(self, branch_name: str) -> None:
+        """Delete a branch.
+
+        Args:
+            branch_name: Name of branch to delete
+
+        Raises:
+            ValueError: If branch doesn't exist or is main branch
+        """
+        # Can't delete main branch
+        if branch_name == "main":
+            raise ValueError("Cannot delete the main branch")
+
+        # Validate branch exists
+        if branch_name not in list_branches(self.project_root, self.database):
+            raise ValueError(f"Branch '{branch_name}' does not exist")
+
+        # Delete branch directory
+        branch_path = get_branch_path(self.project_root, self.database, branch_name)
+        shutil.rmtree(branch_path)
+
+
+    def get_branch_metadata(self, branch_name: str) -> Dict[str, Any]:
+        """Get metadata for a branch.
+
+        Args:
+            branch_name: Branch name
+
+        Returns:
+            Metadata dictionary
+        """
+        metadata_path = (
+            get_branch_path(self.project_root, self.database, branch_name)
+            / "metadata.json"
+        )
+
+        if metadata_path.exists():
+            with open(metadata_path, "r") as f:
+                return json.load(f)
+
+        return {}
+
+    def update_branch_metadata(
+        self, branch_name: str, metadata: Dict[str, Any]
+    ) -> None:
+        """Update metadata for a branch.
+
+        Args:
+            branch_name: Branch name
+            metadata: Metadata dictionary to save
+        """
+        metadata_path = (
+            get_branch_path(self.project_root, self.database, branch_name)
+            / "metadata.json"
+        )
+
+        with open(metadata_path, "w") as f:
+            json.dump(metadata, f, indent=2)
+
+    def branch_exists(self, branch_name: str) -> bool:
+        """Check if a branch exists.
+
+        Args:
+            branch_name: Branch name to check
+
+        Returns:
+            True if branch exists, False otherwise
+        """
+        return branch_name in list_branches(self.project_root, self.database)