truthound-dashboard 1.0.0__py3-none-any.whl

truthound_dashboard/api/schemas.py

@@ -0,0 +1,136 @@
+"""Schemas API endpoints.
+
+This module provides endpoints for schema learning and management.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Path
+
+from truthound_dashboard.schemas import (
+    SchemaLearnRequest,
+    SchemaResponse,
+    SchemaUpdateRequest,
+)
+
+from .deps import SchemaServiceDep, SourceServiceDep
+
+router = APIRouter()
+
+
+@router.get(
+    "/sources/{source_id}/schema",
+    response_model=SchemaResponse | None,
+    summary="Get source schema",
+    description="Get the active schema for a data source",
+)
+async def get_schema(
+    service: SchemaServiceDep,
+    source_service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+) -> SchemaResponse | None:
+    """Get the active schema for a source.
+
+    Args:
+        service: Injected schema service.
+        source_service: Injected source service.
+        source_id: Source to get schema for.
+
+    Returns:
+        Schema if exists, None otherwise.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    # Verify source exists
+    source = await source_service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+
+    schema = await service.get_schema(source_id)
+    if schema is None:
+        return None
+    return SchemaResponse.from_model(schema)
+
+
+@router.post(
+    "/sources/{source_id}/learn",
+    response_model=SchemaResponse,
+    summary="Learn schema",
+    description="Auto-learn schema from data source",
+)
+async def learn_schema(
+    service: SchemaServiceDep,
+    source_service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+    request: SchemaLearnRequest,
+) -> SchemaResponse:
+    """Learn schema from a data source.
+
+    Args:
+        service: Injected schema service.
+        source_service: Injected source service.
+        source_id: Source to learn schema from.
+        request: Learning options.
+
+    Returns:
+        Learned schema.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    # Verify source exists
+    source = await source_service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+
+    try:
+        schema = await service.learn_schema(
+            source_id,
+            infer_constraints=request.infer_constraints,
+        )
+        return SchemaResponse.from_model(schema)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put(
+    "/sources/{source_id}/schema",
+    response_model=SchemaResponse,
+    summary="Update schema",
+    description="Update the schema YAML for a source",
+)
+async def update_schema(
+    service: SchemaServiceDep,
+    source_service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+    request: SchemaUpdateRequest,
+) -> SchemaResponse:
+    """Update schema YAML for a source.
+
+    Args:
+        service: Injected schema service.
+        source_service: Injected source service.
+        source_id: Source to update schema for.
+        request: New schema YAML.
+
+    Returns:
+        Updated schema.
+
+    Raises:
+        HTTPException: 404 if source or schema not found.
+    """
+    # Verify source exists
+    source = await source_service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+
+    schema = await service.update_schema(source_id, request.schema_yaml)
+    if schema is None:
+        raise HTTPException(
+            status_code=404,
+            detail="No active schema found. Use /learn to create one first.",
+        )
+    return SchemaResponse.from_model(schema)

truthound_dashboard/api/sources.py

@@ -0,0 +1,229 @@
+"""Sources API endpoints.
+
+This module provides CRUD endpoints for managing data sources.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Path, Query
+
+from truthound_dashboard.schemas import (
+    MessageResponse,
+    SourceCreate,
+    SourceListResponse,
+    SourceResponse,
+    SourceUpdate,
+)
+
+from .deps import SourceServiceDep
+
+router = APIRouter()
+
+
+@router.get(
+    "",
+    response_model=SourceListResponse,
+    summary="List sources",
+    description="Get a paginated list of all data sources",
+)
+async def list_sources(
+    service: SourceServiceDep,
+    offset: Annotated[int, Query(ge=0, description="Offset for pagination")] = 0,
+    limit: Annotated[
+        int, Query(ge=1, le=100, description="Maximum items to return")
+    ] = 100,
+    active_only: Annotated[
+        bool, Query(description="Only return active sources")
+    ] = True,
+) -> SourceListResponse:
+    """List all data sources with pagination.
+
+    Args:
+        service: Injected source service.
+        offset: Number of items to skip.
+        limit: Maximum items to return.
+        active_only: Filter to active sources only.
+
+    Returns:
+        Paginated list of sources.
+    """
+    sources = await service.list(offset=offset, limit=limit, active_only=active_only)
+
+    return SourceListResponse(
+        data=[SourceResponse.from_model(s) for s in sources],
+        total=len(sources),  # TODO: Get actual total count
+        offset=offset,
+        limit=limit,
+    )
+
+
+@router.post(
+    "",
+    response_model=SourceResponse,
+    status_code=201,
+    summary="Create source",
+    description="Create a new data source",
+)
+async def create_source(
+    service: SourceServiceDep,
+    source: SourceCreate,
+) -> SourceResponse:
+    """Create a new data source.
+
+    Args:
+        service: Injected source service.
+        source: Source creation data.
+
+    Returns:
+        Created source.
+    """
+    created = await service.create(
+        name=source.name,
+        type=source.type,
+        config=source.config,
+        description=source.description,
+    )
+    return SourceResponse.from_model(created)
+
+
+@router.get(
+    "/{source_id}",
+    response_model=SourceResponse,
+    summary="Get source",
+    description="Get a specific data source by ID",
+)
+async def get_source(
+    service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+) -> SourceResponse:
+    """Get a specific data source.
+
+    Args:
+        service: Injected source service.
+        source_id: Source unique identifier.
+
+    Returns:
+        Source details.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    source = await service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+    return SourceResponse.from_model(source)
+
+
+@router.put(
+    "/{source_id}",
+    response_model=SourceResponse,
+    summary="Update source",
+    description="Update an existing data source",
+)
+async def update_source(
+    service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+    update: SourceUpdate,
+) -> SourceResponse:
+    """Update an existing data source.
+
+    Args:
+        service: Injected source service.
+        source_id: Source unique identifier.
+        update: Update data.
+
+    Returns:
+        Updated source.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    updated = await service.update(
+        source_id,
+        name=update.name,
+        config=update.config,
+        description=update.description,
+        is_active=update.is_active,
+    )
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+    return SourceResponse.from_model(updated)
+
+
+@router.delete(
+    "/{source_id}",
+    response_model=MessageResponse,
+    summary="Delete source",
+    description="Delete a data source and all related data",
+)
+async def delete_source(
+    service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+) -> MessageResponse:
+    """Delete a data source.
+
+    Args:
+        service: Injected source service.
+        source_id: Source unique identifier.
+
+    Returns:
+        Success message.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    deleted = await service.delete(source_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Source not found")
+    return MessageResponse(message="Source deleted successfully")
+
+
+@router.post(
+    "/{source_id}/test",
+    response_model=dict,
+    summary="Test source connection",
+    description="Test connection to a data source",
+)
+async def test_source_connection(
+    service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+) -> dict:
+    """Test connection to a data source.
+
+    Args:
+        service: Injected source service.
+        source_id: Source unique identifier.
+
+    Returns:
+        Connection test result with success status and message.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    from truthound_dashboard.core.connections import test_connection
+
+    source = await service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+
+    result = await test_connection(source.type, source.config)
+    return {"success": True, "data": result}
+
+
+@router.get(
+    "/types/supported",
+    response_model=dict,
+    summary="Get supported source types",
+    description="Get list of supported data source types and their configuration",
+)
+async def get_supported_types() -> dict:
+    """Get list of supported source types.
+
+    Returns:
+        List of supported source types with required/optional fields.
+    """
+    from truthound_dashboard.core.connections import get_supported_source_types
+
+    return {"success": True, "data": get_supported_source_types()}

