truthound-dashboard 1.0.0__py3-none-any.whl

truthound_dashboard/db/__init__.py

@@ -0,0 +1,67 @@
+"""Database module.
+
+This module provides database connectivity, models, and repository patterns
+for the truthound dashboard.
+
+Exports:
+    - Database connection: get_session, get_db_session, init_db
+    - Base classes: Base, UUIDMixin, TimestampMixin
+    - Models: Source, Schema, Rule, Validation, Profile, Schedule, DriftComparison, AppSettings
+    - Repository: BaseRepository
+"""
+
+from .base import Base, SoftDeleteMixin, TimestampMixin, UUIDMixin
+from .database import (
+    get_db_session,
+    get_engine,
+    get_session,
+    get_session_factory,
+    init_db,
+    reset_connection,
+    reset_db,
+)
+from .models import (
+    AppSettings,
+    DriftComparison,
+    NotificationChannel,
+    NotificationLog,
+    NotificationRule,
+    Profile,
+    Rule,
+    Schedule,
+    Schema,
+    Source,
+    Validation,
+)
+from .repository import BaseRepository
+
+__all__ = [
+    # Base classes
+    "Base",
+    "UUIDMixin",
+    "TimestampMixin",
+    "SoftDeleteMixin",
+    # Database functions
+    "get_session",
+    "get_db_session",
+    "get_engine",
+    "get_session_factory",
+    "init_db",
+    "reset_db",
+    "reset_connection",
+    # Models
+    "Source",
+    "Schema",
+    "Rule",
+    "Validation",
+    "Profile",
+    "Schedule",
+    "DriftComparison",
+    "AppSettings",
+    # Notification models (Phase 3)
+    "NotificationChannel",
+    "NotificationRule",
+    "NotificationLog",
+    # Repository
+    "BaseRepository",
+]

truthound_dashboard/db/base.py

@@ -0,0 +1,108 @@
+"""Database base classes and mixins for extensibility.
+
+This module provides reusable base classes and mixins for SQLAlchemy models,
+enabling consistent patterns across all database entities.
+
+Example:
+    class MyModel(Base, TimestampMixin, UUIDMixin):
+        __tablename__ = "my_models"
+        name: Mapped[str] = mapped_column(String(255))
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+from uuid import uuid4
+
+from sqlalchemy import DateTime, String, func
+from sqlalchemy.orm import DeclarativeBase, Mapped, declared_attr, mapped_column
+
+
+class Base(DeclarativeBase):
+    """Base class for all SQLAlchemy models.
+
+    Provides common functionality like automatic table naming
+    and serialization methods.
+    """
+
+    @declared_attr.directive
+    @classmethod
+    def __tablename__(cls) -> str:
+        """Generate table name from class name (snake_case)."""
+        import re
+
+        name = cls.__name__
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower() + "s"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert model instance to dictionary.
+
+        Returns:
+            Dictionary representation of the model.
+        """
+        return {
+            column.name: getattr(self, column.name) for column in self.__table__.columns
+        }
+
+
+class UUIDMixin:
+    """Mixin that adds a UUID primary key.
+
+    Automatically generates a UUID4 string as the primary key.
+    """
+
+    id: Mapped[str] = mapped_column(
+        String(36),
+        primary_key=True,
+        default=lambda: str(uuid4()),
+    )
+
+
+class TimestampMixin:
+    """Mixin that adds created_at and updated_at timestamps.
+
+    Automatically sets created_at on insert and updates
+    updated_at on every modification.
+    """
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=datetime.utcnow,
+        server_default=func.now(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+        server_default=func.now(),
+        nullable=False,
+    )
+
+
+class SoftDeleteMixin:
+    """Mixin that adds soft delete functionality.
+
+    Instead of actually deleting records, sets deleted_at timestamp.
+    Use with query filters to exclude deleted records.
+    """
+
+    deleted_at: Mapped[datetime | None] = mapped_column(
+        DateTime,
+        nullable=True,
+        default=None,
+    )
+
+    @property
+    def is_deleted(self) -> bool:
+        """Check if record is soft-deleted."""
+        return self.deleted_at is not None
+
+    def soft_delete(self) -> None:
+        """Mark record as deleted."""
+        self.deleted_at = datetime.utcnow()
+
+    def restore(self) -> None:
+        """Restore soft-deleted record."""
+        self.deleted_at = None

