DEV Community: Art Baker

The FastAPI Starter Template I Wish I Had When I Started

Art Baker — Thu, 16 Apr 2026 23:44:38 +0000

Every FastAPI project starts the same way: copy-paste from the docs, manually set up CORS, figure out Pydantic models, write a Dockerfile, remember how TestClient works.

I got tired of doing this every time, so I made a clean starter template. Here's what's in it and why.

The structure

fastapi_starter/
├── main.py           # CRUD API with models, CORS, error handling
├── test_main.py      # pytest suite with TestClient
├── Dockerfile        # Production container
├── requirements.txt  # Pinned deps
└── README.md         # Quick start guide

main.py — the whole API in 50 lines

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel

app = FastAPI(title="API", version="1.0.0")
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])

class Item(BaseModel):
    name: str
    description: str = ""
    price: float

items: dict[int, Item] = {}
next_id = 1

@app.post("/items", status_code=201)
def create_item(item: Item):
    global next_id
    items[next_id] = item
    next_id += 1
    return {"id": next_id - 1, **item.dict()}

@app.get("/items/{item_id}")
def get_item(item_id: int):
    if item_id not in items:
        raise HTTPException(404, "Item not found")
    return {"id": item_id, **items[item_id].dict()}

CORS is on by default (you'll forget otherwise). Pydantic handles validation. HTTPException gives clean error responses.

test_main.py — 5 tests that actually matter

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_create_and_get():
    r = client.post("/items", json={"name": "Widget", "price": 9.99})
    assert r.status_code == 201
    r2 = client.get(f"/items/{r.json()['id']}")
    assert r2.json()["name"] == "Widget"

def test_not_found():
    assert client.get("/items/999").status_code == 404

Run with pytest test_main.py -v. No external DB needed — the in-memory store makes tests fast and isolated.

Dockerfile — one command to deploy

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t myapi . && docker run -p 8000:8000 myapi — done.

What I'd add next

SQLAlchemy + Alembic for a real database
OAuth2 + JWT authentication
Rate limiting middleware
Background tasks with Celery or ARQ

But the template is deliberately minimal — it gives you a clean starting point without opinions you'll have to undo.

Full starter template (main.py + tests + Docker + README): payhip.com/b/2ptFz ($7)

Also available:

Python Automation Toolkit — 10 standalone scripts ($12)
Regex Cookbook — 50 patterns ($9)
AI Prompt Pack — 50 prompts for Claude/ChatGPT ($9)
Python Cheat Sheet ($5)

The Python Quick Reference I Actually Use (Cheat Sheet)

Art Baker — Thu, 16 Apr 2026 22:52:17 +0000

I keep a single-page Python reference that covers 90% of what I type daily. Here are the highlights.

Data Structures — the 10 patterns that matter

# List comprehension with filter
[x**2 for x in nums if x > 1]

# Dict comprehension
{k: v for k, v in d.items() if v > 0}

# Set operations
a & b   # intersection
a | b   # union
a - b   # difference

# Unpacking
a, *rest = [1, 2, 3, 4]  # a=1, rest=[2,3,4]
merged = {**d1, **d2}     # merge dicts (3.9+: d1 | d2)

Strings

f"Name: {name!r}"               # f-string with repr
" ".join(["a", "b", "c"])       # "a b c"
text.split()                     # split on whitespace
re.sub(r"\s+", " ", text)       # collapse whitespace

Files — pathlib over os.path

from pathlib import Path

text = Path("file.txt").read_text()
Path("out.txt").write_text("hello")

for f in Path(".").glob("**/*.py"):
    print(f.name)

Functions

# Decorator
from functools import wraps
def timer(fn):
    @wraps(fn)
    def wrapper(*a, **kw):
        t0 = time.time()
        r = fn(*a, **kw)
        print(f"{fn.__name__}: {time.time()-t0:.2f}s")
        return r
    return wrapper

# Generator
def chunks(lst, n):
    for i in range(0, len(lst), n):
        yield lst[i:i+n]

One-Liners I Use Weekly

# Flatten nested list
flat = [x for sub in nested for x in sub]

# Remove duplicates preserving order
seen = set()
unique = [x for x in items if x not in seen and not seen.add(x)]

# Invert a dict
inv = {v: k for k, v in d.items()}

# Counter
from collections import Counter
Counter(words).most_common(5)

Async (httpx pattern)

import asyncio, httpx

async def fetch_all(urls):
    async with httpx.AsyncClient() as c:
        return await asyncio.gather(*(c.get(u) for u in urls))

results = asyncio.run(fetch_all(["https://a.com", "https://b.com"]))

Full cheat sheet

This is ~30% of my full reference. The complete version covers: data structures, strings, files, JSON/CSV, functions, decorators, generators, classes, dataclasses, error handling, async, match statements, context managers, and every import I reach for.

PDF: payhip.com/b/1xsQH ($5)

Also:

Python Automation Toolkit — 10 standalone scripts ($12)
Regex Cookbook — 50 patterns ($9)
AI Prompt Pack — 50 prompts for Claude/ChatGPT ($9)
Free preview on GitHub: Devtoolkit26/python-automation-toolkit-lite

The 10 AI Prompts That Actually Improved My Code Quality

Art Baker — Thu, 16 Apr 2026 21:20:58 +0000

placeholder

50 Regex Patterns Every Developer Should Have Bookmarked

Art Baker — Thu, 16 Apr 2026 21:16:31 +0000

Every time I need a regex, I end up Googling the same patterns. So I made myself a reference — here are 15 of the most useful from my full 50-pattern cookbook.

Each works across Python, JavaScript, Ruby, Go, and any PCRE engine.

Validation

Email (simplified RFC 5322)

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

URL (http/https)

^https?://[^\s/$.?#].[^\s]*$

Strong password (8+ chars, mixed case, digit, special)

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

UUID v4

^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

Extraction

All URLs from text

https?://[^\s<>"{}\\^`\[\]]+

Email addresses from text

\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b

Currency amounts

\$\d{1,3}(?:,\d{3})*(?:\.\d{2})?

Version numbers (semver)

\b\d+\.\d+\.\d+\b

Cleaning

Strip HTML tags

Pattern: <[^>]+> — replace with empty string

Collapse multiple spaces

Pattern: \s+ — replace with single space

Mask credit card numbers

Pattern: \b(\d{4})\d{8}(\d{4})\b — replace with $1********$2

CamelCase to snake_case

Pattern: ([a-z0-9])([A-Z]) — replace with $1_$2, then lowercase

Log Parsing

Apache/Nginx log line

^(\S+) \S+ \S+ \[([\w:/]+\s[+\-]\d{4})\] "(\S+) (.*?) (\S+)" (\d{3}) (\d+|-)

Captures: IP, timestamp, method, path, protocol, status code, bytes

Python stack trace line

File "([^"]+)", line (\d+), in (\w+)

