@weirdfingers/baseboards 0.9.6 → 0.9.7

package/templates/api/src/boards/graphql/types/generation.py

@@ -1,166 +0,0 @@
-"""
-Generation GraphQL type definitions
-"""
-
-from datetime import datetime
-from enum import Enum
-from typing import TYPE_CHECKING, Annotated
-from uuid import UUID
-
-import strawberry
-
-if TYPE_CHECKING:
-    from .board import Board
-    from .user import User
-
-
-@strawberry.enum
-class ArtifactType(Enum):
-    """Artifact type enumeration."""
-
-    IMAGE = "image"
-    VIDEO = "video"
-    AUDIO = "audio"
-    TEXT = "text"
-    LORA = "lora"
-    MODEL = "model"
-
-
-@strawberry.enum
-class GenerationStatus(Enum):
-    """Generation status enumeration."""
-
-    PENDING = "pending"
-    PROCESSING = "processing"
-    COMPLETED = "completed"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
-
-
-@strawberry.type
-class AdditionalFile:
-    """Additional file associated with a generation."""
-
-    url: str
-    type: str
-    metadata: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
-
-
-@strawberry.input
-class UploadArtifactInput:
-    """Input for uploading an artifact from URL."""
-
-    board_id: UUID
-    artifact_type: ArtifactType
-    file_url: str | None = None
-    original_filename: str | None = None
-    user_description: str | None = None
-    parent_generation_id: UUID | None = None
-
-
-@strawberry.type
-class ArtifactLineage:
-    """Represents a single input artifact relationship with role metadata."""
-
-    generation_id: UUID
-    role: str
-    artifact_type: ArtifactType
-
-    @strawberry.field
-    async def generation(
-        self, info: strawberry.Info
-    ) -> Annotated["Generation", strawberry.lazy(".generation")] | None:
-        """Resolve the full generation object for this input."""
-        from ..resolvers.lineage import resolve_generation_by_id
-
-        return await resolve_generation_by_id(info, self.generation_id)
-
-
-@strawberry.type
-class AncestryNode:
-    """Represents a node in the ancestry tree."""
-
-    generation: Annotated["Generation", strawberry.lazy(".generation")]
-    depth: int
-    role: str | None
-    parents: list["AncestryNode"]
-
-
-@strawberry.type
-class DescendantNode:
-    """Represents a node in the descendants tree."""
-
-    generation: Annotated["Generation", strawberry.lazy(".generation")]
-    depth: int
-    role: str | None
-    children: list["DescendantNode"]
-
-
-@strawberry.type
-class Generation:
-    """Generation type for GraphQL API."""
-
-    id: UUID
-    tenant_id: UUID
-    board_id: UUID
-    user_id: UUID
-
-    # Generation details
-    generator_name: str
-    artifact_type: ArtifactType
-
-    # Storage
-    storage_url: str | None
-    thumbnail_url: str | None
-    additional_files: list[AdditionalFile]
-
-    # Parameters and metadata
-    input_params: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
-    output_metadata: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
-
-    # Job tracking
-    external_job_id: str | None
-    status: GenerationStatus
-    progress: float
-    error_message: str | None
-
-    # Timestamps
-    started_at: datetime | None
-    completed_at: datetime | None
-    created_at: datetime
-    updated_at: datetime
-
-    @strawberry.field
-    async def board(self, info: strawberry.Info) -> Annotated["Board", strawberry.lazy(".board")]:
-        """Get the board this generation belongs to."""
-        from ..resolvers.generation import resolve_generation_board
-
-        return await resolve_generation_board(self, info)
-
-    @strawberry.field
-    async def user(self, info: strawberry.Info) -> Annotated["User", strawberry.lazy(".user")]:
-        """Get the user who created this generation."""
-        from ..resolvers.generation import resolve_generation_user
-
-        return await resolve_generation_user(self, info)
-
-    @strawberry.field
-    async def input_artifacts(self, info: strawberry.Info) -> list[ArtifactLineage]:
-        """Get input artifacts with role metadata."""
-        from ..resolvers.lineage import resolve_input_artifacts
-
-        return await resolve_input_artifacts(self, info)
-
-    @strawberry.field
-    async def ancestry(self, info: strawberry.Info, max_depth: int = 25) -> AncestryNode:
-        """Get complete ancestry tree up to max_depth levels."""
-        from ..resolvers.lineage import resolve_ancestry
-
-        return await resolve_ancestry(self, info, max_depth)
-
-    @strawberry.field
-    async def descendants(self, info: strawberry.Info, max_depth: int = 25) -> DescendantNode:
-        """Get complete descendants tree up to max_depth levels."""
-        from ..resolvers.lineage import resolve_descendants
-
-        return await resolve_descendants(self, info, max_depth)

