Initial commit: AI Todo App Backend for Hugging Face Spaces

.dockerignore

@@ -0,0 +1,75 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+
+# Environment files
+.env
+.env.local
+.env.production
+
+# Test files
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Documentation
+README.md
+*.md
+
+# Docker
+Dockerfile
+.dockerignore 

.env

@@ -0,0 +1,16 @@
+# Database
+DATABASE_URL=sqlite:///./todo_app.db
+# For production use PostgreSQL:
+# DATABASE_URL=postgresql://user:password@localhost/todo_app
+
+# Groq Configuration
+GROQ_API_KEY=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
+GROQ_MODEL_NAME=llama3-8b-8192
+
+# API Configuration
+API_V1_STR=/api/v1
+PROJECT_NAME=AI Todo App
+DEBUG=True
+
+# CORS
+BACKEND_CORS_ORIGINS=["http://localhost:3000", "https://yourdomain.vercel.app"] 

DEPLOYMENT.md

@@ -0,0 +1,117 @@
+# Deployment Guide
+
+## Hugging Face Spaces Deployment
+
+### 1. Create a Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose "Docker" as the SDK
+4. Set the Space name and visibility
+5. Click "Create Space"
+
+### 2. Configure Environment Variables
+
+In your Hugging Face Space settings, add these environment variables:
+
+```
+DATABASE_URL=sqlite:///./todo_app.db
+GROQ_API_KEY=your_actual_groq_api_key
+GROQ_MODEL_NAME=llama3-8b-8192
+API_V1_STR=/api/v1
+PROJECT_NAME=AI Todo App
+DEBUG=False
+BACKEND_CORS_ORIGINS=["https://your-frontend-domain.com"]
+```
+
+### 3. Update Dockerfile for HF Spaces
+
+The Dockerfile is already optimized for Hugging Face Spaces. Make sure to:
+
+1. Set `DEBUG=False` in production
+2. Configure proper CORS origins
+3. Set your actual Groq API key
+
+### 4. Build and Deploy
+
+The Space will automatically build and deploy when you push to the repository.
+
+## Local Development
+
+### Using Docker Compose
+
+```bash
+# Build and run
+docker-compose up --build
+
+# Run in background
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Stop
+docker-compose down
+```
+
+### Using Docker directly
+
+```bash
+# Build image
+docker build -t todo-ai-app .
+
+# Run container
+docker run -p 8000:8000 -e GROQ_API_KEY=your_key todo-ai-app
+```
+
+## Environment Variables
+
+| Variable | Description | Required | Default |
+|----------|-------------|----------|---------|
+| `DATABASE_URL` | Database connection string | No | `sqlite:///./todo_app.db` |
+| `GROQ_API_KEY` | Groq API key for AI features | Yes | - |
+| `GROQ_MODEL_NAME` | Groq model to use | No | `llama3-8b-8192` |
+| `API_V1_STR` | API version prefix | No | `/api/v1` |
+| `PROJECT_NAME` | Application name | No | `AI Todo App` |
+| `DEBUG` | Debug mode | No | `True` |
+| `BACKEND_CORS_ORIGINS` | CORS allowed origins | No | `["http://localhost:3000"]` |
+
+## Health Check
+
+The application includes a health check endpoint at `/health` that returns:
+
+```json
+{
+  "status": "healthy"
+}
+```
+
+## API Documentation
+
+Once deployed, you can access:
+- API Documentation: `https://your-space.hf.space/docs`
+- Health Check: `https://your-space.hf.space/health`
+- Root endpoint: `https://your-space.hf.space/`
+
+**Note**: The application runs on port 7860, which is the standard port for Hugging Face Spaces.
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Port binding**: Make sure port 8000 is exposed
+2. **Environment variables**: Ensure all required env vars are set
+3. **Database**: SQLite database will be created automatically
+4. **CORS**: Update CORS origins for your frontend domain
+
+### Logs
+
+Check application logs for debugging:
+
+```bash
+# Docker Compose
+docker-compose logs app
+
+# Docker
+docker logs <container_id>
+``` 

