cinchdb 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

cinchdb/config.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field, ConfigDict
 
 class RemoteConfig(BaseModel):
     """Configuration for a remote CinchDB instance."""
-    
+
     url: str = Field(description="Base URL of the remote CinchDB API")
     key: str = Field(description="API key for authentication")
 
@@ -50,7 +50,7 @@ class Config:
             env_dir = os.environ.get("CINCHDB_PROJECT_DIR")
             if env_dir:
                 project_dir = Path(env_dir)
-        
+
         self.project_dir = Path(project_dir) if project_dir else Path.cwd()
         self.config_dir = self.project_dir / ".cinchdb"
         self.config_path = self.config_dir / "config.toml"
@@ -86,24 +86,24 @@ class Config:
         # Override database and branch
         if env_db := os.environ.get("CINCHDB_DATABASE"):
             data["active_database"] = env_db
-        
+
         if env_branch := os.environ.get("CINCHDB_BRANCH"):
             data["active_branch"] = env_branch
-        
+
         # Override or create remote configuration
         env_url = os.environ.get("CINCHDB_REMOTE_URL")
         env_key = os.environ.get("CINCHDB_API_KEY")
-        
+
         if env_url and env_key:
             # Create or update "env" remote
             if "remotes" not in data:
                 data["remotes"] = {}
-            
+
             data["remotes"]["env"] = {
                 "url": env_url.rstrip("/"),  # Remove trailing slash
-                "key": env_key
+                "key": env_key,
             }
-            
+
             # Make it active if no other remote is set
             if not data.get("active_remote"):
                 data["active_remote"] = "env"
@@ -130,48 +130,21 @@ class Config:
             for alias, remote in config_dict["remotes"].items():
                 if isinstance(remote, dict):
                     config_dict["remotes"][alias] = remote
-        
+
         with open(self.config_path, "w") as f:
             toml.dump(config_dict, f)
 
     def init_project(self) -> ProjectConfig:
-        """Initialize a new CinchDB project with default configuration."""
-        if self.exists:
-            raise FileExistsError(f"Project already exists at {self.config_dir}")
+        """Initialize a new CinchDB project with default configuration.
 
-        # Create default config
-        config = ProjectConfig()
-        self.save(config)
+        This method now delegates to the ProjectInitializer for the actual
+        initialization logic.
+        """
+        from cinchdb.core.initializer import ProjectInitializer
 
-        # Create default database structure
-        self._create_default_structure()
+        initializer = ProjectInitializer(self.project_dir)
+        config = initializer.init_project()
 
+        # Load the config into this instance
+        self._config = config
         return config
-
-    def _create_default_structure(self) -> None:
-        """Create default project structure."""
-        # Create main database with main branch
-        db_path = self.config_dir / "databases" / "main" / "branches" / "main"
-        db_path.mkdir(parents=True, exist_ok=True)
-
-        # Create metadata files
-        from datetime import datetime, timezone
-
-        metadata = {"created_at": datetime.now(timezone.utc).isoformat()}
-
-        import json
-
-        with open(db_path / "metadata.json", "w") as f:
-            json.dump(metadata, f, indent=2)
-
-        # Create empty changes file
-        with open(db_path / "changes.json", "w") as f:
-            json.dump([], f, indent=2)
-
-        # Create main tenant directory and database
-        tenant_dir = db_path / "tenants"
-        tenant_dir.mkdir(exist_ok=True)
-
-        # Create main tenant database file
-        main_db = tenant_dir / "main.db"
-        main_db.touch()

cinchdb/core/__init__.py

@@ -1,5 +1,6 @@
 """Core CinchDB functionality."""
 
 from cinchdb.core.database import CinchDB, connect, connect_api
+from cinchdb.core.initializer import init_project, init_database
 
-__all__ = ["CinchDB", "connect", "connect_api"]
+__all__ = ["CinchDB", "connect", "connect_api", "init_project", "init_database"]

cinchdb/core/database.py

@@ -3,10 +3,9 @@
 from pathlib import Path
 from typing import List, Dict, Any, Optional, TYPE_CHECKING
 
