fraiseql-confiture 0.3.7__cp311-cp311-macosx_11_0_arm64.whl

confiture/models/schema.py

@@ -0,0 +1,203 @@
+"""Data models for schema representation.
+
+These models represent database schema objects (tables, columns, indexes, etc.)
+in a structured format for diff detection and comparison.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ColumnType(str, Enum):
+    """PostgreSQL column types."""
+
+    # Integer types
+    SMALLINT = "SMALLINT"
+    INTEGER = "INTEGER"
+    BIGINT = "BIGINT"
+    SERIAL = "SERIAL"
+    BIGSERIAL = "BIGSERIAL"
+
+    # Numeric types
+    NUMERIC = "NUMERIC"
+    DECIMAL = "DECIMAL"
+    REAL = "REAL"
+    DOUBLE_PRECISION = "DOUBLE PRECISION"
+
+    # Text types
+    VARCHAR = "VARCHAR"
+    CHAR = "CHAR"
+    TEXT = "TEXT"
+
+    # Boolean
+    BOOLEAN = "BOOLEAN"
+
+    # Date/Time
+    DATE = "DATE"
+    TIME = "TIME"
+    TIMESTAMP = "TIMESTAMP"
+    TIMESTAMPTZ = "TIMESTAMPTZ"
+
+    # UUID
+    UUID = "UUID"
+
+    # JSON
+    JSON = "JSON"
+    JSONB = "JSONB"
+
+    # Binary
+    BYTEA = "BYTEA"
+
+    # Unknown/Custom
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass
+class Column:
+    """Represents a database column."""
+
+    name: str
+    type: ColumnType
+    nullable: bool = True
+    default: str | None = None
+    primary_key: bool = False
+    unique: bool = False
+    length: int | None = None  # For VARCHAR(n), etc.
+
+    def __eq__(self, other: object) -> bool:
+        """Compare columns for equality."""
+        if not isinstance(other, Column):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.type == other.type
+            and self.nullable == other.nullable
+            and self.default == other.default
+            and self.primary_key == other.primary_key
+            and self.unique == other.unique
+            and self.length == other.length
+        )
+
+    def __hash__(self) -> int:
+        """Make column hashable for use in sets."""
+        return hash(
+            (
+                self.name,
+                self.type,
+                self.nullable,
+                self.default,
+                self.primary_key,
+                self.unique,
+                self.length,
+            )
+        )
+
+
+@dataclass
+class Table:
+    """Represents a database table."""
+
+    name: str
+    columns: list[Column] = field(default_factory=list)
+    indexes: list[str] = field(default_factory=list)  # Simplified for MVP
+    constraints: list[str] = field(default_factory=list)  # Simplified for MVP
+
+    def get_column(self, name: str) -> Column | None:
+        """Get column by name."""
+        for col in self.columns:
+            if col.name == name:
+                return col
+        return None
+
+    def has_column(self, name: str) -> bool:
+        """Check if table has column."""
+        return self.get_column(name) is not None
+
+    def __eq__(self, other: object) -> bool:
+        """Compare tables for equality."""
+        if not isinstance(other, Table):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.columns == other.columns
+            and self.indexes == other.indexes
+            and self.constraints == other.constraints
+        )
+
+
+@dataclass
+class Schema:
+    """Represents a complete database schema."""
+
+    tables: list[Table] = field(default_factory=list)
+
+    def get_table(self, name: str) -> Table | None:
+        """Get table by name."""
+        for table in self.tables:
+            if table.name == name:
+                return table
+        return None
+
+    def has_table(self, name: str) -> bool:
+        """Check if schema has table."""
+        return self.get_table(name) is not None
+
+    def table_names(self) -> list[str]:
+        """Get list of all table names."""
+        return [table.name for table in self.tables]
+
+
+@dataclass
+class SchemaChange:
+    """Represents a single change between two schemas."""
+
+    type: str  # ADD_TABLE, DROP_TABLE, ADD_COLUMN, etc.
+    table: str | None = None
+    column: str | None = None
+    old_value: str | None = None
+    new_value: str | None = None
+    details: dict[str, str] | None = None
+
+    def __str__(self) -> str:
+        """String representation of change."""
+        if self.type == "ADD_TABLE":
+            return f"ADD TABLE {self.table}"
+        elif self.type == "DROP_TABLE":
+            return f"DROP TABLE {self.table}"
+        elif self.type == "RENAME_TABLE":
+            return f"RENAME TABLE {self.old_value} TO {self.new_value}"
+        elif self.type == "ADD_COLUMN":
+            return f"ADD COLUMN {self.table}.{self.column}"
+        elif self.type == "DROP_COLUMN":
+            return f"DROP COLUMN {self.table}.{self.column}"
+        elif self.type == "RENAME_COLUMN":
+            return f"RENAME COLUMN {self.table}.{self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_TYPE":
+            return f"CHANGE COLUMN TYPE {self.table}.{self.column} FROM {self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_NULLABLE":
+            return f"CHANGE COLUMN NULLABLE {self.table}.{self.column} FROM {self.old_value} TO {self.new_value}"
+        elif self.type == "CHANGE_COLUMN_DEFAULT":
+            return f"CHANGE COLUMN DEFAULT {self.table}.{self.column}"
+        else:
+            return f"{self.type}: {self.table}.{self.column if self.column else ''}"
+
+
+@dataclass
+class SchemaDiff:
+    """Represents the difference between two schemas."""
+
+    changes: list[SchemaChange] = field(default_factory=list)
+
+    def has_changes(self) -> bool:
+        """Check if there are any changes."""
+        return len(self.changes) > 0
+
+    def count_by_type(self, change_type: str) -> int:
+        """Count changes of a specific type."""
+        return sum(1 for c in self.changes if c.type == change_type)
+
+    def __str__(self) -> str:
+        """String representation of diff."""
+        if not self.has_changes():
+            return "No changes detected"
+        return "\n".join(str(c) for c in self.changes)

confiture/models/sql_file_migration.py

@@ -0,0 +1,225 @@
+"""SQL file-based migrations.
+
+Provides support for pure SQL migration files without Python boilerplate.
+Migrations are discovered from .up.sql/.down.sql file pairs.
+
+Example file structure:
+    db/migrations/
+    ├── 001_create_users.py           # Python migration
+    ├── 002_add_posts.py              # Python migration
+    ├── 003_move_catalog_tables.up.sql    # SQL migration (up)
+    ├── 003_move_catalog_tables.down.sql  # SQL migration (down)
+
+The migrator will automatically detect and load SQL file pairs alongside
+Python migrations.
+"""
+
+from pathlib import Path
+
+import psycopg
+
+from confiture.models.migration import Migration
+
+
+class FileSQLMigration(Migration):
+    """Migration loaded from .up.sql/.down.sql file pair.
+
+    This class is instantiated dynamically by the migrator when it discovers
+    SQL file pairs. Users don't create these directly - they just create the
+    SQL files.
+
+    The version and name are extracted from the filename:
+    - `003_move_catalog_tables.up.sql` → version="003", name="move_catalog_tables"
+
+    Attributes:
+        up_file: Path to the .up.sql file
+        down_file: Path to the .down.sql file
+
+    Note:
+        This class is instantiated by the migration loader, not directly by users.
+        To create a SQL migration, simply create the .up.sql and .down.sql files.
+    """
+
+    def __init__(
+        self,
+        connection: psycopg.Connection,
+        up_file: Path,
+        down_file: Path,
+    ):
+        """Initialize file-based SQL migration.
+
+        Args:
+            connection: psycopg3 database connection
+            up_file: Path to the .up.sql file
+            down_file: Path to the .down.sql file
+
+        Raises:
+            FileNotFoundError: If either SQL file doesn't exist
+        """
+        # Extract version and name from filename before calling super().__init__
+        # Filename format: 003_move_catalog_tables.up.sql
+        base_name = up_file.name.replace(".up.sql", "")
+        parts = base_name.split("_", 1)
+
+        # Set class attributes dynamically for this instance
+        # We need to do this before super().__init__ because it validates version/name
+        self.__class__ = type(
+            f"FileSQLMigration_{base_name}",
+            (FileSQLMigration,),
+            {
+                "version": parts[0] if parts else "???",
+                "name": parts[1] if len(parts) > 1 else base_name,
+                "up_file": up_file,
+                "down_file": down_file,
+            },
+        )
+
+        self.up_file = up_file
+        self.down_file = down_file
+
+        # Validate files exist
+        if not up_file.exists():
+            raise FileNotFoundError(f"Migration up file not found: {up_file}")
+        if not down_file.exists():
+            raise FileNotFoundError(f"Migration down file not found: {down_file}")
+
+        super().__init__(connection)
+
+    def up(self) -> None:
+        """Apply the migration by executing the .up.sql file."""
+        sql = self.up_file.read_text()
+        self.execute(sql)
+
+    def down(self) -> None:
+        """Rollback the migration by executing the .down.sql file."""
+        sql = self.down_file.read_text()
+        self.execute(sql)
+
+    @classmethod
+    def from_files(
+        cls,
+        up_file: Path,
+        down_file: Path,
+    ) -> type["FileSQLMigration"]:
+        """Create a migration class from SQL file pair.
+
+        This creates a new class (not instance) that can be used with the
+        standard migration system. The class has version and name extracted
+        from the filename.
+
+        Args:
+            up_file: Path to the .up.sql file
+            down_file: Path to the .down.sql file
+
+        Returns:
+            A new Migration class (not instance)
+
+        Example:
+            >>> MigrationClass = FileSQLMigration.from_files(
+            ...     Path("db/migrations/003_move_tables.up.sql"),
+            ...     Path("db/migrations/003_move_tables.down.sql"),
+            ... )
+            >>> migration = MigrationClass(connection=conn)
+            >>> migration.up()
+        """
+        # Extract version and name from filename
+        base_name = up_file.name.replace(".up.sql", "")
+        parts = base_name.split("_", 1)
+        version = parts[0] if parts else "???"
+        name = parts[1] if len(parts) > 1 else base_name
+
+        # Create a new class dynamically
+        class_name = f"FileSQLMigration_{base_name}"
+
+        def init_method(self: "FileSQLMigration", connection: psycopg.Connection) -> None:
+            self.up_file = up_file
+            self.down_file = down_file
+            self.connection = connection
+
+            # Validate files exist
+            if not up_file.exists():
+                raise FileNotFoundError(f"Migration up file not found: {up_file}")
+            if not down_file.exists():
+                raise FileNotFoundError(f"Migration down file not found: {down_file}")
+
+        def up_method(self: "FileSQLMigration") -> None:
+            sql = self.up_file.read_text()
+            self.execute(sql)
+
+        def down_method(self: "FileSQLMigration") -> None:
+            sql = self.down_file.read_text()
+            self.execute(sql)
+
+        # Create the class
+        new_class = type(
+            class_name,
+            (Migration,),
+            {
+                "version": version,
+                "name": name,
+                "up_file": up_file,
+                "down_file": down_file,
+                "__init__": init_method,
+                "up": up_method,
+                "down": down_method,
+            },
+        )
+
+        return new_class  # type: ignore[return-value]
+
+
+def find_sql_migration_files(migrations_dir: Path) -> list[tuple[Path, Path]]:
+    """Find all SQL migration file pairs in a directory.
+
+    Searches for .up.sql files and matches them with corresponding .down.sql files.
+
+    Args:
+        migrations_dir: Directory to search for SQL migrations
+
+    Returns:
+        List of (up_file, down_file) tuples, sorted by version
+
+    Raises:
+        ValueError: If an .up.sql file has no matching .down.sql file
+
+    Example:
+        >>> pairs = find_sql_migration_files(Path("db/migrations"))
+        >>> for up_file, down_file in pairs:
+        ...     print(f"Found: {up_file.name}")
+    """
+    pairs: list[tuple[Path, Path]] = []
+
+    # Find all .up.sql files
+    for up_file in sorted(migrations_dir.glob("*.up.sql")):
+        # Find matching .down.sql
+        base_name = up_file.name.replace(".up.sql", "")
+        down_file = migrations_dir / f"{base_name}.down.sql"
+
+        if not down_file.exists():
+            raise ValueError(
+                f"SQL migration {up_file.name} has no matching .down.sql file.\n"
+                f"Expected: {down_file}\n"
+                f"Hint: Create {down_file.name} with the rollback SQL"
+            )
+
+        pairs.append((up_file, down_file))
+
+    return pairs
+
+
+def get_sql_migration_version(up_file: Path) -> str:
+    """Extract version from SQL migration filename.
+
+    Args:
+        up_file: Path to the .up.sql file
+
+    Returns:
+        Version string (e.g., "003")
+
+    Example:
+        >>> get_sql_migration_version(Path("003_move_tables.up.sql"))
+        '003'
+    """
+    base_name = up_file.name.replace(".up.sql", "")
+    parts = base_name.split("_", 1)
+    return parts[0] if parts else "???"

confiture/scenarios/__init__.py

@@ -0,0 +1,36 @@
+"""Real-world anonymization scenarios.
+
+Provides ready-to-use anonymization profiles for common business domains:
+- E-commerce: Customer data, orders, payments
+- Healthcare: HIPAA-compliant PHI anonymization
+- Financial: Loan applications, credit data
+- SaaS: User accounts, subscription data
+- Multi-tenant: Data isolation with deterministic seeding
+
+Each scenario includes:
+- Pre-configured strategy profiles
+- Batch anonymization support
+- Domain-specific validation
+- Usage examples
+
+Usage:
+    >>> from confiture.scenarios import ECommerceScenario
+    >>> data = {"first_name": "John", "email": "john@example.com"}
+    >>> anonymized = ECommerceScenario.anonymize(data)
+"""
+
+# Import strategies to ensure registration (must come before scenario imports)
+import confiture.core.anonymization.strategies  # noqa: F401
+from confiture.scenarios.ecommerce import ECommerceScenario
+from confiture.scenarios.financial import FinancialScenario
+from confiture.scenarios.healthcare import HealthcareScenario
+from confiture.scenarios.multi_tenant import MultiTenantScenario
+from confiture.scenarios.saas import SaaSScenario
+
+__all__ = [
+    "ECommerceScenario",
+    "HealthcareScenario",
+    "FinancialScenario",
+    "SaaSScenario",
+    "MultiTenantScenario",
+]