Dockerfile

@@ -0,0 +1,40 @@
+# Use Python 3.11 slim image for smaller size
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONPATH=/app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create a non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+USER app
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')" || exit 1
+
+# Run the application
+CMD ["python", "run.py"] 

README.md

@@ -0,0 +1,110 @@
+---
+title: AI Todo App Backend
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# AI Todo App Backend
+
+A FastAPI-based backend application for an AI-powered todo management system with Groq AI integration.
+
+## Features
+
+- **FastAPI REST API** with automatic documentation
+- **SQLite Database** with SQLAlchemy ORM
+- **Groq AI Integration** for intelligent todo management
+- **CORS Support** for frontend integration
+- **Health Check Endpoints** for monitoring
+- **Docker Containerization** for easy deployment
+
+## API Endpoints
+
+- **GET /** - Root endpoint with app info
+- **GET /health** - Health check endpoint
+- **GET /docs** - Interactive API documentation (Swagger UI)
+- **GET /api/v1/** - API v1 endpoints
+
+## Environment Variables
+
+| Variable | Description | Required | Default |
+|----------|-------------|----------|---------|
+| `DATABASE_URL` | Database connection string | No | `sqlite:///./todo_app.db` |
+| `GROQ_API_KEY` | Groq API key for AI features | Yes | - |
+| `GROQ_MODEL_NAME` | Groq model to use | No | `llama3-8b-8192` |
+| `API_V1_STR` | API version prefix | No | `/api/v1` |
+| `PROJECT_NAME` | Application name | No | `AI Todo App` |
+| `DEBUG` | Debug mode | No | `True` |
+| `BACKEND_CORS_ORIGINS` | CORS allowed origins | No | `["http://localhost:3000"]` |
+
+## Local Development
+
+### Using Docker Compose
+
+```bash
+# Build and run
+docker-compose up --build
+
+# Run in background
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Stop
+docker-compose down
+```
+
+### Using Docker directly
+
+```bash
+# Build image
+docker build -t todo-ai-app .
+
+# Run container
+docker run -p 7860:7860 -e GROQ_API_KEY=your_key todo-ai-app
+```
+
+## Deployment
+
+This application is deployed on Hugging Face Spaces and runs on port 7860.
+
+### Access Points
+
+- **Application**: https://huggingface.co/spaces/Muhammadbilal10101/todo-ai
+- **API Documentation**: https://huggingface.co/spaces/Muhammadbilal10101/todo-ai/docs
+- **Health Check**: https://huggingface.co/spaces/Muhammadbilal10101/todo-ai/health
+
+## Technology Stack
+
+- **FastAPI** - Modern, fast web framework for building APIs
+- **SQLAlchemy** - SQL toolkit and ORM
+- **Alembic** - Database migration tool
+- **Pydantic** - Data validation using Python type annotations
+- **Groq** - Fast AI inference API
+- **Docker** - Containerization platform
+- **SQLite** - Lightweight database
+
+## Project Structure
+
+```
+backend/
+├── app/
+│   ├── api/          # API routes
+│   ├── core/         # Core configuration
+│   ├── models/       # Database models
+│   ├── schemas/      # Pydantic schemas
+│   └── services/     # Business logic
+├── alembic/          # Database migrations
+├── Dockerfile        # Docker configuration
+├── docker-compose.yml # Local development
+├── requirements.txt  # Python dependencies
+└── run.py           # Application entry point
+```
+
+## License
+
+MIT License - see LICENSE file for details. 

alembic.ini

@@ -0,0 +1,41 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+sqlalchemy.url = sqlite:///./todo_app.db
+
+[post_write_hooks]
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S 

alembic/env.py

@@ -0,0 +1,59 @@
+from logging.config import fileConfig
+from sqlalchemy import engine_from_config, pool
+from alembic import context
+import os
+import sys
+
+# Add your project directory to Python path
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+from app.core.config import settings
+from app.core.database import Base
+from app.models import todo, subtask  # Import all models
+
+# Alembic Config object
+config = context.config
+
+# Set SQLAlchemy URL from settings
+config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
+
+# Interpret the config file for Python logging
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Target metadata for 'autogenerate' support
+target_metadata = Base.metadata
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online() 

app/__init__.py

@@ -0,0 +1 @@
+# AI Todo App Backend 

app/api/__init__.py

@@ -0,0 +1 @@
+# API endpoints 

app/api/v1/__init__.py

@@ -0,0 +1 @@
+# API v1 endpoints 

app/api/v1/api.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+from .endpoints import todos, subtasks, translation
+
+api_router = APIRouter()
+
+api_router.include_router(todos.router, prefix="/todos", tags=["todos"])
+api_router.include_router(subtasks.router, prefix="", tags=["subtasks"])
+api_router.include_router(translation.router, prefix="/todos", tags=["translation"]) 

app/api/v1/endpoints/__init__.py

@@ -0,0 +1 @@
+# API endpoint modules 

app/api/v1/endpoints/subtasks.py

@@ -0,0 +1,62 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from ....core.database import get_db
+from ....schemas.subtask import Subtask, SubtaskGenerateRequest, SubtaskUpdate
+from ....services.todo_service import TodoService
+
+router = APIRouter()
+
+@router.post("/todos/{todo_id}/generate", response_model=List[Subtask])
+async def generate_subtasks(
+    todo_id: int,
+    request: SubtaskGenerateRequest,
+    db: Session = Depends(get_db)
+):
+    """Generate AI subtasks for a todo"""
+    todo_service = TodoService(db)
+    
+    try:
+        subtasks = await todo_service.generate_subtasks(
+            todo_id=todo_id,
+            max_subtasks=request.max_subtasks
+        )
+        return subtasks
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=str(e)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to generate subtasks: {str(e)}"
+        )
+
+@router.get("/todos/{todo_id}/subtasks", response_model=List[Subtask])
+def get_todo_subtasks(todo_id: int, db: Session = Depends(get_db)):
+    """Get all subtasks for a todo"""
+    todo_service = TodoService(db)
+    todo = todo_service.get_todo(todo_id)
+    if not todo:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+    return todo.subtasks
+
+@router.put("/subtasks/{subtask_id}", response_model=Subtask)
+def update_subtask(
+    subtask_id: int,
+    subtask_update: SubtaskUpdate,
+    db: Session = Depends(get_db)
+):
+    """Update a subtask"""
+    todo_service = TodoService(db)
+    updated_subtask = todo_service.update_subtask(subtask_id, subtask_update)
+    if not updated_subtask:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Subtask not found"
+        )
+    return updated_subtask 

app/api/v1/endpoints/todos.py

@@ -0,0 +1,75 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from ....core.database import get_db
+from ....schemas.todo import Todo, TodoCreate, TodoUpdate, TodoWithRelations
+from ....services.todo_service import TodoService
+
+router = APIRouter()
+
+@router.get("/", response_model=List[TodoWithRelations])
+def get_todos(
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db)
+):
+    """Get all todos with subtasks and translations"""
+    todo_service = TodoService(db)
+    return todo_service.get_todos(skip=skip, limit=limit)
+
+@router.get("/{todo_id}", response_model=TodoWithRelations)
+def get_todo(todo_id: int, db: Session = Depends(get_db)):
+    """Get a specific todo with subtasks and translations"""
+    todo_service = TodoService(db)
+    todo = todo_service.get_todo(todo_id)
+    if not todo:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+    return todo
+
+@router.post("/", response_model=TodoWithRelations, status_code=status.HTTP_201_CREATED)
+def create_todo(todo: TodoCreate, db: Session = Depends(get_db)):
+    """Create a new todo"""
+    todo_service = TodoService(db)
+    return todo_service.create_todo(todo)
+
+@router.put("/{todo_id}", response_model=TodoWithRelations)
+def update_todo(
+    todo_id: int,
+    todo_update: TodoUpdate,
+    db: Session = Depends(get_db)
+):
+    """Update an existing todo"""
+    todo_service = TodoService(db)
+    updated_todo = todo_service.update_todo(todo_id, todo_update)
+    if not updated_todo:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+    return updated_todo
+
+@router.delete("/{todo_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_todo(todo_id: int, db: Session = Depends(get_db)):
+    """Delete a todo"""
+    todo_service = TodoService(db)
+    success = todo_service.delete_todo(todo_id)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+
+@router.patch("/{todo_id}/toggle", response_model=TodoWithRelations)
+def toggle_todo_completion(todo_id: int, db: Session = Depends(get_db)):
+    """Toggle todo completion status"""
+    todo_service = TodoService(db)
+    updated_todo = todo_service.toggle_todo_completion(todo_id)
+    if not updated_todo:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+    return updated_todo 

app/api/v1/endpoints/translation.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from ....core.database import get_db
+from ....schemas.translation import Translation, TranslationRequest, TodoTranslationRequest
+from ....services.todo_service import TodoService
+
+router = APIRouter()
+
+@router.post("/{todo_id}/translate", response_model=Translation)
+async def translate_todo(
+    todo_id: int,
+    request: TodoTranslationRequest,
+    db: Session = Depends(get_db)
+):
+    """Translate a todo to target language"""
+    todo_service = TodoService(db)
+    
+    try:
+        translation = await todo_service.translate_todo(
+            todo_id=todo_id,
+            target_language=request.target_language
+        )
+        if not translation:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Todo not found"
+            )
+        return translation
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+
+@router.get("/{todo_id}/translations", response_model=List[Translation])
+def get_todo_translations(todo_id: int, db: Session = Depends(get_db)):
+    """Get all translations for a todo"""
+    todo_service = TodoService(db)
+    todo = todo_service.get_todo(todo_id)
+    if not todo:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Todo not found"
+        )
+    return todo_service.get_todo_translations(todo_id)
+
+@router.post("/translate", response_model=dict)
+async def translate_text(request: TranslationRequest):
+    """Translate any text to target language"""
+    from ....services.translation_service import translation_service
+    
+    try:
+        translated_text = await translation_service.translate_text(
+            text=request.text,
+            target_language=request.target_language
+        )
+        return {
+            "original_text": request.text,
+            "translated_text": translated_text,
+            "target_language": request.target_language
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        ) 

app/core/__init__.py

@@ -0,0 +1 @@
+# Core configuration and database setup 

app/core/config.py

@@ -0,0 +1,28 @@
+from pydantic_settings import BaseSettings
+from typing import List
+import os
+
+class Settings(BaseSettings):
+    # API Settings
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "AI Todo App"
+    DEBUG: bool = True
+    
+    # Database
+    DATABASE_URL: str = "sqlite:///./todo_app.db"
+    
+    # Groq Configuration
+    GROQ_API_KEY: str
+    GROQ_MODEL_NAME: str = "llama3-8b-8192"
+    
+    # CORS
+    BACKEND_CORS_ORIGINS: List[str] = [
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+    ]
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings() 

app/core/database.py

@@ -0,0 +1,27 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import settings
+
+# Create engine
+if settings.DATABASE_URL.startswith("sqlite"):
+    engine = create_engine(
+        settings.DATABASE_URL, 
+        connect_args={"check_same_thread": False}
+    )
+else:
+    engine = create_engine(settings.DATABASE_URL)
+
+# Create session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base class for models
+Base = declarative_base()
+
+# Dependency to get database session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close() 

app/main.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .core.config import settings
+from .core.database import engine, Base
+from .api.v1.api import api_router
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+# Create FastAPI app
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    openapi_url=f"{settings.API_V1_STR}/openapi.json",
+    debug=settings.DEBUG
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.BACKEND_CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include API router
+app.include_router(api_router, prefix=settings.API_V1_STR)
+
+@app.get("/")
+async def root():
+    return {"message": "AI Todo App API", "version": "1.0.0"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True) 

app/models/__init__.py

@@ -0,0 +1 @@
+# Database models 

app/models/subtask.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, Integer, String, Text, Boolean, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from ..core.database import Base
+
+class Subtask(Base):
+    __tablename__ = "subtasks"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    todo_id = Column(Integer, ForeignKey("todos.id"), nullable=False)
+    title = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+    completed = Column(Boolean, default=False, nullable=False)
+    order_index = Column(Integer, default=0)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    
+    # Relationships
+    todo = relationship("Todo", back_populates="subtasks")
+
+class Translation(Base):
+    __tablename__ = "translations"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    todo_id = Column(Integer, ForeignKey("todos.id"), nullable=False)
+    language = Column(String(50), nullable=False)
+    translated_title = Column(String(500), nullable=False)
+    translated_description = Column(Text, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    
+    # Relationships
+    todo = relationship("Todo", back_populates="translations") 

app/models/todo.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Column, Integer, String, Text, Boolean, DateTime
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from ..core.database import Base
+
+class Todo(Base):
+    __tablename__ = "todos"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    completed = Column(Boolean, default=False, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    subtasks = relationship("Subtask", back_populates="todo", cascade="all, delete-orphan")
+    translations = relationship("Translation", back_populates="todo", cascade="all, delete-orphan") 

app/schemas/__init__.py

@@ -0,0 +1 @@
+# Pydantic schemas for request/response models 

app/schemas/subtask.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+class SubtaskBase(BaseModel):
+    title: str = Field(..., min_length=1, max_length=255)
+    description: Optional[str] = None
+
+class SubtaskCreate(SubtaskBase):
+    todo_id: int
+    order_index: Optional[int] = 0
+
+class SubtaskUpdate(BaseModel):
+    title: Optional[str] = Field(None, min_length=1, max_length=255)
+    description: Optional[str] = None
+    completed: Optional[bool] = None
+    order_index: Optional[int] = None
+
+class Subtask(SubtaskBase):
+    id: int
+    todo_id: int
+    completed: bool
+    order_index: int
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+class SubtaskGenerateRequest(BaseModel):
+    todo_id: int
+    max_subtasks: Optional[int] = Field(default=5, ge=1, le=10) 

app/schemas/todo.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, TYPE_CHECKING
+from datetime import datetime
+
+if TYPE_CHECKING:
+    from .subtask import Subtask
+    from .translation import Translation
+
+# Base Todo schema
+class TodoBase(BaseModel):
+    title: str = Field(..., min_length=1, max_length=255)
+    description: Optional[str] = None
+
+# Schema for creating Todo
+class TodoCreate(TodoBase):
+    pass
+
+# Schema for updating Todo
+class TodoUpdate(BaseModel):
+    title: Optional[str] = Field(None, min_length=1, max_length=255)
+    description: Optional[str] = None
+    completed: Optional[bool] = None
+
+# Schema for Todo response
+class Todo(TodoBase):
+    id: int
+    completed: bool
+    created_at: datetime
+    updated_at: Optional[datetime]
+    
+    class Config:
+        from_attributes = True
+
+# Schema for Todo with relations
+class TodoWithRelations(Todo):
+    subtasks: List["Subtask"] = []
+    translations: List["Translation"] = []
+
+# Import the actual classes to resolve forward references
+from .subtask import Subtask
+from .translation import Translation
+
+# Rebuild the model to resolve forward references
+TodoWithRelations.model_rebuild() 

app/schemas/translation.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+class TranslationBase(BaseModel):
+    language: str = Field(..., min_length=2, max_length=50)
+    translated_title: str = Field(..., min_length=1, max_length=500)
+    translated_description: Optional[str] = None
+
+class Translation(TranslationBase):
+    id: int
+    todo_id: int
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+class TranslationRequest(BaseModel):
+    text: str = Field(..., min_length=1)
+    target_language: str = Field(..., min_length=2, max_length=50)
+
+class TodoTranslationRequest(BaseModel):
+    target_language: str = Field(..., min_length=2, max_length=50) 

app/services/__init__.py

@@ -0,0 +1 @@
+# Business logic services