solokit 0.1.1__py3-none-any.whl

solokit/templates/ml_ai_fastapi/base/pyproject.toml.template

@@ -0,0 +1,91 @@
+[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "{project_description}"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi==0.115.6",
+    "uvicorn[standard]==0.34.0",
+    "pydantic==2.12.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.11.0",
+    "sqlmodel==0.0.25",
+    "sqlalchemy==2.0.37",
+    "psycopg2-binary==2.9.10",
+    "alembic==1.14.0",
+    "python-dotenv==1.2.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.4",
+    "pytest-cov==6.0.0",
+    "pytest-asyncio==0.25.2",
+    "httpx==0.28.1",
+    "ruff==0.9.2",
+    "pyright==1.1.396",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "N",  # pep8-naming
+    "UP", # pyupgrade
+]
+
+ignore = [
+    "E501",  # line too long (handled by formatter)
+]
+
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    "alembic/versions",
+    ".pytest_cache",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.isort]
+known-first-party = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--tb=short",
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "alembic/*",
+    "*/__init__.py",
+]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false

solokit/templates/ml_ai_fastapi/base/requirements.txt.template

@@ -0,0 +1,28 @@
+# Base Dependencies for {project_name}
+# FastAPI Framework
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+
+# Data Validation
+pydantic==2.12.4
+pydantic-core==2.41.5
+pydantic-settings==2.11.0
+
+# Database ORM
+sqlmodel==0.0.25
+sqlalchemy==2.0.37
+psycopg2-binary==2.9.10
+
+# Database Migrations
+alembic==1.14.0
+
+# Environment Variables
+python-dotenv==1.2.1
+
+# Development Dependencies (Tier 1)
+pytest==8.3.4
+pytest-cov==6.0.0
+pytest-asyncio==0.25.2
+httpx==0.28.1
+ruff==0.9.2
+pyright==1.1.396

solokit/templates/ml_ai_fastapi/base/src/__init__.py

@@ -0,0 +1,5 @@
+"""
+{project_name} - FastAPI ML/AI Application
+"""
+
+__version__ = "0.1.0"

solokit/templates/ml_ai_fastapi/base/src/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API package - contains all API routes and endpoints
+"""

solokit/templates/ml_ai_fastapi/base/src/api/dependencies.py

@@ -0,0 +1,20 @@
+"""
+FastAPI dependency injection - provides shared dependencies like database sessions
+"""
+
+from collections.abc import AsyncGenerator
+
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.core.database import async_session_maker
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """
+    Dependency that provides a database session.
+
+    Yields:
+        AsyncSession: Database session
+    """
+    async with async_session_maker() as session:
+        yield session

solokit/templates/ml_ai_fastapi/base/src/api/routes/__init__.py

@@ -0,0 +1,3 @@
+"""
+API routes package
+"""

solokit/templates/ml_ai_fastapi/base/src/api/routes/example.py

@@ -0,0 +1,134 @@
+"""
+Example CRUD endpoints demonstrating SQLModel usage
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.api.dependencies import get_db
+from src.models.example import Item, ItemCreate, ItemRead, ItemUpdate
+from src.services.example import ItemService
+
+router = APIRouter()
+
+
+@router.post("/items", response_model=ItemRead, status_code=status.HTTP_201_CREATED)
+async def create_item(
+    item: ItemCreate,
+    db: AsyncSession = Depends(get_db),
+) -> Item:
+    """
+    Create a new item.
+
+    Args:
+        item: Item data
+        db: Database session
+
+    Returns:
+        Item: Created item
+    """
+    service = ItemService(db)
+    return await service.create_item(item)
+
+
+@router.get("/items", response_model=list[ItemRead])
+async def list_items(
+    skip: int = 0,
+    limit: int = 100,
+    db: AsyncSession = Depends(get_db),
+) -> list[Item]:
+    """
+    List all items with pagination.
+
+    Args:
+        skip: Number of items to skip
+        limit: Maximum number of items to return
+        db: Database session
+
+    Returns:
+        List[Item]: List of items
+    """
+    service = ItemService(db)
+    return await service.get_items(skip=skip, limit=limit)
+
+
+@router.get("/items/{item_id}", response_model=ItemRead)
+async def get_item(
+    item_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> Item:
+    """
+    Get a specific item by ID.
+
+    Args:
+        item_id: Item ID
+        db: Database session
+
+    Returns:
+        Item: Item data
+
+    Raises:
+        HTTPException: If item not found
+    """
+    service = ItemService(db)
+    item = await service.get_item(item_id)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Item with id {item_id} not found",
+        )
+    return item
+
+
+@router.patch("/items/{item_id}", response_model=ItemRead)
+async def update_item(
+    item_id: int,
+    item_update: ItemUpdate,
+    db: AsyncSession = Depends(get_db),
+) -> Item:
+    """
+    Update an item.
+
+    Args:
+        item_id: Item ID
+        item_update: Fields to update
+        db: Database session
+
+    Returns:
+        Item: Updated item
+
+    Raises:
+        HTTPException: If item not found
+    """
+    service = ItemService(db)
+    item = await service.update_item(item_id, item_update)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Item with id {item_id} not found",
+        )
+    return item
+
+
+@router.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_item(
+    item_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> None:
+    """
+    Delete an item.
+
+    Args:
+        item_id: Item ID
+        db: Database session
+
+    Raises:
+        HTTPException: If item not found
+    """
+    service = ItemService(db)
+    success = await service.delete_item(item_id)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Item with id {item_id} not found",
+        )