truthound_dashboard/db/database.py

@@ -0,0 +1,196 @@
+"""Database connection and session management.
+
+This module provides async database connection handling using SQLAlchemy 2.0.
+It supports both production SQLite and in-memory databases for testing.
+
+Example:
+    # Using context manager
+    async with get_session() as session:
+        result = await session.execute(select(Source))
+        sources = result.scalars().all()
+
+    # Using FastAPI dependency
+    @router.get("/sources")
+    async def list_sources(session: AsyncSession = Depends(get_db_session)):
+        ...
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from truthound_dashboard.config import get_settings
+
+from .base import Base
+
+# Global engine and session factory
+_engine: AsyncEngine | None = None
+_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+
+def get_database_url(in_memory: bool = False) -> str:
+    """Get database URL.
+
+    Args:
+        in_memory: If True, use in-memory SQLite for testing.
+
+    Returns:
+        SQLAlchemy async database URL.
+    """
+    if in_memory:
+        return "sqlite+aiosqlite:///:memory:"
+
+    settings = get_settings()
+    settings.ensure_directories()
+    return f"sqlite+aiosqlite:///{settings.database_path}"
+
+
+def get_engine(in_memory: bool = False) -> AsyncEngine:
+    """Get or create database engine.
+
+    Args:
+        in_memory: If True, create in-memory database.
+
+    Returns:
+        AsyncEngine instance.
+    """
+    global _engine
+
+    if _engine is None or in_memory:
+        url = get_database_url(in_memory)
+        engine = create_async_engine(
+            url,
+            echo=False,
+            pool_pre_ping=True,
+            connect_args={"check_same_thread": False} if "sqlite" in url else {},
+        )
+        if not in_memory:
+            _engine = engine
+        return engine
+
+    return _engine
+
+
+def get_session_factory(
+    engine: AsyncEngine | None = None,
+) -> async_sessionmaker[AsyncSession]:
+    """Get or create session factory.
+
+    Args:
+        engine: Optional engine to use. If None, uses default engine.
+
+    Returns:
+        Session factory for creating database sessions.
+    """
+    global _session_factory
+
+    if engine is not None:
+        # Create new factory for provided engine (used in testing)
+        return async_sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autoflush=False,
+        )
+
+    if _session_factory is None:
+        _session_factory = async_sessionmaker(
+            get_engine(),
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autoflush=False,
+        )
+
+    return _session_factory
+
+
+@asynccontextmanager
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    """Get database session as async context manager.
+
+    Yields:
+        AsyncSession for database operations.
+
+    Example:
+        async with get_session() as session:
+            result = await session.execute(select(Source))
+    """
+    factory = get_session_factory()
+    async with factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency for database sessions.
+
+    Yields:
+        AsyncSession for use in route handlers.
+
+    Example:
+        @router.get("/sources")
+        async def get_sources(session: AsyncSession = Depends(get_db_session)):
+            ...
+    """
+    async with get_session() as session:
+        yield session
+
+
+async def init_db(engine: AsyncEngine | None = None) -> None:
+    """Initialize database tables.
+
+    Creates all tables defined in models if they don't exist.
+
+    Args:
+        engine: Optional engine to use. If None, uses default engine.
+    """
+    target_engine = engine or get_engine()
+    async with target_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def drop_db(engine: AsyncEngine | None = None) -> None:
+    """Drop all database tables.
+
+    Warning: This will delete all data!
+
+    Args:
+        engine: Optional engine to use. If None, uses default engine.
+    """
+    target_engine = engine or get_engine()
+    async with target_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+
+
+async def reset_db(engine: AsyncEngine | None = None) -> None:
+    """Reset database by dropping and recreating all tables.
+
+    Warning: This will delete all data!
+
+    Args:
+        engine: Optional engine to use. If None, uses default engine.
+    """
+    await drop_db(engine)
+    await init_db(engine)
+
+
+def reset_connection() -> None:
+    """Reset global engine and session factory.
+
+    Useful for testing or when configuration changes.
+    """
+    global _engine, _session_factory
+    _engine = None
+    _session_factory = None