Add simple todo app with FastAPI and SQLite

- Created FastAPI application with CRUD endpoints for todos
- Set up SQLAlchemy with SQLite database
- Created database models and Pydantic schemas
- Added Alembic for database migrations
- Added health check endpoint
- Updated README with project information

generated with BackendIM... (backend.im)
This commit is contained in:
Automated Action 2025-05-12 22:59:07 +00:00
parent d63f110e1a
commit a054c1c20d
12 changed files with 496 additions and 2 deletions

View File

@ -1,3 +1,73 @@
# FastAPI Application
# Simple Todo App
This is a FastAPI application bootstrapped by BackendIM, the AI-powered backend generation platform.
This is a simple Todo API built with FastAPI and SQLite.
## Features
- Create, read, update, and delete todo items
- Health check endpoint
- SQLite database with SQLAlchemy ORM
- Alembic for database migrations
## Project Structure
```
simpletodoapp/
├── alembic/ # Database migrations
│ ├── versions/ # Migration versions
│ ├── env.py # Alembic environment configuration
│ └── script.py.mako # Migration script template
├── app/ # Application package
│ ├── __init__.py
│ ├── crud.py # CRUD operations
│ ├── database.py # Database setup and connection
│ ├── models.py # SQLAlchemy models
│ └── schemas.py # Pydantic schemas for API
├── alembic.ini # Alembic configuration
├── main.py # FastAPI application and endpoints
└── requirements.txt # Python dependencies
```
## API Endpoints
- `GET /health` - Health check endpoint
- `GET /todos` - Get all todos
- `POST /todos` - Create a new todo
- `GET /todos/{todo_id}` - Get a specific todo
- `PUT /todos/{todo_id}` - Update a todo
- `DELETE /todos/{todo_id}` - Delete a todo
## Getting Started
1. Install dependencies:
```
pip install -r requirements.txt
```
2. Run database migrations:
```
alembic upgrade head
```
3. Start the application:
```
uvicorn main:app --reload
```
4. Access the API documentation at http://localhost:8000/docs
## Todo Item Schema
```json
{
"id": 1,
"title": "Task title",
"description": "Task description",
"completed": false,
"created_at": "2023-01-01T00:00:00",
"updated_at": "2023-01-01T00:00:00"
}
```

107
alembic.ini Normal file
View File

@ -0,0 +1,107 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
script_location = alembic
# template used to generate migration files
# file_template = %%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9
# from time import has_tzinfo will be used to determine the
# migration filename.
# If set to 'true', alembic will use the system timezone.
# timezone =
# max length of characters to apply to the
# "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to alembic/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# set to 'true' to search source files recursively
# in each "version_locations" directory
# new in Alembic version 1.10
# recursive_version_locations = false
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = sqlite:////app/storage/db/db.sqlite
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# Logging configuration
[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

77
alembic/env.py Normal file
View File

@ -0,0 +1,77 @@
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from alembic import context
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
from app.database import Base
from app.models import Todo
target_metadata = Base.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
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():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
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()

24
alembic/script.py.mako Normal file
View File

@ -0,0 +1,24 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}

View File