solokit/templates/ml_ai_fastapi/base/src/api/routes/health.py

@@ -0,0 +1,66 @@
+"""
+Health check endpoints for monitoring and load balancers
+"""
+
+from fastapi import APIRouter, Depends
+from sqlmodel import text
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.api.dependencies import get_db
+from src.core.config import settings
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def health_check() -> dict[str, str]:
+    """
+    Basic health check endpoint.
+
+    Returns:
+        dict: Health status
+    """
+    return {
+        "status": "healthy",
+        "service": settings.APP_NAME,
+        "version": settings.APP_VERSION,
+    }
+
+
+@router.get("/health/ready")
+async def readiness_check(db: AsyncSession = Depends(get_db)) -> dict[str, str]:
+    """
+    Readiness check - verifies database connectivity.
+
+    Args:
+        db: Database session
+
+    Returns:
+        dict: Readiness status
+    """
+    try:
+        # Test database connection
+        await db.exec(text("SELECT 1"))
+        return {
+            "status": "ready",
+            "database": "connected",
+        }
+    except Exception as e:
+        return {
+            "status": "not ready",
+            "database": "disconnected",
+            "error": str(e),
+        }
+
+
+@router.get("/health/live")
+async def liveness_check() -> dict[str, str]:
+    """
+    Liveness check - verifies the application is running.
+
+    Returns:
+        dict: Liveness status
+    """
+    return {
+        "status": "alive",
+    }

solokit/templates/ml_ai_fastapi/base/src/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core package - contains configuration, database, and utilities
+"""

solokit/templates/ml_ai_fastapi/base/src/core/config.py

@@ -0,0 +1,64 @@
+"""
+Application configuration using pydantic-settings
+"""
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables.
+
+    Attributes:
+        APP_NAME: Application name
+        APP_VERSION: Application version
+        DEBUG: Debug mode
+        ENVIRONMENT: Environment (development, staging, production)
+        DATABASE_URL: Database connection string
+        SECRET_KEY: Secret key for cryptographic operations
+        CORS_ORIGINS: List of allowed CORS origins
+        LOG_LEVEL: Logging level
+    """
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+    )
+
+    # Application
+    APP_NAME: str = "{project_name}"
+    APP_VERSION: str = "0.1.0"
+    DEBUG: bool = True
+    ENVIRONMENT: str = "development"
+
+    # Database
+    DATABASE_URL: str = "postgresql://user:password@localhost:5432/{project_name}_db"
+
+    # Security
+    SECRET_KEY: str = "change-this-to-a-random-secret-key"
+    ALLOWED_HOSTS: list[str] = ["localhost", "127.0.0.1"]
+
+    # CORS
+    CORS_ORIGINS: list[str] = ["http://localhost:3000", "http://localhost:8000"]
+
+    @field_validator("CORS_ORIGINS", mode="before")
+    @classmethod
+    def parse_cors_origins(cls, v: str | list[str]) -> list[str]:
+        """Parse CORS origins from string or list."""
+        if isinstance(v, str):
+            return [origin.strip() for origin in v.split(",")]
+        return v
+
+    # Logging
+    LOG_LEVEL: str = "DEBUG"
+    LOG_FORMAT: str = "json"
+
+    # Server
+    HOST: str = "0.0.0.0"  # nosec B104 - Binding to all interfaces is intentional for development
+    PORT: int = 8000
+
+
+# Global settings instance
+settings = Settings()