truthound_dashboard/api/validations.py

@@ -0,0 +1,125 @@
+"""Validations API endpoints.
+
+This module provides endpoints for running and managing validations.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Path, Query
+
+from truthound_dashboard.schemas import (
+    ValidationListItem,
+    ValidationListResponse,
+    ValidationResponse,
+    ValidationRunRequest,
+)
+
+from .deps import SourceServiceDep, ValidationServiceDep
+
+router = APIRouter()
+
+
+@router.post(
+    "/sources/{source_id}/validate",
+    response_model=ValidationResponse,
+    summary="Run validation",
+    description="Run validation on a data source",
+)
+async def run_validation(
+    service: ValidationServiceDep,
+    source_id: Annotated[str, Path(description="Source ID to validate")],
+    request: ValidationRunRequest,
+) -> ValidationResponse:
+    """Run validation on a data source.
+
+    Args:
+        service: Injected validation service.
+        source_id: Source to validate.
+        request: Validation options.
+
+    Returns:
+        Validation result.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    try:
+        validation = await service.run_validation(
+            source_id,
+            validators=request.validators,
+            schema_path=request.schema_path,
+            auto_schema=request.auto_schema,
+        )
+        return ValidationResponse.from_model(validation)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.get(
+    "/{validation_id}",
+    response_model=ValidationResponse,
+    summary="Get validation",
+    description="Get a specific validation result by ID",
+)
+async def get_validation(
+    service: ValidationServiceDep,
+    validation_id: Annotated[str, Path(description="Validation ID")],
+) -> ValidationResponse:
+    """Get a specific validation result.
+
+    Args:
+        service: Injected validation service.
+        validation_id: Validation unique identifier.
+
+    Returns:
+        Validation details with issues.
+
+    Raises:
+        HTTPException: 404 if validation not found.
+    """
+    validation = await service.get_validation(validation_id)
+    if validation is None:
+        raise HTTPException(status_code=404, detail="Validation not found")
+    return ValidationResponse.from_model(validation)
+
+
+@router.get(
+    "/sources/{source_id}/validations",
+    response_model=ValidationListResponse,
+    summary="List source validations",
+    description="Get validation history for a source",
+)
+async def list_source_validations(
+    service: ValidationServiceDep,
+    source_service: SourceServiceDep,
+    source_id: Annotated[str, Path(description="Source ID")],
+    limit: Annotated[int, Query(ge=1, le=100, description="Maximum items")] = 20,
+) -> ValidationListResponse:
+    """List validation history for a source.
+
+    Args:
+        service: Injected validation service.
+        source_service: Injected source service.
+        source_id: Source to get validations for.
+        limit: Maximum validations to return.
+
+    Returns:
+        List of validation summaries.
+
+    Raises:
+        HTTPException: 404 if source not found.
+    """
+    # Verify source exists
+    source = await source_service.get_by_id(source_id)
+    if source is None:
+        raise HTTPException(status_code=404, detail="Source not found")
+
+    validations = await service.list_for_source(source_id, limit=limit)
+
+    return ValidationListResponse(
+        data=[ValidationListItem.from_model(v) for v in validations],
+        total=len(validations),
+        limit=limit,
+    )