-from cinchdb.config import Config
 from cinchdb.models import Column, Change
 from cinchdb.core.path_utils import get_project_root
-from cinchdb.utils import validate_query_safe, SQLValidationError
+from cinchdb.utils import validate_query_safe
 
 if TYPE_CHECKING:
     from cinchdb.managers.table import TableManager
@@ -307,7 +306,10 @@ class CinchDB:
     # Convenience methods for common operations
 
     def query(
-        self, sql: str, params: Optional[List[Any]] = None, skip_validation: bool = False
+        self,
+        sql: str,
+        params: Optional[List[Any]] = None,
+        skip_validation: bool = False,
     ) -> List[Dict[str, Any]]:
         """Execute a SQL query.
 
@@ -318,14 +320,14 @@ class CinchDB:
 
         Returns:
             List of result rows as dictionaries
-            
+
         Raises:
             SQLValidationError: If the query contains restricted operations
         """
         # Validate query unless explicitly skipped
         if not skip_validation:
             validate_query_safe(sql)
-            
+
         if self.is_local:
             if self._query_manager is None:
                 from cinchdb.managers.query import QueryManager
@@ -427,6 +429,7 @@ class CinchDB:
         """
         if self.is_local:
             from cinchdb.managers.change_tracker import ChangeTracker
+
             tracker = ChangeTracker(self.project_dir, self.database, self.branch)
             return tracker.get_changes()
         else:
@@ -435,6 +438,7 @@ class CinchDB:
             # Convert API response to Change objects
             from cinchdb.models import Change
             from datetime import datetime
+
             changes = []
             for data in result.get("changes", []):
                 # Convert string dates back to datetime if present

cinchdb/core/initializer.py

@@ -0,0 +1,214 @@
+"""Project initialization for CinchDB."""
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.config import ProjectConfig
+
+
+class ProjectInitializer:
+    """Handles initialization of CinchDB projects."""
+
+    def __init__(self, project_dir: Optional[Path] = None):
+        """Initialize the project initializer.
+
+        Args:
+            project_dir: Path to project directory. If None, uses current directory.
+        """
+        self.project_dir = Path(project_dir) if project_dir else Path.cwd()
+        self.config_dir = self.project_dir / ".cinchdb"
+        self.config_path = self.config_dir / "config.toml"
+
+    def init_project(
+        self, database_name: str = "main", branch_name: str = "main"
+    ) -> ProjectConfig:
+        """Initialize a new CinchDB project with default configuration.
+
+        Args:
+            database_name: Name for the initial database (default: "main")
+            branch_name: Name for the initial branch (default: "main")
+
+        Returns:
+            The created ProjectConfig
+
+        Raises:
+            FileExistsError: If project already exists at the location
+        """
+        if self.config_path.exists():
+            raise FileExistsError(f"Project already exists at {self.config_dir}")
+
+        # Create config directory
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create default config
+        config = ProjectConfig(active_database=database_name, active_branch=branch_name)
+
+        # Save config
+        self._save_config(config)
+
+        # Create default database structure
+        self._create_database_structure(database_name, branch_name)
+
+        return config
+
+    def init_database(
+        self,
+        database_name: str,
+        branch_name: str = "main",
+        description: Optional[str] = None,
+    ) -> None:
+        """Initialize a new database within an existing project.
+
+        Args:
+            database_name: Name for the database
+            branch_name: Initial branch name (default: "main")
+            description: Optional description for the database
+
+        Raises:
+            FileNotFoundError: If project doesn't exist
+            FileExistsError: If database already exists
+        """
+        if not self.config_path.exists():
+            raise FileNotFoundError(f"No CinchDB project found at {self.config_dir}")
+
+        db_path = self.config_dir / "databases" / database_name
+        if db_path.exists():
+            raise FileExistsError(f"Database '{database_name}' already exists")
+
+        # Create database structure
+        self._create_database_structure(database_name, branch_name, description)
+
+    def _create_database_structure(
+        self,
+        database_name: str,
+        branch_name: str = "main",
+        description: Optional[str] = None,
+    ) -> None:
+        """Create the directory structure for a database.
+
+        Args:
+            database_name: Name of the database
+            branch_name: Name of the initial branch
+            description: Optional description
+        """
+        # Create database branch path
+        branch_path = (
+            self.config_dir / "databases" / database_name / "branches" / branch_name
+        )
+        branch_path.mkdir(parents=True, exist_ok=True)
+
+        # Create metadata file
+        metadata = {
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "name": branch_name,
+            "parent": None,
+            "description": description,
+        }
+
+        with open(branch_path / "metadata.json", "w") as f:
+            json.dump(metadata, f, indent=2)
+
+        # Create empty changes file
+        with open(branch_path / "changes.json", "w") as f:
+            json.dump([], f, indent=2)
+
+        # Create tenants directory
+        tenant_dir = branch_path / "tenants"
+        tenant_dir.mkdir(exist_ok=True)
+
+        # Create and initialize main tenant database
+        self._init_tenant_database(tenant_dir / "main.db")
+
+    def _init_tenant_database(self, db_path: Path) -> None:
+        """Initialize a tenant database with proper PRAGMAs.
+
+        Args:
+            db_path: Path to the database file
+        """
+        # Create the database file
+        db_path.touch()
+
+        # Initialize with proper PRAGMAs
+        with DatabaseConnection(db_path):
+            # The connection automatically sets up PRAGMAs in _connect():
+            # - journal_mode = WAL
+            # - synchronous = NORMAL
+            # - wal_autocheckpoint = 0
+            # - foreign_keys = ON
+            pass
+
+    def _save_config(self, config: ProjectConfig) -> None:
+        """Save configuration to disk.
+
+        Args:
+            config: Configuration to save
+        """
+        import toml
+
+        # Ensure config directory exists
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Convert to dict for TOML serialization
+        config_dict = config.model_dump()
+
+        # Convert RemoteConfig objects to dicts if present
+        if "remotes" in config_dict:
+            for alias, remote in config_dict["remotes"].items():
+                if isinstance(remote, dict):
+                    config_dict["remotes"][alias] = remote
+
+        with open(self.config_path, "w") as f:
+            toml.dump(config_dict, f)
+
+
+def init_project(
+    project_dir: Optional[Path] = None,
+    database_name: str = "main",
+    branch_name: str = "main",
+) -> ProjectConfig:
+    """Initialize a new CinchDB project.
+
+    This is a convenience function that creates a ProjectInitializer
+    and initializes a project.
+
+    Args:
+        project_dir: Directory to initialize in (default: current directory)
+        database_name: Name for initial database (default: "main")
+        branch_name: Name for initial branch (default: "main")
+
+    Returns:
+        The created ProjectConfig
+
+    Raises:
+        FileExistsError: If project already exists
+    """
+    initializer = ProjectInitializer(project_dir)
+    return initializer.init_project(database_name, branch_name)
+
+
+def init_database(
+    project_dir: Optional[Path] = None,
+    database_name: str = "main",
+    branch_name: str = "main",
+    description: Optional[str] = None,
+) -> None:
+    """Initialize a new database within an existing project.
+
+    This is a convenience function that creates a ProjectInitializer
+    and initializes a database.
+
+    Args:
+        project_dir: Project directory (default: current directory)
+        database_name: Name for the database
+        branch_name: Initial branch name (default: "main")
+        description: Optional description
+
+    Raises:
+        FileNotFoundError: If project doesn't exist
+        FileExistsError: If database already exists
+    """
+    initializer = ProjectInitializer(project_dir)
+    initializer.init_database(database_name, branch_name, description)

cinchdb/managers/branch.py

@@ -6,7 +6,6 @@ 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,
@@ -68,7 +67,7 @@ class BranchManager:
         """
         # Validate new branch name
         validate_name(new_branch_name, "branch")