package/templates/api/src/boards/graphql/types/generator.py

@@ -1,17 +0,0 @@
-"""
-Generator GraphQL type definitions
-"""
-
-import strawberry
-
-from .generation import ArtifactType
-
-
-@strawberry.type
-class GeneratorInfo:
-    """Information about an available generator."""
-
-    name: str
-    description: str
-    artifact_type: ArtifactType
-    input_schema: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]

package/templates/api/src/boards/graphql/types/user.py

@@ -1,47 +0,0 @@
-"""
-User GraphQL type definitions
-"""
-
-from datetime import datetime
-from typing import TYPE_CHECKING, Annotated
-from uuid import UUID
-
-import strawberry
-
-if TYPE_CHECKING:
-    from .board import Board
-
-
-@strawberry.type
-class User:
-    """User type for GraphQL API."""
-
-    id: UUID
-    tenant_id: UUID
-    auth_provider: str
-    auth_subject: str
-    email: str | None
-    display_name: str | None
-    avatar_url: str | None
-    created_at: datetime
-    updated_at: datetime
-
-    @strawberry.field
-    async def boards(
-        self, info: strawberry.Info
-    ) -> list[Annotated["Board", strawberry.lazy(".board")]]:  # noqa: E501
-        """Get boards owned by this user."""
-        # TODO: Implement data loader
-        from ..resolvers.user import resolve_user_boards
-
-        return await resolve_user_boards(self, info)
-
-    @strawberry.field
-    async def member_boards(
-        self, info: strawberry.Info
-    ) -> list[Annotated["Board", strawberry.lazy(".board")]]:  # noqa: E501
-        """Get boards where user is a member."""
-        # TODO: Implement data loader
-        from ..resolvers.user import resolve_user_member_boards
-
-        return await resolve_user_member_boards(self, info)

package/templates/api/src/boards/jobs/repository.py