@ -0,0 +1,36 @@
"""Create todos table
Revision ID: e55826737163
Revises:
Create Date: 2023-01-01 00:00:00.000000
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'e55826737163'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
op.create_table('todos',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('title', sa.String(), nullable=False),
sa.Column('description', sa.String(), nullable=True),
sa.Column('completed', sa.Boolean(), nullable=True, default=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)')),
sa.Column('updated_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)')),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_todos_id'), 'todos', ['id'], unique=False)
op.create_index(op.f('ix_todos_title'), 'todos', ['title'], unique=False)
def downgrade():
op.drop_index(op.f('ix_todos_title'), table_name='todos')
op.drop_index(op.f('ix_todos_id'), table_name='todos')
op.drop_table('todos')

1
app/__init__.py Normal file
View File

@ -0,0 +1 @@
# App package initialization

40
app/crud.py Normal file
View File

@ -0,0 +1,40 @@
from sqlalchemy.orm import Session
from . import models, schemas
def get_todo(db: Session, todo_id: int):
return db.query(models.Todo).filter(models.Todo.id == todo_id).first()
def get_todos(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.Todo).offset(skip).limit(limit).all()
def create_todo(db: Session, todo: schemas.TodoCreate):
db_todo = models.Todo(
title=todo.title,
description=todo.description,
completed=todo.completed
)
db.add(db_todo)
db.commit()
db.refresh(db_todo)
return db_todo
def update_todo(db: Session, todo_id: int, todo: schemas.TodoUpdate):
db_todo = get_todo(db, todo_id)
# Update fields if they are provided
if todo.title is not None:
db_todo.title = todo.title
if todo.description is not None:
db_todo.description = todo.description
if todo.completed is not None:
db_todo.completed = todo.completed
db.commit()
db.refresh(db_todo)
return db_todo
def delete_todo(db: Session, todo_id: int):
db_todo = get_todo(db, todo_id)
db.delete(db_todo)
db.commit()
return db_todo

26
app/database.py Normal file
View File

@ -0,0 +1,26 @@
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from pathlib import Path
# Create database directory
DB_DIR = Path("/app") / "storage" / "db"
DB_DIR.mkdir(parents=True, exist_ok=True)
SQLALCHEMY_DATABASE_URL = f"sqlite:///{DB_DIR}/db.sqlite"
engine = create_engine(
SQLALCHEMY_DATABASE_URL,
connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()

13
app/models.py Normal file
View File

@ -0,0 +1,13 @@
from sqlalchemy import Boolean, Column, Integer, String, DateTime
from sqlalchemy.sql import func
from .database import Base
class Todo(Base):
__tablename__ = "todos"
id = Column(Integer, primary_key=True, index=True)
title = Column(String, index=True)
description = Column(String, nullable=True)
completed = Column(Boolean, default=False)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

24
app/schemas.py Normal file
View File

@ -0,0 +1,24 @@
from pydantic import BaseModel
from typing import Optional
from datetime import datetime
class TodoBase(BaseModel):
title: str
description: Optional[str] = None
completed: Optional[bool] = False
class TodoCreate(TodoBase):
pass
class TodoUpdate(BaseModel):
title: Optional[str] = None
description: Optional[str] = None
completed: Optional[bool] = None
class Todo(TodoBase):
id: int
created_at: datetime
updated_at: datetime
class Config:
orm_mode = True

70
main.py Normal file
View File

@ -0,0 +1,70 @@
from fastapi import FastAPI, Depends, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import uvicorn
from typing import List
from pathlib import Path
from app.database import engine, get_db
from app import models, schemas, crud
from sqlalchemy.orm import Session
# Create the database tables
models.Base.metadata.create_all(bind=engine)
app = FastAPI(
title="Todo API",
description="A simple Todo API built with FastAPI and SQLite",
version="1.0.0"
)
# CORS middleware
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
@app.get("/health", tags=["Health"])
async def health_check():
"""Health check endpoint"""
return {"status": "healthy"}
@app.get("/todos", response_model=List[schemas.Todo], tags=["Todos"])
def read_todos(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
"""Get all todos"""
todos = crud.get_todos(db, skip=skip, limit=limit)
return todos
@app.post("/todos", response_model=schemas.Todo, status_code=201, tags=["Todos"])
def create_todo(todo: schemas.TodoCreate, db: Session = Depends(get_db)):
"""Create a new todo"""
return crud.create_todo(db=db, todo=todo)
@app.get("/todos/{todo_id}", response_model=schemas.Todo, tags=["Todos"])
def read_todo(todo_id: int, db: Session = Depends(get_db)):
"""Get a specific todo by id"""
db_todo = crud.get_todo(db, todo_id=todo_id)
if db_todo is None:
raise HTTPException(status_code=404, detail="Todo not found")
return db_todo
@app.put("/todos/{todo_id}", response_model=schemas.Todo, tags=["Todos"])
def update_todo(todo_id: int, todo: schemas.TodoUpdate, db: Session = Depends(get_db)):
"""Update a todo"""
db_todo = crud.get_todo(db, todo_id=todo_id)
if db_todo is None:
raise HTTPException(status_code=404, detail="Todo not found")
return crud.update_todo(db=db, todo_id=todo_id, todo=todo)
@app.delete("/todos/{todo_id}", response_model=schemas.Todo, tags=["Todos"])
def delete_todo(todo_id: int, db: Session = Depends(get_db)):
"""Delete a todo"""
db_todo = crud.get_todo(db, todo_id=todo_id)
if db_todo is None:
raise HTTPException(status_code=404, detail="Todo not found")
return crud.delete_todo(db=db, todo_id=todo_id)
if __name__ == "__main__":
uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

6
requirements.txt Normal file
View File

@ -0,0 +1,6 @@
fastapi>=0.68.0
uvicorn>=0.15.0
sqlalchemy>=1.4.23
alembic>=1.7.3
pydantic>=1.8.2
python-dotenv>=0.19.0