-        
+
         # 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")
@@ -122,7 +121,6 @@ class BranchManager:
         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.
 

cinchdb/managers/column.py

@@ -439,16 +439,20 @@ class ColumnManager:
             conn.commit()
 
     def alter_column_nullable(
-        self, table_name: str, column_name: str, nullable: bool, fill_value: Optional[Any] = None
+        self,
+        table_name: str,
+        column_name: str,
+        nullable: bool,
+        fill_value: Optional[Any] = None,
     ) -> None:
         """Change the nullable constraint on a column.
-        
+
         Args:
             table_name: Name of the table
             column_name: Name of the column to modify
             nullable: Whether the column should allow NULL values
             fill_value: Value to use for existing NULL values when making column NOT NULL
-        
+
         Raises:
             ValueError: If table/column doesn't exist or column is protected
             ValueError: If making NOT NULL and column has NULL values without fill_value
@@ -469,13 +473,13 @@ class ColumnManager:
         existing_columns = self.list_columns(table_name)
         column_found = False
         old_column = None
-        
+
         for col in existing_columns:
             if col.name == column_name:
                 column_found = True
                 old_column = col
                 break
-                
+
         if not column_found:
             raise ValueError(
                 f"Column '{column_name}' does not exist in table '{table_name}'"
@@ -494,7 +498,7 @@ class ColumnManager:
                     f"SELECT COUNT(*) FROM {table_name} WHERE {column_name} IS NULL"
                 )
                 null_count = cursor.fetchone()[0]
-                
+
                 if null_count > 0 and fill_value is None:
                     raise ValueError(
                         f"Column '{column_name}' has {null_count} NULL values. "
@@ -503,7 +507,7 @@ class ColumnManager:
 
         # Build SQL statements for table recreation
         temp_table = f"{table_name}_temp"
-        
+
         # Create new table with modified column
         col_defs = []
         for col in existing_columns:
@@ -527,7 +531,7 @@ class ColumnManager:
         # Column names for copying
         col_names = [col.name for col in existing_columns]
         col_list = ", ".join(col_names)
-        
+
         # Build copy SQL with COALESCE if needed
         if not nullable and fill_value is not None:
             # Build select list with COALESCE for the target column
@@ -545,7 +549,7 @@ class ColumnManager:
             copy_sql = f"INSERT INTO {temp_table} ({col_list}) SELECT {select_list} FROM {table_name}"
         else:
             copy_sql = f"INSERT INTO {temp_table} ({col_list}) SELECT {col_list} FROM {table_name}"
-            
+
         drop_sql = f"DROP TABLE {table_name}"
         rename_sql = f"ALTER TABLE {temp_table} RENAME TO {table_name}"
 

cinchdb/managers/query.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel, ValidationError
 
 from cinchdb.core.connection import DatabaseConnection
 from cinchdb.core.path_utils import get_tenant_db_path
-from cinchdb.utils import validate_query_safe, SQLValidationError
+from cinchdb.utils import validate_query_safe
 
 T = TypeVar("T", bound=BaseModel)
 
@@ -33,7 +33,10 @@ class QueryManager:
         self.db_path = get_tenant_db_path(project_root, database, branch, tenant)
 
     def execute(
-        self, sql: str, params: Optional[Union[tuple, dict]] = None, skip_validation: bool = False
+        self,
+        sql: str,
+        params: Optional[Union[tuple, dict]] = None,
+        skip_validation: bool = False,
     ) -> List[Dict[str, Any]]:
         """Execute a SQL query and return results as dictionaries.
 