@@ -1,153 +0,0 @@
-"""Repository helpers for Generations job lifecycle."""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from decimal import Decimal
-from typing import Any
-from uuid import UUID
-
-from sqlalchemy import select, update
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from ..dbmodels import Generations
-
-
-async def get_generation(session: AsyncSession, generation_id: str | UUID) -> Generations:
-    stmt = select(Generations).where(Generations.id == str(generation_id))
-    res = await session.execute(stmt)
-    row = res.scalar_one()
-    return row
-
-
-async def update_progress(
-    session: AsyncSession,
-    generation_id: str | UUID,
-    *,
-    status: str,
-    progress: float,
-    error_message: str | None = None,
-) -> None:
-    now = datetime.now(UTC)
-    stmt = (
-        update(Generations)
-        .where(Generations.id == str(generation_id))
-        .values(
-            status=status,
-            progress=progress,
-            error_message=error_message,
-            updated_at=now,
-            started_at=now if status == "processing" else Generations.started_at,
-            completed_at=(now if status in {"completed", "failed", "cancelled"} else None),
-        )
-    )
-    await session.execute(stmt)
-
-
-async def create_generation(
-    session: AsyncSession,
-    *,
-    tenant_id: UUID,
-    board_id: UUID,
-    user_id: UUID,
-    generator_name: str,
-    artifact_type: str,
-    input_params: dict,
-) -> Generations:
-    gen = Generations()
-    gen.tenant_id = tenant_id
-    gen.board_id = board_id
-    gen.user_id = user_id
-    gen.generator_name = generator_name
-    gen.artifact_type = artifact_type
-    gen.input_params = input_params
-    gen.status = "pending"
-    gen.progress = Decimal(0.0)
-    session.add(gen)
-    await session.flush()
-    return gen
-
-
-async def set_external_job_id(
-    session: AsyncSession, generation_id: str | UUID, external_job_id: str
-) -> None:
-    stmt = (
-        update(Generations)
-        .where(Generations.id == str(generation_id))
-        .values(external_job_id=external_job_id)
-    )
-    await session.execute(stmt)
-
-
-async def finalize_success(
-    session: AsyncSession,
-    generation_id: str | UUID,
-    *,
-    storage_url: str | None = None,
-    thumbnail_url: str | None = None,
-    output_metadata: dict[str, Any] | None = None,
-) -> None:
-    now = datetime.now(UTC)
-    stmt = (
-        update(Generations)
-        .where(Generations.id == str(generation_id))
-        .values(
-            status="completed",
-            progress=100.0,
-            storage_url=storage_url,
-            thumbnail_url=thumbnail_url,
-            output_metadata=output_metadata or {},
-            updated_at=now,
-            completed_at=now,
-        )
-    )
-    await session.execute(stmt)
-
-
-async def create_batch_generation(
-    session: AsyncSession,
-    *,
-    tenant_id: UUID,
-    board_id: UUID,
-    user_id: UUID,
-    generator_name: str,
-    artifact_type: str,
-    input_params: dict,
-    batch_id: str,
-    batch_index: int,
-) -> str:
-    """Create a batch generation record for multi-output generators.
-
-    This creates a new generation record that is part of a batch, with
-    batch metadata stored in output_metadata.
-
-    Args:
-        session: Database session
-        tenant_id: Tenant ID
-        board_id: Board ID
-        user_id: User ID
-        generator_name: Name of the generator
-        artifact_type: Type of artifact (image, video, etc.)
-        input_params: Input parameters (same as primary generation)
-        batch_id: Unique ID for this batch
-        batch_index: Index of this output in the batch
-
-    Returns:
-        ID of the created generation record
-    """
-    gen = Generations()
-    gen.tenant_id = tenant_id
-    gen.board_id = board_id
-    gen.user_id = user_id
-    gen.generator_name = generator_name
-    gen.artifact_type = artifact_type
-    gen.input_params = input_params
-    gen.status = "processing"
-    gen.progress = Decimal(0.0)
-    gen.output_metadata = {
-        "batch_id": batch_id,
-        "batch_index": batch_index,
-    }
-    session.add(gen)
-    await session.flush()
-    return str(gen.id)

package/templates/api/src/boards/logging.py