HTTP status code from log

\s(2|3|4|5)\d{2}\s

Using them in Python

import re

# Compile once, reuse
EMAIL_RE = re.compile(r'\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b')
emails = EMAIL_RE.findall(text)

# Replace
cleaned = re.sub(r'<[^>]+>', '', html_text)

# Split on multiple delimiters
tokens = re.split(r'[,;\|\t]', messy_data)

The full 50

These 15 are the ones I use most. The full cookbook has 50 patterns in 10 categories:

Validation (10) — email, URL, phone, IP, UUID, date, card, password, hex, slug
Extraction (10) — URLs, emails, hashtags, mentions, numbers, currency, HTML, markdown, code blocks, versions
Cleaning (10) — strip HTML, collapse whitespace, mask PII, CamelCase convert
Splitting (6) — CSV, multi-delimiter, camelCase, sentences, words
Log parsing (4) — Apache, Python, stack traces, HTTP status
File paths (5) — extensions, Windows, Unix, Docker, Git SHA
Advanced (5) — balanced parens, strings, JSON keys, SQL

Full cookbook: payhip.com/b/q8xTn ($9)

Also available:

Python Automation Toolkit — 10 standalone scripts ($12)
Python Quick Reference Cheat Sheet ($5)
AI Prompt Pack for Developers — 50 prompts for Claude/ChatGPT ($9)

What regex patterns do you reach for most?

10 Python Automation Scripts That Actually Save Time (with code)

Art Baker — Thu, 16 Apr 2026 17:18:33 +0000

Every developer accumulates automation scripts over time. I finally collected my 10 most-reached-for ones, cleaned them up, and want to walk through what they do and how they work.

All are standalone (minimal dependencies), under 100 lines each, and have been used in real projects.

1. Bulk File Renamer

Rename hundreds of files in seconds using regex patterns. Great for photo organizing, log file management, and build artifact cleanup.

import re, pathlib

def bulk_rename(directory, pattern, replacement, dry_run=True):
    path = pathlib.Path(directory)
    renamed = []
    for f in path.iterdir():
        if f.is_file():
            new_name = re.sub(pattern, replacement, f.name)
            if new_name != f.name:
                if not dry_run:
                    f.rename(f.parent / new_name)
                renamed.append((f.name, new_name))
    return renamed

Run with dry_run=True first to preview changes.

2. CSV/Excel Merger

Combines multiple spreadsheets with smart column matching — handles mismatched column orders automatically.

import pandas as pd, glob

def merge_spreadsheets(directory, output_file):
    files = glob.glob(f"{directory}/*.csv") + glob.glob(f"{directory}/*.xlsx")
    dfs = []
    for f in files:
        df = pd.read_csv(f) if f.endswith('.csv') else pd.read_excel(f)
        dfs.append(df)
    merged = pd.concat(dfs, ignore_index=True, sort=False)
    merged.to_csv(output_file, index=False)
    return len(merged)