@@ -52,7 +55,7 @@ class QueryManager:
         # Validate query unless explicitly skipped
         if not skip_validation:
             validate_query_safe(sql)
-            
+
         # Note: The original code had SELECT-only validation, but we're now more permissive
         if not sql.strip().upper().startswith("SELECT"):
             raise ValueError(
@@ -161,7 +164,10 @@ class QueryManager:
         return results[0] if results else None
 
     def execute_non_query(
-        self, sql: str, params: Optional[Union[tuple, dict]] = None, skip_validation: bool = False
+        self,
+        sql: str,
+        params: Optional[Union[tuple, dict]] = None,
+        skip_validation: bool = False,
     ) -> int:
         """Execute a non-SELECT SQL query (INSERT, UPDATE, DELETE, etc.).
 
@@ -172,7 +178,7 @@ class QueryManager:
 
         Returns:
             Number of rows affected
-            
+
         Raises:
             SQLValidationError: If query contains restricted operations
             Exception: If query execution fails
@@ -180,7 +186,7 @@ class QueryManager:
         # Validate query unless explicitly skipped
         if not skip_validation:
             validate_query_safe(sql)
-            
+
         with DatabaseConnection(self.db_path) as conn:
             cursor = conn.execute(sql, params)
             affected_rows = cursor.rowcount

cinchdb/managers/table.py

@@ -95,13 +95,13 @@ class TableManager:
         for column in columns:
             if column.foreign_key:
                 fk = column.foreign_key
-                
+
                 # Validate referenced table exists
                 if not self._table_exists(fk.table):
                     raise ValueError(
                         f"Foreign key reference to non-existent table: '{fk.table}'"
                     )
-                
+
                 # Validate referenced column exists
                 ref_table = self.get_table(fk.table)
                 ref_col_names = [col.name for col in ref_table.columns]
@@ -109,9 +109,11 @@ class TableManager:
                     raise ValueError(
                         f"Foreign key reference to non-existent column: '{fk.table}.{fk.column}'"
                     )
-                
+
                 # Build foreign key constraint
-                fk_constraint = f"FOREIGN KEY ({column.name}) REFERENCES {fk.table}({fk.column})"
+                fk_constraint = (
+                    f"FOREIGN KEY ({column.name}) REFERENCES {fk.table}({fk.column})"
+                )
                 if fk.on_delete != "RESTRICT":
                     fk_constraint += f" ON DELETE {fk.on_delete}"
                 if fk.on_update != "RESTRICT":
@@ -143,7 +145,7 @@ class TableManager:
                 col_def += " UNIQUE"
 
             sql_parts.append(col_def)
-        
+
         # Add foreign key constraints
         sql_parts.extend(foreign_key_constraints)
 
@@ -201,16 +203,17 @@ class TableManager:
                 to_col = fk_row["to"]
                 on_update = fk_row["on_update"]
                 on_delete = fk_row["on_delete"]
-                
+
                 # Create ForeignKeyRef
                 from cinchdb.models import ForeignKeyRef
+
                 foreign_keys[from_col] = ForeignKeyRef(
                     table=to_table,
                     column=to_col,
                     on_update=on_update,
-                    on_delete=on_delete
+                    on_delete=on_delete,
                 )
-            
+
             # Get column information
             cursor = conn.execute(f"PRAGMA table_info({table_name})")
 
@@ -241,7 +244,7 @@ class TableManager:
                     nullable=(row["notnull"] == 0),
                     default=row["dflt_value"],
                     primary_key=(row["pk"] == 1),
-                    foreign_key=foreign_key
+                    foreign_key=foreign_key,
                 )
                 columns.append(column)
 

cinchdb/managers/tenant.py

@@ -70,7 +70,7 @@ class TenantManager:
         """
         # Validate tenant name
         validate_name(tenant_name, "tenant")
-        
+
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -168,7 +168,7 @@ class TenantManager:
         """
         # Validate target tenant name
         validate_name(target_tenant, "tenant")
-        
+
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -213,7 +213,7 @@ class TenantManager:
         """
         # Validate new tenant name
         validate_name(new_name, "tenant")
-        
+
         # Can't rename main tenant
         if old_name == "main":
             raise ValueError("Cannot rename the main tenant")

cinchdb/models/branch.py

@@ -22,7 +22,7 @@ class Branch(CinchDBBaseModel):
     )
     is_main: bool = Field(default=False, description="Whether this is the main branch")
 
-    @field_validator('name')
+    @field_validator("name")
     @classmethod
     def validate_name_field(cls, v: str) -> str:
         """Validate branch name meets naming requirements."""

cinchdb/models/database.py

@@ -16,7 +16,7 @@ class Database(CinchDBBaseModel):
     active_branch: str = Field(default="main", description="Currently active branch")
     description: Optional[str] = Field(default=None, description="Database description")
 
-    @field_validator('name')
+    @field_validator("name")
     @classmethod
     def validate_name_field(cls, v: str) -> str:
         """Validate database name meets naming requirements."""