solokit/templates/ml_ai_fastapi/base/src/core/database.py

@@ -0,0 +1,50 @@
+"""
+Database configuration and session management
+"""
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.core.config import settings
+
+# Convert postgresql:// to postgresql+asyncpg:// for async support
+DATABASE_URL = settings.DATABASE_URL.replace("postgresql://", "postgresql+asyncpg://")
+
+# Create async engine
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=settings.DEBUG,
+    future=True,
+)
+
+# Create async session maker
+async_session_maker = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+
+async def create_db_and_tables() -> None:
+    """
+    Create all database tables.
+    In production, use Alembic migrations instead.
+    """
+    async with engine.begin() as conn:
+        # Import all models here to ensure they are registered
+        from src.models import Item  # noqa: F401
+
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+
+async def get_session() -> AsyncSession:
+    """
+    Get a database session.
+
+    Yields:
+        AsyncSession: Database session
+    """
+    async with async_session_maker() as session:
+        yield session

solokit/templates/ml_ai_fastapi/base/src/main.py

@@ -0,0 +1,64 @@
+"""
+FastAPI application entry point for {project_name}
+"""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from src.api.routes import example, health
+from src.core.config import settings
+from src.core.database import create_db_and_tables
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """
+    Application lifespan manager - handles startup and shutdown events.
+    """
+    # Startup
+    print(f"Starting {settings.APP_NAME} v{settings.APP_VERSION}")
+    print(f"Environment: {settings.ENVIRONMENT}")
+
+    # Create database tables
+    await create_db_and_tables()
+
+    yield
+
+    # Shutdown
+    print(f"Shutting down {settings.APP_NAME}")
+
+
+# Create FastAPI application
+app = FastAPI(
+    title=settings.APP_NAME,
+    version=settings.APP_VERSION,
+    description="{project_description}",
+    lifespan=lifespan,
+    debug=settings.DEBUG,
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(health.router, tags=["health"])
+app.include_router(example.router, prefix="/api/v1", tags=["examples"])
+
+
+@app.get("/")
+async def root() -> dict[str, str]:
+    """Root endpoint - returns API information."""
+    return {
+        "name": settings.APP_NAME,
+        "version": settings.APP_VERSION,
+        "status": "running",
+    }

solokit/templates/ml_ai_fastapi/base/src/models/__init__.py

@@ -0,0 +1,7 @@
+"""
+SQLModel models package
+"""
+
+from src.models.example import Item, ItemCreate, ItemRead, ItemUpdate
+
+__all__ = ["Item", "ItemCreate", "ItemRead", "ItemUpdate"]

solokit/templates/ml_ai_fastapi/base/src/models/example.py

@@ -0,0 +1,61 @@
+"""
+Example SQLModel model demonstrating best practices
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+
+class ItemBase(SQLModel):
+    """Base model with shared fields."""
+
+    name: str = Field(index=True, max_length=255)
+    description: Optional[str] = Field(default=None, max_length=1000)
+    price: float = Field(gt=0)
+    is_active: bool = Field(default=True)
+
+
+class Item(ItemBase, table=True):
+    """
+    Item database model.
+
+    Attributes:
+        id: Primary key
+        name: Item name
+        description: Item description
+        price: Item price (must be > 0)
+        is_active: Whether item is active
+        created_at: Timestamp when item was created
+        updated_at: Timestamp when item was last updated
+    """
+
+    __tablename__ = "items"
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class ItemCreate(ItemBase):
+    """Schema for creating a new item."""
+
+    pass
+
+
+class ItemRead(ItemBase):
+    """Schema for reading an item (includes id and timestamps)."""
+
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+
+class ItemUpdate(SQLModel):
+    """Schema for updating an item (all fields optional)."""
+
+    name: Optional[str] = Field(default=None, max_length=255)
+    description: Optional[str] = Field(default=None, max_length=1000)
+    price: Optional[float] = Field(default=None, gt=0)
+    is_active: Optional[bool] = None

solokit/templates/ml_ai_fastapi/base/src/services/__init__.py

@@ -0,0 +1,3 @@
+"""
+Business logic services package
+"""