@@ -1,195 +0,0 @@
-"""
-Centralized logging configuration using structlog
-"""
-
-import base64
-import logging
-import secrets
-import sys
-import time
-from contextvars import ContextVar
-from typing import Any
-
-import structlog
-from fastapi import Request
-
-# Context variables for request tracking
-request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
-user_id_ctx: ContextVar[str | None] = ContextVar("user_id", default=None)
-
-
-class RequestContextFilter:
-    """Add request context to log records."""
-
-    def __call__(self, logger: Any, method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
-        """Add request context to the event dict."""
-        # Suppress unused parameter warnings - these are required by structlog interface
-        _ = logger, method_name
-
-        request_id = request_id_ctx.get()
-        user_id = user_id_ctx.get()
-
-        if request_id:
-            event_dict["request_id"] = request_id
-
-        if user_id:
-            event_dict["user_id"] = user_id
-
-        return event_dict
-
-
-def configure_logging(debug: bool = False) -> None:
-    """Configure structlog with appropriate processors and formatters.
-
-    Args:
-        debug: If True, use human-readable console output. If False, use JSON.
-    """
-
-    # Determine log level
-    log_level = logging.DEBUG if debug else logging.INFO
-
-    # Configure stdlib logging
-    logging.basicConfig(
-        level=log_level,
-        stream=sys.stdout,
-        format="%(message)s",
-        force=True,
-    )
-
-    # Configure structlog processors
-    processors = [
-        # Filter out keys with underscores (internal)
-        structlog.stdlib.filter_by_level,
-        # Add logger name to event dict
-        structlog.stdlib.add_logger_name,
-        # Add log level to event dict
-        structlog.stdlib.add_log_level,
-        # Add request context
-        RequestContextFilter(),
-        # Add timestamp
-        structlog.processors.TimeStamper(fmt="ISO", utc=True),
-        # Perform %-style string formatting
-        structlog.stdlib.PositionalArgumentsFormatter(),
-        # Stack info processor (for exceptions)
-        structlog.processors.StackInfoRenderer(),
-        # Exception info processor
-        structlog.processors.format_exc_info,
-        # Unicode decoder processor
-        structlog.processors.UnicodeDecoder(),
-    ]
-
-    if debug:
-        # Development: human-readable console output
-        processors.append(structlog.dev.ConsoleRenderer(colors=True))
-    else:
-        # Production: JSON output
-        processors.append(structlog.processors.JSONRenderer())
-
-    # Configure structlog
-    structlog.configure(
-        processors=processors,
-        wrapper_class=structlog.stdlib.BoundLogger,
-        logger_factory=structlog.stdlib.LoggerFactory(),
-        context_class=dict,
-        cache_logger_on_first_use=True,
-    )
-
-
-def get_logger(name: str) -> structlog.BoundLogger:
-    """Get a structlog logger instance.
-
-    Args:
-        name: Logger name (typically __name__)
-
-    Returns:
-        Configured structlog logger
-    """
-    return structlog.get_logger(name)
-
-
-def generate_request_id() -> str:
-    """Generate a compact, secure request ID with timestamp and randomness.
-
-    Uses microsecond precision timestamp with added randomness for security.
-    Format: 11-character base64 string (e.g., 'Ab3X9mF2xYz')
-
-    Provides high uniqueness probability while preventing predictable enumeration.
-    """
-    # Get microseconds since epoch (8 bytes when encoded as int64)
-    timestamp_us = int(time.time() * 1_000_000)
-
-    # Add 2 bytes of cryptographically secure randomness
-    random_bytes = secrets.token_bytes(2)
-
-    # Convert timestamp to bytes (8 bytes for int64) and combine with random bytes
-    timestamp_bytes = timestamp_us.to_bytes(8, byteorder="big")
-    combined_bytes = timestamp_bytes + random_bytes
-
-    # Encode as base64 and strip padding
-    b64 = base64.urlsafe_b64encode(combined_bytes).decode("ascii").rstrip("=")
-
-    return b64
-
-
-def set_request_context(request_id: str | None = None, user_id: str | None = None) -> None:
-    """Set request context variables.
-
-    Args:
-        request_id: Request ID to set (generates one if None)
-        user_id: User ID to set
-    """
-    if request_id is None:
-        request_id = generate_request_id()
-
-    request_id_ctx.set(request_id)
-    if user_id is not None:
-        user_id_ctx.set(user_id)
-
-
-def clear_request_context() -> None:
-    """Clear request context variables."""
-    request_id_ctx.set(None)
-    user_id_ctx.set(None)
-
-
-def get_request_id() -> str | None:
-    """Get the current request ID."""
-    return request_id_ctx.get()
-
-
-def get_user_id() -> str | None:
-    """Get the current user ID."""
-    return user_id_ctx.get()
-
-
-def extract_user_id_from_request(request: Request) -> str | None:
-    """Extract user ID from FastAPI request.
-
-    This should be customized based on your authentication implementation.
-
-    Args:
-        request: FastAPI request object
-
-    Returns:
-        User ID if authenticated, None otherwise
-    """
-    # TODO: Implement based on your auth strategy
-    # Examples:
-    # - JWT token in Authorization header
-    # - Session data
-    # - Supabase auth token
-
-    # For now, look for a user ID in headers (customize as needed)
-    auth_header = request.headers.get("authorization")
-    if auth_header:
-        # This is a placeholder - implement actual token parsing
-        # For example, if using Bearer tokens:
-        # if auth_header.startswith("Bearer "):
-        #     token = auth_header[7:]
-        #     # Parse JWT token to extract user_id
-        #     return parsed_user_id
-
-        # For now, return None until auth is implemented
-        return None
-
-    return None