3. Email Sender with Attachments

Programmatic email via Gmail SMTP. Handles HTML content and multiple attachments.

import smtplib, os
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

def send_email(sender, password, recipient, subject, body, attachments=[]):
    msg = MIMEMultipart()
    msg['From'] = sender
    msg['To'] = recipient
    msg['Subject'] = subject
    msg.attach(MIMEText(body, 'html'))

    for filepath in attachments:
        with open(filepath, 'rb') as f:
            part = MIMEBase('application', 'octet-stream')
            part.set_payload(f.read())
        encoders.encode_base64(part)
        part.add_header('Content-Disposition', f'attachment; filename={os.path.basename(filepath)}')
        msg.attach(part)

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(sender, password)
        server.send_message(msg)

Use an App Password if you have 2FA enabled on Gmail.

4. Web Scraper Template

BeautifulSoup + requests starter with rate limiting and retry logic built in.

import requests, time, random
from bs4 import BeautifulSoup

def scrape_page(url, delay_range=(1, 3)):
    time.sleep(random.uniform(*delay_range))  # Be polite
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}

    for attempt in range(3):
        try:
            resp = requests.get(url, headers=headers, timeout=10)
            resp.raise_for_status()
            return BeautifulSoup(resp.text, 'html.parser')
        except requests.RequestException:
            if attempt == 2:
                raise
            time.sleep(2 ** attempt)

5. PDF Text Extractor

Extract text from PDFs for downstream processing. Handles multi-page documents.

import PyPDF2

def extract_pdf_text(filepath, pages=None):
    with open(filepath, 'rb') as f:
        reader = PyPDF2.PdfReader(f)
        if pages is None:
            pages = range(len(reader.pages))

        text = []
        for page_num in pages:
            text.append(reader.pages[page_num].extract_text())

    return '\n\n'.join(text)

6. Directory Watcher

Trigger custom actions when files are added, modified, or deleted. Uses watchdog.

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import time

class FileHandler(FileSystemEventHandler):
    def on_created(self, event):
        if not event.is_directory:
            print(f"New file: {event.src_path}")
            # processing logic here

def watch_directory(path, handler=None):
    observer = Observer()
    observer.schedule(handler or FileHandler(), path, recursive=False)
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

7. JSON/CSV Converter

Bidirectional conversion with nested JSON flattening — handles deeply nested structures.

import json, csv

def flatten(d, parent_key='', sep='.'):
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten(v, new_key, sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

def json_to_csv(json_file, csv_file):
    with open(json_file) as f:
        data = json.load(f)
    if isinstance(data, dict):
        data = [data]
    flat = [flatten(item) for item in data]
    keys = sorted({k for d in flat for k in d})
    with open(csv_file, 'w', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=keys)
        writer.writeheader()
        writer.writerows(flat)

8. Duplicate File Finder

Finds (and optionally removes) duplicate files using MD5 hashing.

import hashlib, pathlib
from collections import defaultdict

def find_duplicates(directory, remove=False):
    hashes = defaultdict(list)

    for filepath in pathlib.Path(directory).rglob('*'):
        if filepath.is_file():
            md5 = hashlib.md5(filepath.read_bytes()).hexdigest()
            hashes[md5].append(filepath)

    duplicates = {h: paths for h, paths in hashes.items() if len(paths) > 1}

    if remove:
        for paths in duplicates.values():
            for path in paths[1:]:
                path.unlink()

    return duplicates

9. Scheduled Task Runner

Lightweight cron-style scheduler in pure Python.

import schedule, time, threading

def run_scheduler(jobs):
    for j in jobs:
        schedule.every(j['interval']).hours.do(j['fn'])

    while True:
        schedule.run_pending()
        time.sleep(60)

thread = threading.Thread(
    target=run_scheduler,
    args=([{'interval': 1, 'fn': lambda: print('hourly')}],),
    daemon=True
)
thread.start()

10. API Response Cacher

Decorator that caches API responses to disk — avoids repeated calls and rate limit issues.

import json, hashlib, os, time
from functools import wraps

def cache_api(cache_dir='.cache', ttl=3600):
    os.makedirs(cache_dir, exist_ok=True)

    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            key = hashlib.md5(str(args + tuple(kwargs.items())).encode()).hexdigest()
            cache_file = os.path.join(cache_dir, f'{key}.json')

            if os.path.exists(cache_file) and time.time() - os.path.getmtime(cache_file) < ttl:
                with open(cache_file) as f:
                    return json.load(f)

            result = func(*args, **kwargs)
            with open(cache_file, 'w') as f:
                json.dump(result, f)
            return result
        return wrapper
    return decorator

Wrapping up

These are the 10 I reach for most. Each is small and modifiable for your own projects.

I've packaged all 10 with docs and example usage here if you want the ready-to-use versions: payhip.com/b/Zm4lG ($12).

What automation scripts have saved you the most time?