truthound_dashboard/cli.py

@@ -0,0 +1,226 @@
+"""CLI entry point for truthound-dashboard.
+
+This module provides the command-line interface using Typer.
+It supports both standalone usage and integration with the
+truthound CLI plugin system.
+
+Example:
+    # Standalone usage
+    truthound-dashboard serve --port 8765
+
+    # Via truthound CLI plugin
+    truthound serve --port 8765
+"""
+
+from __future__ import annotations
+
+import webbrowser
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from truthound_dashboard import __version__
+
+app = typer.Typer(
+    name="truthound-dashboard",
+    help="Open-source data quality dashboard - GX Cloud alternative",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        console.print(f"truthound-dashboard version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-v",
+            help="Show version and exit",
+            callback=version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    """Truthound Dashboard - Open-source data quality monitoring."""
+    pass
+
+
+@app.command()
+def serve(
+    port: Annotated[
+        int,
+        typer.Option("--port", "-p", help="Port to run server on", min=1, max=65535),
+    ] = 8765,
+    host: Annotated[
+        str,
+        typer.Option("--host", "-h", help="Host to bind server to"),
+    ] = "127.0.0.1",
+    data_dir: Annotated[
+        Path | None,
+        typer.Option(
+            "--data-dir",
+            "-d",
+            help="Data directory for database and cache",
+            exists=False,
+            file_okay=False,
+            resolve_path=True,
+        ),
+    ] = None,
+    no_browser: Annotated[
+        bool,
+        typer.Option("--no-browser", help="Don't open browser automatically"),
+    ] = False,
+    reload: Annotated[
+        bool,
+        typer.Option("--reload", help="Enable hot reload for development"),
+    ] = False,
+    log_level: Annotated[
+        str,
+        typer.Option(
+            "--log-level",
+            "-l",
+            help="Logging level",
+            case_sensitive=False,
+        ),
+    ] = "warning",
+) -> None:
+    """Start the truthound dashboard server.
+
+    This command starts the FastAPI server and optionally opens
+    the dashboard in your default browser.
+
+    Examples:
+        truthound serve
+        truthound serve --port 9000
+        truthound serve --reload --log-level debug
+    """
+    import uvicorn
+
+    from truthound_dashboard.config import get_settings, reset_settings
+
+    # Reset settings cache to pick up any CLI overrides
+    reset_settings()
+    settings = get_settings()
+
+    # Override settings from CLI arguments
+    if data_dir:
+        settings.data_dir = data_dir
+
+    # Ensure directories exist
+    settings.ensure_directories()
+
+    # Display startup info
+    url = f"http://{host}:{port}"
+    console.print(
+        Panel(
+            f"[bold]Truthound Dashboard v{__version__}[/bold]\n\n"
+            f"[green]✓[/green] Database: {settings.database_path}\n"
+            f"[green]✓[/green] Server: {url}\n"
+            f"[green]✓[/green] API Docs: {url}/docs",
+            title="Starting Dashboard",
+            border_style="bright_blue",
+        )
+    )
+
+    # Open browser
+    if not no_browser:
+        webbrowser.open(url)
+        console.print("[dim]Opening browser...[/dim]")
+
+    # Configure and run server
+    uvicorn.run(
+        "truthound_dashboard.main:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level=log_level.lower(),
+        access_log=log_level.lower() == "debug",
+    )
+
+
+@app.command()
+def info() -> None:
+    """Show dashboard configuration and status."""
+    from truthound_dashboard.config import get_settings
+
+    settings = get_settings()
+    settings.ensure_directories()
+
+    console.print(
+        Panel(
+            f"[bold]Configuration[/bold]\n\n"
+            f"Data Directory: {settings.data_dir}\n"
+            f"Database: {settings.database_path}\n"
+            f"Cache: {settings.cache_dir}\n"
+            f"Schemas: {settings.schema_dir}\n\n"
+            f"[bold]Server Defaults[/bold]\n\n"
+            f"Host: {settings.host}\n"
+            f"Port: {settings.port}\n"
+            f"Auth Enabled: {settings.auth_enabled}\n\n"
+            f"[bold]Validation Defaults[/bold]\n\n"
+            f"Sample Size: {settings.sample_size:,}\n"
+            f"Max Failed Rows: {settings.max_failed_rows:,}\n"
+            f"Timeout: {settings.default_timeout}s",
+            title=f"Truthound Dashboard v{__version__}",
+            border_style="bright_blue",
+        )
+    )
+
+
+def register_commands(typer_app: typer.Typer) -> None:
+    """Register commands with truthound CLI plugin system.
+
+    This function is called by the truthound CLI when the
+    dashboard plugin is discovered via entry points.
+
+    Args:
+        typer_app: The parent typer application to register commands with.
+    """
+
+    @typer_app.command(name="serve")
+    def serve_dashboard(
+        port: Annotated[
+            int,
+            typer.Option("--port", "-p", help="Port to run on"),
+        ] = 8765,
+        host: Annotated[
+            str,
+            typer.Option("--host", help="Host to bind"),
+        ] = "127.0.0.1",
+        data_dir: Annotated[
+            Path | None,
+            typer.Option("--data-dir", "-d", help="Data directory path"),
+        ] = None,
+        no_browser: Annotated[
+            bool,
+            typer.Option("--no-browser", help="Don't open browser automatically"),
+        ] = False,
+        reload: Annotated[
+            bool,
+            typer.Option("--reload", help="Enable hot reload for development"),
+        ] = False,
+    ) -> None:
+        """Start the truthound dashboard server."""
+        serve(
+            port=port,
+            host=host,
+            data_dir=data_dir,
+            no_browser=no_browser,
+            reload=reload,
+        )
+
+
+if __name__ == "__main__":
+    app()