DEV Community: German Yamil

Python sqlite3: A Database in One File, No Server Needed

German Yamil — Wed, 03 Jun 2026 13:18:22 +0000

What SQLite Is (and Isn't)

SQLite is a full SQL database stored in a single file. No server, no install, no configuration. It ships with Python.

Good for:

Local data persistence (replacing JSON for complex data)
Development databases before switching to PostgreSQL
Embedded databases in desktop apps, CLI tools, scripts
Read-heavy workloads up to ~100GB

Not for:

High concurrent writes (>10 writers at once)
Multi-server setups
Web apps with heavy traffic

Creating a Database

import sqlite3

# Creates file if it doesn't exist; opens it if it does
conn = sqlite3.connect("myapp.db")

# In-memory database — gone when connection closes
conn = sqlite3.connect(":memory:")

Always close connections (or use context managers):

with sqlite3.connect("myapp.db") as conn:
    # conn auto-commits on success, rolls back on exception
    pass

Creating Tables

import sqlite3

with sqlite3.connect("users.db") as conn:
    conn.execute("""
        CREATE TABLE IF NOT EXISTS users (
            id      INTEGER PRIMARY KEY AUTOINCREMENT,
            name    TEXT    NOT NULL,
            email   TEXT    UNIQUE NOT NULL,
            created TEXT    DEFAULT (datetime('now'))
        )
    """)

IF NOT EXISTS prevents errors on repeated runs.

CRUD Operations

import sqlite3
from datetime import datetime

def add_user(conn: sqlite3.Connection, name: str, email: str) -> int:
    cursor = conn.execute(
        "INSERT INTO users (name, email) VALUES (?, ?)",
        (name, email)
    )
    conn.commit()
    return cursor.lastrowid  # New row's ID

def get_user(conn: sqlite3.Connection, user_id: int) -> dict | None:
    row = conn.execute(
        "SELECT id, name, email, created FROM users WHERE id = ?",
        (user_id,)
    ).fetchone()
    if row is None:
        return None
    return {"id": row[0], "name": row[1], "email": row[2], "created": row[3]}

def update_user(conn: sqlite3.Connection, user_id: int, name: str) -> bool:
    cursor = conn.execute(
        "UPDATE users SET name = ? WHERE id = ?",
        (name, user_id)
    )
    conn.commit()
    return cursor.rowcount > 0  # True if a row was updated

def delete_user(conn: sqlite3.Connection, user_id: int) -> bool:
    cursor = conn.execute("DELETE FROM users WHERE id = ?", (user_id,))
    conn.commit()
    return cursor.rowcount > 0

# Usage
with sqlite3.connect("users.db") as conn:
    conn.execute("""CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL,
        created TEXT DEFAULT (datetime('now'))
    )""")

    uid = add_user(conn, "Alice", "alice@example.com")
    print(add_user(conn, "Bob", "bob@example.com"))    # 2

    print(get_user(conn, 1))  # {'id': 1, 'name': 'Alice', ...}
    update_user(conn, 1, "Alicia")
    print(get_user(conn, 1))  # {'id': 1, 'name': 'Alicia', ...}

NEVER Use String Formatting for Queries

# ❌ SQL INJECTION VULNERABILITY
name = "'; DROP TABLE users; --"
conn.execute(f"SELECT * FROM users WHERE name = '{name}'")

# ✅ Always use parameterized queries
conn.execute("SELECT * FROM users WHERE name = ?", (name,))

The ? placeholder safely escapes the value. Always use it.

Fetching Multiple Rows

def get_all_users(conn: sqlite3.Connection) -> list[dict]:
    rows = conn.execute("SELECT id, name, email FROM users ORDER BY id").fetchall()
    return [{"id": r[0], "name": r[1], "email": r[2]} for r in rows]

def search_users(conn: sqlite3.Connection, query: str) -> list[dict]:
    rows = conn.execute(
        "SELECT id, name, email FROM users WHERE name LIKE ?",
        (f"%{query}%",)
    ).fetchall()
    return [{"id": r[0], "name": r[1], "email": r[2]} for r in rows]

# For large results, iterate instead of fetchall()
for row in conn.execute("SELECT * FROM large_table"):
    process(row)

Row Factory: Get Dicts Instead of Tuples

import sqlite3

def dict_factory(cursor, row):
    return {col[0]: row[idx] for idx, col in enumerate(cursor.description)}

conn = sqlite3.connect("users.db")
conn.row_factory = dict_factory

row = conn.execute("SELECT * FROM users WHERE id = 1").fetchone()
print(row)  # {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'}

Or use the built-in:

conn.row_factory = sqlite3.Row
row = conn.execute("SELECT * FROM users WHERE id = 1").fetchone()
print(row["name"])   # Alice (access by column name)
print(dict(row))     # {'id': 1, 'name': 'Alice', ...}

Transactions

def transfer_points(conn, from_id, to_id, amount):
    try:
        conn.execute("BEGIN")
        conn.execute("UPDATE users SET points = points - ? WHERE id = ?", (amount, from_id))
        conn.execute("UPDATE users SET points = points + ? WHERE id = ?", (amount, to_id))
        conn.commit()
    except Exception:
        conn.rollback()
        raise

The context manager handles this automatically:

with sqlite3.connect("db.db") as conn:
    conn.execute("UPDATE ...")  # Auto-committed or rolled back

Schema Migrations

def init_db(conn: sqlite3.Connection):
    conn.execute("""
        CREATE TABLE IF NOT EXISTS users (
            id    INTEGER PRIMARY KEY AUTOINCREMENT,
            name  TEXT NOT NULL,
            email TEXT UNIQUE NOT NULL
        )
    """)

    # Add column if it doesn't exist (migration)
    columns = [row[1] for row in conn.execute("PRAGMA table_info(users)")]
    if "created" not in columns:
        conn.execute("ALTER TABLE users ADD COLUMN created TEXT DEFAULT (datetime('now'))")

    conn.commit()

When to Switch to PostgreSQL

SQLite	PostgreSQL
Single writer	Multiple concurrent writers
< 100GB	Any size
Local/embedded	Server, networked
No setup needed	Requires server
`sqlite3` (stdlib)	`psycopg2` or `asyncpg`

SQLite first, switch when you need to.

Get the Full Pipeline

This article is part of the Python AI Publishing Pipeline series — a complete system to write, validate, and publish technical ebooks with Python and Claude.

📋 Free checklist: 7 steps to ship a Python ebook — PDF, no email required.

🚀 Full pipeline + source code: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

The Python Automation Stack I Use to Generate Content While I Sleep

German Yamil — Tue, 02 Jun 2026 13:51:13 +0000

I haven't manually published an article in weeks.

This is the stack that does it for me — with real costs, real output numbers, and honest revenue figures.

The Problem I Was Solving

Writing and publishing technical content takes time. If you're consistent, it can build an audience. But "consistent" means showing up every day, and most people — including me — can't do that manually long-term.

So I automated it.

The goal: a system that writes, validates, publishes, and distributes technical Python articles daily, without me touching it. The output feeds an audience. The audience (eventually) buys a product.

The Stack

Claude API (claude-opus-4-5)
  → Generates article drafts from topic definitions
  → ~$0.40 per article at current usage

Dev.to API
  → Publishes articles (free)
  → 46 articles live, 496 total views

Hashnode API
  → Cross-posts with canonical URL (free)
  → 69 articles live (some pre-queue)
  → Dev.to keeps SEO credit

Imgur API (anonymous upload)
  → Cover images generated with Pillow → uploaded (free)
  → 42 covers in the map

launchd (macOS)
  → Fires publish job at 19:00 daily
  → Fires on wake if Mac was sleeping
  → Cost: $0

Gumroad
  → Product listing ($9.99)
  → 10% transaction fee
  → ~$18 per sale

Total monthly cost: ~$12-20 (Claude API, depending on generation volume)

What the Pipeline Actually Does

Every day at 7pm, this runs:

# auto_publish_queue.py — simplified
def cmd_publish_next():
    q = load_queue()
    item = q['pending'][0]

    # 1. Publish to Dev.to
    result = publish_article(item['filename'])
    url = f"https://dev.to{result['path']}"

    # 2. Add UTM tracking to Gumroad links
    add_utm_tracking(result['id'], url)

    # 3. Cross-post to Hashnode (canonical URL = Dev.to)
    crosspost(url, item['filename'])

    # 4. Attach cover image from cover_map.json
    attach_cover(result['id'], item['filename'])

    # 5. Fix stale links in older articles
    patch_stale_links(url, item['filename'])

    # 6. Update queue state
    q['pending'].pop(0)
    q['published'].append({...})
    save_queue(q)

    # 7. Check queue depth — auto-generate if < 7 articles
    if len(q['pending']) < 7:
        auto_extend_queue()  # Uses Claude API

Seven steps, fully automatic, every day.

The Real Numbers (After 3 Months)

Metric	Value
Articles published	48
Total views	496
Avg views/article	10.3
Reactions	3
Hashnode articles	69
API cost (total)	~$35
Sales	0
Time spent daily	~0 min

The honest number: zero sales after three months. The pipeline is working. The conversion isn't there yet.

Why: The content attracts Python beginners (high volume, low purchase intent). The product is for developers who want to automate publishing pipelines (lower volume, higher intent). Fixing that audience mismatch is the current work.

The fix: add buyer-intent articles every 3-4 tutorials. Show developers how the pipeline works, not just how Python works.

The Content Strategy Shift

Original queue (100% tutorial):

1. Python argparse
2. Python pathlib
3. Python logging
...46 more beginner tutorials

Current queue (mixed):

1. Python decorators     (tutorial → SEO)
2. Python error handling (tutorial → SEO)
3. Python os module      (tutorial → SEO)
4. Passive Income for Python Devs  ← buyer-intent
5. Python sets           (tutorial → SEO)
...
7. Python Scripts → Side Income    ← buyer-intent

The tutorials build search traffic. The buyer-intent articles convert. Both are needed.

Auto-Generation When Queue Runs Low

The newest addition: when the queue drops below 7 articles, the system auto-generates new ones using Claude:

# auto_extend_queue.py
def run():
    q = load_queue()
    if len(q['pending']) >= MIN_QUEUE_SIZE:
        return  # Queue healthy, nothing to do

    topics = get_next_topics(q, BATCH_SIZE)

    for topic in topics:
        body = generate_article(topic)  # Claude API call
        filename = filename_from_title(topic['title'])

        with open(filename, 'w') as f:
            f.write(body + GUMROAD_CTA)

        q['pending'].append({"filename": filename, "title": topic['title']})
        save_queue(q)

The queue now self-heals. It never runs empty.

What I'd Do Differently

Start with buyer-intent content. The first 20 articles were about the pipeline itself. They got better views and probably attract more buyers than the beginner tutorials. I should have done more of those from the start.

Add UTM tracking from day one. I added it on article 46. I have no idea which of the first 45 articles has driven traffic to Gumroad.

Use launchd from the start. I used cron for weeks. It skipped jobs when the Mac was sleeping. Switched to launchd — it fires missed jobs on wake. No lost days.

Price higher. $9.99 for a complete automation pipeline might be under-priced. Testing $29.99 next.

The Compounding Effect

Here's what the view graph looks like after 3 months of daily publishing:

Month 1: 350 views from 25 articles (April)
Month 2: 146 views from 23 articles (May, still accumulating)
Month 3: (publishing now)

Each article is a permanent asset. The April articles still get views. The May articles will compound into June. At some point, the daily drip of new traffic hits a threshold where sales become inevitable.

The math: if 2% of visitors buy, I need 50 targeted visitors to get one sale. At current traffic rates, that's about 2-3 weeks of buyer-intent articles hitting the right audience.

The Product

The pipeline itself is the product: Python AI Publishing Pipeline — every script, config file, and setup doc for running this exact system.

If you're building something similar, it saves about 10 hours of build time.

Get the Full Pipeline

Every script, config, and setup doc behind this publishing system.

📋 Free: AI Publishing Checklist — 7 steps, PDF.

🚀 Full pipeline: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

Python click: Build Beautiful CLI Tools in Minutes

German Yamil — Mon, 01 Jun 2026 01:35:29 +0000

click vs argparse

Both build CLI tools. click does it with less code:

# argparse — 12 lines for a simple command
import argparse
parser = argparse.ArgumentParser(description="Say hello")
parser.add_argument("name", help="Your name")
parser.add_argument("--count", type=int, default=1, help="Times to repeat")
args = parser.parse_args()
for _ in range(args.count):
    print(f"Hello, {args.name}!")

# click — same result, cleaner
import click

@click.command()
@click.argument("name")
@click.option("--count", default=1, help="Times to repeat")
def hello(name, count):
    for _ in range(count):
        click.echo(f"Hello, {name}!")

Install: pip install click

Basic Commands

import click

@click.command()
@click.argument("filename")
@click.option("--output", "-o", default="output.txt", help="Output file")
@click.option("--verbose", "-v", is_flag=True, help="Show details")
def process(filename, output, verbose):
    """Process FILENAME and write results to OUTPUT."""
    if verbose:
        click.echo(f"Processing {filename}...")

    # Your logic here
    click.echo(f"Done → {output}")

if __name__ == "__main__":
    process()

Run: python script.py data.csv --output results.txt -v

Auto-generated help:

Usage: script.py [OPTIONS] FILENAME

  Process FILENAME and write results to OUTPUT.

Options:
  -o, --output TEXT  Output file
  -v, --verbose      Show details
  --help             Show this message and exit.

Arguments vs Options

@click.command()
@click.argument("src")              # Required, positional
@click.argument("dst", default=".")  # Optional, positional
@click.option("--force", is_flag=True)  # Optional, named flag
@click.option("--mode", type=click.Choice(["fast", "safe"]), default="safe")
def copy(src, dst, force, mode):
    click.echo(f"Copying {src} → {dst} (mode={mode}, force={force})")

Arguments: positional, usually required
Options: named with --flag, usually optional

Type Validation

@click.command()
@click.option("--count", type=int, default=1)          # Must be integer
@click.option("--ratio", type=float)                   # Must be float
@click.option("--mode", type=click.Choice(["a", "b"])) # Must be one of
@click.option("--file", type=click.Path(exists=True))  # Must exist
@click.option("--out", type=click.Path())              # Path (doesn't check)
@click.option("--range", type=click.IntRange(1, 10))   # Int within range
def process(count, ratio, mode, file, out, range):
    pass

click validates and shows a clear error if the wrong type is provided.

Prompts and Confirmation

@click.command()
@click.option("--name", prompt="Your name", help="Who to greet")
@click.option("--password", prompt=True, hide_input=True, confirmation_prompt=True)
def setup(name, password):
    click.echo(f"Hello, {name}!")

@click.command()
@click.argument("path")
def delete(path):
    click.confirm(f"Delete {path}?", abort=True)  # Stops if user says no
    click.echo(f"Deleted {path}")

Multiple Commands (CLI Groups)

import click

@click.group()
def cli():
    """My project CLI."""
    pass

@cli.command()
@click.argument("name")
def add(name):
    """Add a new item."""
    click.echo(f"Added: {name}")

@cli.command()
def list():
    """List all items."""
    click.echo("item1\nitem2\nitem3")

@cli.command()
@click.argument("name")
def delete(name):
    """Delete an item."""
    click.confirm(f"Delete {name}?", abort=True)
    click.echo(f"Deleted: {name}")

if __name__ == "__main__":
    cli()

Usage:

python cli.py add "my item"
python cli.py list
python cli.py delete "my item"
python cli.py --help

Colors and Formatting

@click.command()
def status():
    click.echo(click.style("✅ Success", fg="green"))
    click.echo(click.style("⚠️  Warning", fg="yellow"))
    click.echo(click.style("❌ Error", fg="red", bold=True))

    # Progress bar
    items = list(range(100))
    with click.progressbar(items, label="Processing") as bar:
        for item in bar:
            process(item)

Passing Context Between Commands

@click.group()
@click.option("--debug", is_flag=True)
@click.pass_context
def cli(ctx, debug):
    ctx.ensure_object(dict)
    ctx.obj["debug"] = debug

@cli.command()
@click.pass_context
def run(ctx):
    if ctx.obj["debug"]:
        click.echo("Debug mode on")
    click.echo("Running...")

Making it Installable

Add to pyproject.toml or setup.py:

[project.scripts]
mytool = "mypackage.cli:cli"

After pip install -e .:

mytool add "item"    # Works globally

When to Use click vs argparse

Scenario	Use
Simple script, no deps	`argparse` (stdlib)
Complex CLI with subcommands	`click`
Beautiful output, progress bars	`click`
Distributable tool	`click`

Get the Full Pipeline

This article is part of the Python AI Publishing Pipeline series — a complete system to write, validate, and publish technical ebooks with Python and Claude.

📋 Free checklist: 7 steps to ship a Python ebook — PDF, no email required.

🚀 Full pipeline + source code: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

Python pytest: Write Tests That Actually Help You

German Yamil — Sat, 30 May 2026 20:21:00 +0000

Why Testing Matters (and Why pytest)

Tests catch bugs before users do. pytest makes writing them fast enough that you'll actually do it.

pip install pytest

Run with: pytest (auto-discovers test_*.py files)

Basic Test Structure

# test_calculator.py

def add(a: int, b: int) -> int:
    return a + b

def test_add_positive():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, -1) == -2

def test_add_zero():
    assert add(0, 5) == 5

Run: pytest test_calculator.py -v

test_calculator.py::test_add_positive PASSED
test_calculator.py::test_add_negative PASSED
test_calculator.py::test_add_zero     PASSED
3 passed in 0.01s

Testing Exceptions

import pytest

def divide(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

def test_divide_by_zero():
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide(10, 0)

def test_divide_normal():
    assert divide(10, 2) == 5.0

Fixtures: Reusable Setup

Fixtures provide test data or objects without repeating setup code:

import pytest

class UserDB:
    def __init__(self):
        self.users = {}

    def add_user(self, name: str, email: str):
        self.users[email] = {"name": name, "email": email}

    def get_user(self, email: str) -> dict | None:
        return self.users.get(email)

@pytest.fixture
def db():
    """Fresh database for each test."""
    return UserDB()

@pytest.fixture
def db_with_user(db):
    """Database pre-loaded with a test user."""
    db.add_user("Alice", "alice@example.com")
    return db

def test_add_user(db):
    db.add_user("Bob", "bob@example.com")
    assert db.get_user("bob@example.com")["name"] == "Bob"

def test_get_existing_user(db_with_user):
    user = db_with_user.get_user("alice@example.com")
    assert user["name"] == "Alice"

def test_get_missing_user(db):
    assert db.get_user("nobody@example.com") is None

Each test gets a fresh db — no state leaks between tests.

Parametrize: Test Multiple Inputs

import pytest

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
    (100, -50, 50),
])
def test_add(a, b, expected):
    assert add(a, b) == expected

One test function, four test cases. pytest runs and reports each separately.

Mocking with monkeypatch

import requests

def get_user_name(user_id: int) -> str:
    r = requests.get(f"https://api.example.com/users/{user_id}")
    return r.json()["name"]

def test_get_user_name(monkeypatch):
    class FakeResponse:
        def json(self):
            return {"name": "Alice", "id": 1}

    def fake_get(url):
        return FakeResponse()

    monkeypatch.setattr(requests, "get", fake_get)

    result = get_user_name(1)
    assert result == "Alice"

The real requests.get never fires — your test runs offline and fast.

Using pytest-mock for Cleaner Mocks

pip install pytest-mock

def test_get_user_name(mocker):
    mock_get = mocker.patch("requests.get")
    mock_get.return_value.json.return_value = {"name": "Alice"}

    result = get_user_name(1)

    assert result == "Alice"
    mock_get.assert_called_once_with("https://api.example.com/users/1")

Test Organization

project/
├── src/
│   └── myapp/
│       ├── __init__.py
│       ├── calculator.py
│       └── users.py
└── tests/
    ├── conftest.py        # Shared fixtures
    ├── test_calculator.py
    └── test_users.py

conftest.py — fixtures available to all test files without importing:

# tests/conftest.py
import pytest
from myapp.users import UserDB

@pytest.fixture
def empty_db():
    return UserDB()

@pytest.fixture
def populated_db(empty_db):
    empty_db.add_user("Alice", "alice@example.com")
    empty_db.add_user("Bob", "bob@example.com")
    return empty_db

Useful pytest Options

pytest                    # Run all tests
pytest -v                 # Verbose output
pytest -k "test_add"      # Run tests matching pattern
pytest --tb=short         # Shorter tracebacks
pytest -x                 # Stop on first failure
pytest --lf               # Run only last-failed tests
pytest -s                 # Show print() output
pytest --cov=src          # Coverage report (needs pytest-cov)

What to Test

Test these:

Happy path (valid inputs, expected output)
Edge cases (empty list, zero, None, empty string)
Error conditions (invalid input raises exception)
Boundary values (min/max for numeric inputs)

Don't test:

Python itself (assert 1 + 1 == 2)
Third-party library internals
Private implementation details that change often

Get the Full Pipeline

This article is part of the Python AI Publishing Pipeline series — a complete system to write, validate, and publish technical ebooks with Python and Claude.

📋 Free checklist: 7 steps to ship a Python ebook — PDF, no email required.

🚀 Full pipeline + source code: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

Python requests: The Complete HTTP Client Guide

German Yamil — Fri, 29 May 2026 12:43:33 +0000

Why requests Over urllib

Python's built-in urllib works but is verbose. requests is what everyone actually uses:

# urllib — verbose
import urllib.request, json
req = urllib.request.Request("https://api.example.com/data",
                              headers={"Authorization": "Bearer token"})
with urllib.request.urlopen(req) as r:
    data = json.loads(r.read().decode())

# requests — clean
import requests
r = requests.get("https://api.example.com/data",
                 headers={"Authorization": "Bearer token"})
data = r.json()

Install: pip install requests

GET Requests

import requests

# Basic GET
r = requests.get("https://jsonplaceholder.typicode.com/posts/1")
print(r.status_code)   # 200
print(r.json())        # {'userId': 1, 'id': 1, 'title': ...}

# With query parameters
r = requests.get(
    "https://jsonplaceholder.typicode.com/posts",
    params={"userId": 1, "_limit": 5}
)
# URL becomes: .../posts?userId=1&_limit=5
posts = r.json()
print(len(posts))  # 5

POST Requests

# Send JSON
r = requests.post(
    "https://jsonplaceholder.typicode.com/posts",
    json={"title": "My Post", "body": "Content here", "userId": 1}
)
print(r.status_code)  # 201
print(r.json())       # {'id': 101, 'title': 'My Post', ...}

# Send form data
r = requests.post(
    "https://example.com/login",
    data={"username": "user", "password": "pass"}
)

# Send raw body
r = requests.post(
    "https://example.com/upload",
    data=b"raw bytes here",
    headers={"Content-Type": "application/octet-stream"}
)

Headers and Authentication

# Custom headers
headers = {
    "Authorization": "Bearer your-token-here",
    "User-Agent": "MyApp/1.0",
    "Accept": "application/json",
}
r = requests.get("https://api.example.com/data", headers=headers)

# Basic auth
r = requests.get(
    "https://api.example.com/protected",
    auth=("username", "password")
)

# API key in header (common pattern)
r = requests.get(
    "https://api.example.com/data",
    headers={"X-API-Key": "your-api-key"}
)

Error Handling

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError

def safe_get(url: str, **kwargs) -> dict | None:
    try:
        r = requests.get(url, timeout=10, **kwargs)
        r.raise_for_status()  # Raises for 4xx, 5xx
        return r.json()
    except Timeout:
        print(f"Request timed out: {url}")
    except ConnectionError:
        print(f"Connection failed: {url}")
    except requests.HTTPError as e:
        print(f"HTTP error {e.response.status_code}: {url}")
    except RequestException as e:
        print(f"Request failed: {e}")
    return None

data = safe_get("https://api.example.com/data")

Sessions: Reuse Connections

Sessions persist headers, cookies, and TCP connections across requests:

import requests

# Without session — new connection each time
r1 = requests.get(url1, headers={"Authorization": "Bearer token"})
r2 = requests.get(url2, headers={"Authorization": "Bearer token"})

# With session — one connection, shared headers
with requests.Session() as s:
    s.headers.update({"Authorization": "Bearer token"})
    r1 = s.get(url1)  # Connection reused
    r2 = s.get(url2)  # Faster

Use sessions when making multiple requests to the same host.

Timeouts

Always set timeouts. Without them, requests can hang forever:

# Timeout after 5 seconds
r = requests.get(url, timeout=5)

# Connect timeout vs read timeout
r = requests.get(url, timeout=(3, 10))
# (connect_timeout, read_timeout)
# Fails if connection takes >3s or response takes >10s

Working with Response Data

r = requests.get("https://jsonplaceholder.typicode.com/posts/1")

r.status_code        # 200
r.ok                 # True (status < 400)
r.headers            # {'Content-Type': 'application/json', ...}
r.text               # Raw string response
r.content            # Raw bytes (for images, files)
r.json()             # Parse JSON → dict/list
r.url                # Final URL (after redirects)
r.elapsed            # Time taken (timedelta)

File Upload

# Upload a file
with open("data.csv", "rb") as f:
    r = requests.post(
        "https://api.example.com/upload",
        files={"file": ("data.csv", f, "text/csv")}
    )

# Upload with additional form fields
with open("image.png", "rb") as f:
    r = requests.post(
        "https://api.example.com/upload",
        files={"image": f},
        data={"title": "My Image"}
    )

Retry Logic

from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retries(
    retries: int = 3,
    backoff_factor: float = 0.3,
) -> requests.Session:
    session = requests.Session()
    retry = Retry(
        total=retries,
        backoff_factor=backoff_factor,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    adapter = HTTPAdapter(max_retries=retry)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    return session

s = create_session_with_retries()
r = s.get("https://api.example.com/data", timeout=10)

Quick Reference

Task	Code
GET	`requests.get(url)`
POST JSON	`requests.post(url, json=data)`
Headers	`requests.get(url, headers={...})`
Auth	`requests.get(url, auth=(user, pass))`
Params	`requests.get(url, params={...})`
Timeout	`requests.get(url, timeout=10)`
Check status	`r.raise_for_status()`
Parse JSON	`r.json()`

Get the Full Pipeline

This article is part of the Python AI Publishing Pipeline series — a complete system to write, validate, and publish technical ebooks with Python and Claude.

📋 Free checklist: 7 steps to ship a Python ebook — PDF, no email required.

🚀 Full pipeline + source code: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

Python asyncio: async/await Without the Confusion

German Yamil — Thu, 28 May 2026 12:00:01 +0000

Why async/await Exists

Regular Python code runs one line at a time. While one line waits for a network request, everything else pauses.

# Synchronous — each request waits for the previous
import requests

urls = ["https://api.example.com/1", "https://api.example.com/2", "https://api.example.com/3"]
for url in urls:
    r = requests.get(url)       # Waits here
    print(r.status_code)        # Then continues

Three requests, three full wait cycles. If each takes 1 second, total time: 3 seconds.

With async:

import asyncio, aiohttp

async def fetch(session, url):
    async with session.get(url) as r:
        return r.status

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

Same three requests. Total time: ~1 second (limited by the slowest request, not the sum).

The Core Concepts

async def — defining a coroutine

async def greet(name: str) -> str:
    return f"Hello, {name}"

# Must be awaited or run with asyncio.run()
result = asyncio.run(greet("world"))
print(result)  # Hello, world

async def creates a coroutine — a function that can pause and resume. Calling it doesn't run it. You need await or asyncio.run().

await — pause until done

import asyncio

async def slow_task():
    await asyncio.sleep(1)  # Pauses here, lets other tasks run
    return "done"

async def main():
    result = await slow_task()
    print(result)

asyncio.run(main())

await says: "pause here and let the event loop do other work while waiting."

asyncio.gather() — run multiple tasks concurrently

async def task(name: str, delay: float) -> str:
    await asyncio.sleep(delay)
    return f"{name} done"

async def main():
    # These run concurrently, not sequentially
    results = await asyncio.gather(
        task("A", 1.0),
        task("B", 0.5),
        task("C", 1.5),
    )
    print(results)
    # ['A done', 'B done', 'C done']
    # Total time: ~1.5s, not 3s

asyncio.run(main())

When to Use async

Use async when:

Making multiple HTTP requests
Reading/writing files concurrently
Handling WebSocket connections
Any I/O-bound work where waiting is the bottleneck

Don't use async when:

Doing CPU-intensive computation (use multiprocessing instead)
Only making one request (adds complexity for no gain)
Working with libraries that don't support async

Practical Example: Fetch Multiple APIs

import asyncio
import aiohttp
from typing import Any

async def fetch_json(session: aiohttp.ClientSession, url: str) -> dict[str, Any]:
    try:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as r:
            r.raise_for_status()
            return await r.json()
    except Exception as e:
        return {"error": str(e), "url": url}

async def fetch_all(urls: list[str]) -> list[dict]:
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_json(session, url) for url in urls]
        return await asyncio.gather(*tasks)

# Usage
urls = [
    "https://jsonplaceholder.typicode.com/posts/1",
    "https://jsonplaceholder.typicode.com/posts/2",
    "https://jsonplaceholder.typicode.com/posts/3",
]

results = asyncio.run(fetch_all(urls))
for r in results:
    print(r.get("title", r.get("error")))

Install aiohttp: pip install aiohttp

Common Mistakes

Mistake 1: Calling async functions without await

async def get_data():
    return "data"

# Wrong — returns a coroutine object, not the value
result = get_data()  # <coroutine object get_data at 0x...>

# Correct
result = asyncio.run(get_data())  # "data"

Mistake 2: Using blocking calls inside async functions

import time, requests

async def bad_example():
    time.sleep(1)           # Blocks the entire event loop!
    r = requests.get(url)   # Also blocking!
    return r.text

# Use asyncio.sleep() and aiohttp.ClientSession() instead

Mistake 3: Mixing sync and async without a bridge

# If you're in a sync context and need to call async:
import asyncio

def sync_function():
    result = asyncio.run(async_function())  # Correct bridge
    return result

async for and async with

Some objects support the async iteration and context manager protocols:

async def process_stream():
    # async with — for async context managers
    async with aiohttp.ClientSession() as session:

        # async for — for async iterables
        async for line in some_async_reader():
            process(line)

Quick Reference

Concept	Use	Notes
`async def`	Define coroutine	Must be awaited
`await`	Pause and yield	Only inside `async def`
`asyncio.run()`	Entry point	Top-level call
`asyncio.gather()`	Concurrent tasks	Returns list of results
`asyncio.sleep()`	Non-blocking wait	Use instead of `time.sleep()`
`asyncio.create_task()`	Background task	Doesn't wait by default

Get the Full Pipeline

This article is part of the Python AI Publishing Pipeline series — a complete system to write, validate, and publish technical ebooks with Python and Claude.

📋 Free checklist: 7 steps to ship a Python ebook — PDF, no email required.

🚀 Full pipeline + source code: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

From Python Script to Your First Digital Product: A Practical Roadmap

German Yamil — Wed, 27 May 2026 20:28:35 +0000

Most Python developers have written scripts that save them hours. Most of those scripts die in a local folder.

Here's how to turn one into a product.

Step 1: Identify the Right Script

Not every script is worth selling. The ones that are share three traits:

It solves a recurring problem. A script you run once isn't a product. A script you run every week — or that someone else runs every day — is infrastructure. Infrastructure has value.

The problem is painful enough to pay to fix. Test this: how long would it take to do this manually? If the answer is "hours," there's a market. If it's "30 seconds," probably not.

The output is clear. "It processes data" is vague. "It converts a folder of Markdown files into a formatted PDF ebook, automatically" is clear. Buyers pay for clear outcomes.

What scripts do you already have?

# Start with an audit — what scripts do you run regularly?
import os
from pathlib import Path

scripts_dir = Path.home() / "scripts"
for f in sorted(scripts_dir.glob("*.py"), key=lambda x: x.stat().st_mtime, reverse=True):
    stat = f.stat()
    print(f"{f.name:<40} modified: {stat.st_mtime:.0f}")

The most recently modified scripts are often the most active — and most valuable.

Step 2: Validate Before Building

Before packaging anything, check if people want it. Three fast validation methods:

Search Dev.to and Reddit. Look for questions about the problem your script solves. If there are posts asking "how do I automate X" or "is there a tool for Y" — that's demand. No posts? The problem might not be widespread enough.

Check Gumroad. Search for similar products. If other people are selling Python tools in this space, the market exists. If nothing comes up, you're either early or the market isn't there.

Ask in communities. Post in r/learnpython or r/Python: "I built a script that does X — anyone else doing this manually?" The responses tell you everything.

My own validation: I searched Dev.to for "python ebook automation" and found dozens of questions about exactly what my pipeline solves. Market confirmed before I wrote a single line of product copy.

Step 3: Package It

A script is not a product. A product is a script plus:

my_tool/
├── README.md           # Setup in 5 minutes
├── requirements.txt    # pip install -r requirements.txt
├── main.py             # The script (clean, documented)
├── config.example.py   # Example config, rename to config.py
├── examples/
│   ├── sample_input/   # Real input examples
│   └── sample_output/  # Expected outputs
└── CHANGELOG.md        # What changed between versions

The README is the most important file. It should answer:

What does this do? (one sentence)
What does it require? (Python version, dependencies)
How do I set it up? (copy-paste commands)
How do I run it? (exact command)
What does the output look like?

If a developer who's never seen your code can set it up in under 10 minutes using only your README, you have a product.

Step 4: Price It

The mistake most developers make: pricing based on time spent building, not value delivered.

Use this formula instead:

Value-based pricing = (time your tool saves per week) × (buyer's hourly rate) × 0.1

Example:

Tool saves 2 hours/week
Buyer is a developer at $50/hr
That's $100/week in saved time
Price at 10% of monthly value: $40/month or $80 one-time

Most one-time Python tools should be priced between $15-49. Under $15 feels low-value. Over $49 needs a stronger pitch.

For documentation and guides (not just the script), $15-29 is the sweet spot.

Step 5: List It

Gumroad is the fastest path to money for solo developers:

Create account at gumroad.com (free)
New Product → Digital Product
Upload the zip file
Set price (enable "pay what you want" with minimum)
Write the product description using your README's first paragraph

The product description should be the problem, not the solution:

❌ "Python script that processes Markdown files"

✅ "You're writing technical content and spending 2 hours per week
    manually formatting and converting it. This script does it
    automatically in 30 seconds."

Step 6: Drive Your First Traffic

You don't need an audience. You need to find where people with the problem already gather.

Dev.to + Hashnode: Write one article about the problem your script solves. End with a link to the product. This is evergreen — the article keeps bringing traffic.

Reddit: Post in the relevant subreddit. Show the script working, share the interesting technical parts, link to the full version. Don't lead with "buy my thing."

The anchor article: Your best marketing asset is a detailed technical article showing exactly how you built the thing. Developers trust builders. A real post with real code, real numbers, and honest results converts better than any ad.

I published one article about the complete architecture of my automation pipeline. It brought more qualified visitors in one day than weeks of tutorial articles.

The Timeline

Realistic expectations for a solo developer:

Week	Goal
1	Script packaged, README written, listed on Gumroad
2	First article published, shared on Reddit
3	5-10 visitors/day from organic search
4-8	First sale
Month 3+	1-3 sales/month from compounding content

The first sale is the hardest. After that, you have social proof ("X people have bought this"), and conversions improve.

What I'm Running Right Now

My product: Python AI Publishing Pipeline — a complete set of Python scripts that automate writing, validating, publishing, and cross-posting technical ebooks.

Current stats: 48 published articles, 496 views, waiting on first sale.

The pipeline itself publishes these articles automatically. It's the product and the marketing engine at the same time.

Get the Full Pipeline

The complete Python AI Publishing Pipeline — scripts, architecture, and setup guide for automating your own content system.

📋 Free: AI Publishing Checklist — 7 steps, PDF, no email required.

🚀 Full pipeline: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

Python enumerate, zip, map, and filter: Loop Upgrades Every Beginner Needs

German Yamil — Sun, 24 May 2026 23:48:12 +0000

If you have been writing for i in range(len(items)): to track index positions, or manually zipping two lists with items[i] inside a loop, you are doing extra work that Python already solved. The builtins enumerate, zip, map, and filter exist precisely to replace those patterns — and once you internalize them, your loops become shorter, more readable, and less error-prone.

🎁 Free: AI Publishing Checklist — 7 steps in Python · Full pipeline: germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99)

Why These Builtins Matter

Python's design philosophy favors expressive, intention-revealing code. The range(len(...)) pattern works, but it forces the reader to mentally reconstruct what you actually want: index plus value, or two lists in lockstep. These builtins make the intent explicit. They also tend to be faster than their manual equivalents because the iteration logic runs at the C layer, not in your Python loop body.

enumerate() — Never Write `i = 0; i += 1` Again

Before:

fruits = ["apple", "banana", "cherry"]
i = 0
for fruit in fruits:
    print(i, fruit)
    i += 1

After:

for i, fruit in enumerate(fruits):
    print(i, fruit)

enumerate wraps any iterable and yields (index, value) tuples. The start parameter lets you control where the count begins — useful when building 1-indexed output for users:

for n, fruit in enumerate(fruits, start=1):
    print(f"{n}. {fruit}")
# 1. apple
# 2. banana
# 3. cherry

Real use case: updating only specific items based on their position, or building a numbered display from a list without a separate counter variable polluting your scope.

zip() — Pair Two Lists Cleanly

Before:

titles = ["Chapter 1", "Chapter 2", "Chapter 3"]
slugs = ["ch-1", "ch-2", "ch-3"]
for i in range(len(titles)):
    print(titles[i], slugs[i])

After:

for title, slug in zip(titles, slugs):
    print(title, slug)

zip stops at the shortest iterable. If your lists can be unequal in length and you need to process all items, use itertools.zip_longest with a fillvalue:

from itertools import zip_longest
for title, slug in zip_longest(titles, slugs, fillvalue="MISSING"):
    print(title, slug)

Unzipping: pass a zipped sequence back through zip with the unpack operator to reverse the operation:

pairs = [("a", 1), ("b", 2), ("c", 3)]
letters, numbers = zip(*pairs)

map() — Apply a Function to Every Item

map(func, iterable) applies func to each element and returns a lazy iterator. It does not build a list until you ask for one.

Before:

prices = [9.99, 14.99, 4.99]
discounted = []
for p in prices:
    discounted.append(round(p * 0.9, 2))

After:

discounted = list(map(lambda p: round(p * 0.9, 2), prices))

Because map is lazy, it is memory-efficient for large sequences — values are computed on demand, not all at once.

When to prefer a list comprehension instead: if the transformation is complex or the lambda becomes hard to read at a glance, a comprehension is clearer:

# Prefer this for readability
discounted = [round(p * 0.9, 2) for p in prices]

Use map when you already have a named function to pass in — map(str, numbers) or map(slugify, titles) reads very naturally.

filter() — Keep Only Matching Items

filter(func, iterable) keeps elements where func returns truthy. Also lazy.

Before:

scores = [82, 45, 91, 67, 55, 78]
passing = []
for s in scores:
    if s >= 60:
        passing.append(s)

After:

passing = list(filter(lambda s: s >= 60, scores))

Again, if the condition is straightforward, a comprehension often wins on readability:

passing = [s for s in scores if s >= 60]

Use filter when the predicate is a named function you want to reuse, or when you are chaining it with map in a pipeline.

Combining Them: Real Chains

These builtins compose cleanly. Here is zip paired with enumerate to track position while iterating paired data:

titles = ["Intro", "Setup", "Usage"]
slugs = ["intro", "setup", "usage"]
for n, (title, slug) in enumerate(zip(titles, slugs), start=1):
    print(f"{n}. {title} → /posts/{slug}")

Here is a map + filter pipeline: normalize titles, then keep only the ones long enough to be meaningful:

raw = ["  hello world  ", "hi", "  python for beginners  ", "ok"]
cleaned = map(str.strip, raw)
meaningful = filter(lambda s: len(s) > 5, cleaned)
print(list(meaningful))
# ['hello world', 'python for beginners']

sorted() with key= — The Most Useful Builtin You Are Underusing

sorted deserves a mention here because its key parameter accepts any callable — which pairs naturally with the patterns above.

articles = [
    {"title": "Python Sets", "views": 1200},
    {"title": "Python zip", "views": 850},
    {"title": "Python map", "views": 3100},
]
by_views = sorted(articles, key=lambda a: a["views"], reverse=True)

You can pass operator.itemgetter("views") instead of the lambda if you prefer avoiding anonymous functions. The key= pattern is far more versatile than writing a custom comparison — it computes a sort value once per element, which is also more efficient.

any() and all() — Short-Circuit Evaluation for Collections

any(iterable) returns True the moment it finds a truthy element and stops. all(iterable) returns False the moment it finds a falsy element and stops. Both accept generators, so they stay lazy.

Before:

errors = ["", "missing slug", "", ""]
has_error = False
for e in errors:
    if e:
        has_error = True
        break

After:

has_error = any(errors)
all_valid = all(len(slug) > 0 for slug in slugs)

These are especially useful for validation checks in publishing pipelines — you want to know if any task failed or if all required fields are present before proceeding.

Real Pipeline Pattern

Here is how all of these come together in a practical scenario — managing an article publishing queue:

articles = [
    {"title": "Python Sets", "slug": "python-sets", "status": "published"},
    {"title": "Python zip", "slug": "python-zip", "status": "draft"},
    {"title": "Python map", "slug": "python-map", "status": "failed"},
    {"title": "Python filter", "slug": "python-filter", "status": "published"},
]

# Pair titles with slugs for published articles only
published = filter(lambda a: a["status"] == "published", articles)
paired = [(a["title"], a["slug"]) for a in published]

# Enumerate the queue for display
for n, (title, slug) in enumerate(paired, start=1):
    print(f"{n}. {title} → /posts/{slug}")

# Check if any tasks failed
failed = any(a["status"] == "failed" for a in articles)
if failed:
    failed_titles = [a["title"] for a in articles if a["status"] == "failed"]
    print(f"Failed: {failed_titles}")

Output:

1. Python Sets → /posts/python-sets
2. Python filter → /posts/python-filter
Failed: ['Python map']

This is the kind of pipeline that would take twice as many lines with manual index tracking and explicit append loops. Every builtin here does exactly one thing and composes cleanly with the others.

Quick Decision Reference

Pattern	Use builtin	Use comprehension
Index + value	`enumerate`	rarely needed
Two lists in sync	`zip`	rarely needed
Transform every item	`map(named_func, ...)`	`map(lambda ...)` — use comp instead
Keep matching items	`filter(named_func, ...)`	`filter(lambda ...)` — use comp instead
Sort by field	`sorted(key=...)`	not applicable
Any/all check	`any()` / `all()`	not applicable

The rule of thumb: if you need a lambda, a list comprehension is usually more readable. If you have a named function, map and filter read well. enumerate, zip, sorted, any, and all are almost always the right choice — no comprehension equivalent exists for them.

If you want to see how these builtins power a real automated publishing workflow, the full pipeline is documented in the AI Book Publishing Pipeline — including the queue manager, slug generator, and status checker built entirely with these patterns.

Python String Methods: The Complete Reference You'll Actually Use

German Yamil — Sat, 23 May 2026 22:08:40 +0000

Strings are everywhere in Python. Every CSV you parse, every API response you process, every user input you validate — it all comes back to text. Python ships with a rich set of built-in string methods, and knowing the right one for the job separates scripts that work from scripts that are a pleasure to maintain.

🎁 Free: AI Publishing Checklist — 7 steps in Python · Full pipeline: germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99)

Strings Are Immutable — What That Means in Practice

Before diving into methods, one concept saves a lot of debugging time: strings in Python are immutable. Every method that appears to "change" a string actually returns a new string. The original is untouched.

name = "  alice  "
name.strip()   # returns "alice"
print(name)    # still "  alice  " — nothing changed in place

The fix is always to reassign:

name = name.strip()
print(name)    # "alice"

Keep this in mind as you work through the methods below. Every one of them follows the same rule.

Cleaning Input: strip(), lstrip(), rstrip()

The most common real-world string problem is extra whitespace. CSVs have trailing spaces. User inputs have newlines. LLM outputs sometimes start with a blank line. The strip family solves all of it.

raw = "  \n  hello world  \n  "

raw.strip()    # "hello world"
raw.lstrip()   # "hello world  \n  "   (left side only)
raw.rstrip()   # "  \n  hello world"   (right side only)

You can also strip specific characters — not just whitespace:

path = "///usr/local/bin///"
path.strip("/")    # "usr/local/bin"

csv_field = '"revenue"'
csv_field.strip('"')   # "revenue"

This is invaluable when cleaning CSV headers exported from spreadsheet software, which often wrap column names in quotation marks.

Case Conversion: upper(), lower(), title(), capitalize(), swapcase()

Case methods are simple but frequently misused. Here is what each one actually does:

text = "hello world from PYTHON"

text.upper()       # "HELLO WORLD FROM PYTHON"
text.lower()       # "hello world from python"
text.title()       # "Hello World From Python"
text.capitalize()  # "Hello world from python"  — only first char
text.swapcase()    # "HELLO WORLD FROM python"

title() is useful for formatting user-supplied names, but watch out — it treats any character after a space as a word boundary, including apostrophes:

"it's a test".title()   # "It'S A Test"  ← probably not what you want

For proper title casing with edge-case handling, consider a dedicated library or a custom function. For most automation work, title() is good enough.

Searching: find(), index(), startswith(), endswith(), in

When you need to know whether a substring exists or where it lives, Python gives you several tools with slightly different behavior:

line = "ERROR: disk quota exceeded"

"ERROR" in line          # True  — simplest check
line.startswith("ERROR") # True  — checks the beginning
line.endswith("exceeded") # True — checks the end

line.find("disk")        # 7   — returns index, or -1 if not found
line.index("disk")       # 7   — same, but raises ValueError if not found

Use in and startswith/endswith for boolean guards. Use find() when you need the position but missing is acceptable. Use index() when a missing substring is a genuine error you want to surface.

# Practical: classify log lines
def classify_log(line):
    if line.startswith("ERROR"):
        return "error"
    elif line.startswith("WARN"):
        return "warning"
    return "info"

startswith() and endswith() both accept a tuple of prefixes/suffixes, which saves nested or chains:

line.startswith(("ERROR", "CRITICAL", "FATAL"))

Splitting and Joining: split(), rsplit(), splitlines(), join()

Split and join are two sides of the same coin. split() breaks a string into a list; join() assembles a list back into a string.

row = "Alice,30,Engineer,New York"
fields = row.split(",")
# ["Alice", "30", "Engineer", "New York"]

# Limit the number of splits
"a:b:c:d".split(":", 2)   # ["a", "b", "c:d"]

# Split from the right
"a:b:c:d".rsplit(":", 1)  # ["a:b:c", "d"]  — useful for file extensions

# Split on newlines (handles \r\n, \n, \r automatically)
text = "line one\nline two\r\nline three"
text.splitlines()   # ["line one", "line two", "line three"]

join() is the correct way to build strings from lists — far more efficient than concatenation in a loop:

parts = ["usr", "local", "bin"]
"/".join(parts)     # "usr/local/bin"

words = ["Hello", "world"]
" ".join(words)     # "Hello world"

# Rebuild a CSV row
",".join(["Alice", "30", "Engineer"])   # "Alice,30,Engineer"

Replacing Text: replace() and translate()

replace() swaps every occurrence of a substring with another string:

text = "the cat sat on the cat mat"
text.replace("cat", "dog")          # "the dog sat on the dog mat"
text.replace("cat", "dog", 1)       # "the dog sat on the cat mat"  — limit to 1

For character-level bulk replacements, translate() paired with str.maketrans() is faster than chained replace() calls:

# Replace multiple characters at once
table = str.maketrans({"á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u"})
"café résumé".translate(table)    # "cafe resume"

# Remove characters (map to None)
remove_table = str.maketrans("", "", "!?.,")
"Hello, world!".translate(remove_table)   # "Hello world"

This pattern is common when normalizing text before feeding it into a search index or slug generator.

Testing String Content: isdigit(), isalpha(), isalnum(), isspace()

The is* methods return True or False and are useful for validation:

"42".isdigit()      # True
"hello".isalpha()   # True
"h3llo".isalnum()   # True  — letters and digits only
"   ".isspace()     # True  — only whitespace
"HELLO".isupper()   # True
"hello".islower()   # True

A common use case: validating CSV fields before type conversion.

def safe_int(value):
    cleaned = value.strip()
    if cleaned.isdigit():
        return int(cleaned)
    return None

Note that isdigit() returns False for floats ("3.14") and negative numbers ("-5"). For those, a try/except around float() or int() is more reliable.

Padding and Alignment: zfill(), ljust(), rjust(), center()

These methods are useful for formatting fixed-width output — log files, CLI tables, zero-padded identifiers:

# Zero-padding numbers
"42".zfill(5)       # "00042"
"1234".zfill(3)     # "1234"  — never truncates

# Alignment with padding character (default: space)
"Alice".ljust(10)          # "Alice     "
"Alice".rjust(10)          # "     Alice"
"Alice".center(11)         # "   Alice   "
"Alice".center(11, "-")    # "---Alice---"

Building a quick formatted report without importing tabulate:

headers = ["Name", "Score", "Grade"]
rows = [("Alice", "95", "A"), ("Bob", "82", "B"), ("Carol", "91", "A")]

print("  ".join(h.ljust(8) for h in headers))
for row in rows:
    print("  ".join(cell.ljust(8) for cell in row))

Real Pipeline Patterns

Here is where string methods combine into something actually useful. Consider a script that reads a Markdown file with YAML frontmatter, cleans LLM-generated content, and builds URL slugs.

import re

def clean_llm_output(text: str) -> str:
    """Strip whitespace, normalize line endings, fix case artifacts."""
    text = text.strip()
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    # Remove double blank lines
    while "\n\n\n" in text:
        text = text.replace("\n\n\n", "\n\n")
    return text

def parse_frontmatter(content: str) -> dict:
    """Extract key: value pairs from YAML frontmatter block."""
    meta = {}
    if not content.startswith("---"):
        return meta
    end = content.find("---", 3)
    if end == -1:
        return meta
    block = content[3:end].strip()
    for line in block.splitlines():
        if ": " in line:
            key, value = line.split(": ", 1)
            meta[key.strip()] = value.strip().strip('"')
    return meta

def build_slug(title: str) -> str:
    """Convert an article title to a URL-safe slug."""
    slug = title.lower()
    # Remove characters that aren't alphanumeric or spaces
    table = str.maketrans("", "", "!?.,:'\"")
    slug = slug.translate(table)
    slug = slug.replace(" ", "-")
    # Collapse multiple dashes
    while "--" in slug:
        slug = slug.replace("--", "-")
    return slug.strip("-")

# Example usage
title = "Python String Methods: The Complete Reference You'll Actually Use"
print(build_slug(title))
# "python-string-methods-the-complete-reference-youll-actually-use"

Each function above uses only the methods covered in this article. No regex required (except for the import that is there but unused — delete it if you like). Real automation scripts are mostly string operations stitched together.

If you want to see these patterns applied to a full publishing pipeline — parsing markdown, formatting output, and automating uploads — the full pipeline guide is at germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99).

Python datetime: Dates, Times, and Timezones Without the Confusion

German Yamil — Fri, 22 May 2026 22:00:03 +0000

If you've ever tried to add a week to today's date, parse a log timestamp, or figure out why two datetimes that look identical won't compare equal — welcome to Python's datetime module. It's powerful, it's in the standard library, and it's more confusing than it needs to be. This guide cuts straight to the 20% of features you'll actually use 80% of the time.

🎁 Free: AI Publishing Checklist — 7 steps in Python · Full pipeline: germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99)

The Three Types: date, time, and datetime

The datetime module exports three main classes, and picking the right one matters.

from datetime import date, time, datetime

# date: year, month, day only — no time component
d = date(2025, 5, 6)
print(d)  # 2025-05-06

# time: hours, minutes, seconds — no date component
t = time(14, 30, 0)
print(t)  # 14:30:00

# datetime: both date AND time — what you'll use most
dt = datetime(2025, 5, 6, 14, 30, 0)
print(dt)  # 2025-05-06 14:30:00

When to use which:

date — scheduling events, birth dates, expiration dates, anything where the time of day is irrelevant
time — storing a recurring time (e.g., "run at 09:00 every day") independent of the date
datetime — log timestamps, scheduling with time precision, anything that combines date and time

In practice, you'll use datetime for 90% of automation work.

Creating Datetimes: now(), today(), and date.today()

from datetime import datetime, date

# Get the current date and time (local time, no timezone info)
now = datetime.now()
print(now)  # 2025-05-06 14:32:17.483921

# Get just today's date
today = date.today()
print(today)  # 2025-05-06

# datetime.today() works too, but datetime.now() is preferred
# (now() accepts a timezone argument; today() does not)

The difference between datetime.now() and datetime.today() is subtle and rarely matters for naive datetimes. Prefer datetime.now() because it can accept a tz argument when you need timezone awareness later.

strftime() — Format a Datetime to String

strftime stands for "string format time." You pass a format string with codes, and it returns a formatted string.

from datetime import datetime

now = datetime(2025, 5, 6, 14, 30, 5)

# ISO 8601 — machine-readable, great for logs and APIs
print(now.strftime("%Y-%m-%dT%H:%M:%S"))    # 2025-05-06T14:30:05

# Human-readable
print(now.strftime("%B %d, %Y at %I:%M %p"))  # May 06, 2025 at 02:30 PM

# Compact date for filenames
print(now.strftime("%Y%m%d"))               # 20250506

Common format codes:
| Code | Meaning | Example |
|------|---------|---------|
| %Y | 4-digit year | 2025 |
| %m | Month (01–12) | 05 |
| %d | Day (01–31) | 06 |
| %H | Hour 24h (00–23) | 14 |
| %M | Minutes (00–59) | 30 |
| %S | Seconds (00–59) | 05 |
| %B | Full month name | May |
| %I | Hour 12h (01–12) | 02 |
| %p | AM or PM | PM |

Tip: Use .isoformat() as a shortcut for ISO 8601 without memorizing the format string:

print(now.isoformat())  # 2025-05-06T14:30:05

strptime() — Parse a String into datetime

strptime is the reverse: string in, datetime out. The p stands for "parse."

from datetime import datetime

# Parse an ISO timestamp from a log file
raw = "2025-05-06T14:30:05"
dt = datetime.strptime(raw, "%Y-%m-%dT%H:%M:%S")
print(type(dt))   # <class 'datetime.datetime'>
print(dt.year)    # 2025

# Parse a human-readable date
raw2 = "May 06, 2025"
dt2 = datetime.strptime(raw2, "%B %d, %Y")
print(dt2)  # 2025-05-06 00:00:00

Common mistake: The format string must exactly match the input string — including separators. "2025/05/06" with the format "%Y-%m-%d" will raise a ValueError. Double-check your separators.

timedelta — Date Arithmetic

timedelta represents a duration. Add it to or subtract it from a datetime to get a new datetime.

from datetime import datetime, timedelta

now = datetime(2025, 5, 6, 14, 30, 0)

# Add 7 days
next_week = now + timedelta(days=7)
print(next_week)  # 2025-05-13 14:30:00

# Subtract 2 hours
two_hours_ago = now - timedelta(hours=2)
print(two_hours_ago)  # 2025-05-06 12:30:00

# Find the difference between two datetimes
start = datetime(2025, 5, 1, 9, 0, 0)
end = datetime(2025, 5, 6, 14, 30, 0)
delta = end - start
print(delta.days)          # 5
print(delta.total_seconds())  # 484200.0

timedelta accepts: weeks, days, hours, minutes, seconds, milliseconds, microseconds.

Comparing Datetimes — Sorting and Filtering

Datetimes support all comparison operators, which makes sorting and filtering straightforward.

from datetime import datetime

dt1 = datetime(2025, 5, 1)
dt2 = datetime(2025, 5, 6)

print(dt1 < dt2)   # True
print(dt1 == dt2)  # False

# Filter a list to events in May 2025
events = [
    datetime(2025, 4, 30),
    datetime(2025, 5, 3),
    datetime(2025, 5, 15),
    datetime(2025, 6, 1),
]

may_start = datetime(2025, 5, 1)
may_end = datetime(2025, 5, 31, 23, 59, 59)

may_events = [e for e in events if may_start <= e <= may_end]
print(may_events)
# [datetime.datetime(2025, 5, 3, 0, 0), datetime.datetime(2025, 5, 15, 0, 0)]

# Sort a list of datetimes
sorted_events = sorted(events)

Timezone-Aware Datetimes with zoneinfo (Python 3.9+)

This is where most beginners hit a wall. By default, datetime.now() returns a naive datetime — no timezone information attached. The moment your code runs on a server in a different timezone, or you compare timestamps from two sources, naive datetimes become a liability.

from datetime import datetime
from zoneinfo import ZoneInfo  # Python 3.9+

# Naive datetime (no timezone — avoid for production logs)
naive = datetime.now()
print(naive.tzinfo)  # None

# Timezone-aware datetime
aware = datetime.now(tz=ZoneInfo("America/New_York"))
print(aware)         # 2025-05-06 14:30:00-04:00
print(aware.tzinfo)  # America/New_York

# Convert between timezones
utc_dt = datetime.now(tz=ZoneInfo("UTC"))
eastern = utc_dt.astimezone(ZoneInfo("America/New_York"))
print(eastern)

The rule: Always use UTC for storage and logging. Convert to local time only for display. Never mix naive and aware datetimes — Python will raise a TypeError if you try to compare them.

# This raises TypeError — don't do this
naive = datetime(2025, 5, 6, 14, 30)
aware = datetime(2025, 5, 6, 14, 30, tzinfo=ZoneInfo("UTC"))
print(naive < aware)  # TypeError: can't compare offset-naive and offset-aware datetimes

Unix Timestamps: timestamp() and fromtimestamp()

A Unix timestamp is a float representing seconds since January 1, 1970 UTC. It's common in APIs, databases, and system logs.

from datetime import datetime
from zoneinfo import ZoneInfo

# datetime → Unix timestamp
dt = datetime(2025, 5, 6, 14, 30, 0, tzinfo=ZoneInfo("UTC"))
ts = dt.timestamp()
print(ts)   # 1746541800.0

# Unix timestamp → datetime (local timezone by default)
dt_back = datetime.fromtimestamp(ts)
print(dt_back)  # local time equivalent

# Better: specify UTC explicitly
dt_utc = datetime.fromtimestamp(ts, tz=ZoneInfo("UTC"))
print(dt_utc)  # 2025-05-06 14:30:00+00:00

Warning: datetime.fromtimestamp() without a tz argument uses your system's local timezone. Always pass tz=ZoneInfo("UTC") to get consistent results across environments.

Real Pipeline Pattern: Logging, Scheduling, and Time-Since-Last-Run

Here's how these pieces fit together in a real automation pipeline — logging timestamps, scheduling daily jobs, and calculating time since last run.

from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
import json
from pathlib import Path

STATE_FILE = Path("pipeline_state.json")
UTC = ZoneInfo("UTC")

def get_now() -> datetime:
    """Always return timezone-aware UTC datetime."""
    return datetime.now(tz=UTC)

def log_run(step: str) -> None:
    """Write a timestamped log entry."""
    ts = get_now().isoformat()
    print(f"[{ts}] {step}")

def save_last_run() -> None:
    """Persist the last run time to disk."""
    STATE_FILE.write_text(json.dumps({"last_run": get_now().isoformat()}))

def should_run_today() -> bool:
    """Return True if the pipeline hasn't run in the last 23 hours."""
    if not STATE_FILE.exists():
        return True
    state = json.loads(STATE_FILE.read_text())
    last_run = datetime.fromisoformat(state["last_run"])
    elapsed = get_now() - last_run
    return elapsed > timedelta(hours=23)

# Usage
if should_run_today():
    log_run("Starting pipeline")
    # ... do work ...
    save_last_run()
    log_run("Pipeline complete")
else:
    log_run("Skipping — already ran today")

Key patterns here:

datetime.fromisoformat() parses the ISO strings you saved with .isoformat() — clean round-trip
Storing last_run as an ISO string in JSON means it's human-readable and portable
All datetimes are UTC-aware so the comparison get_now() - last_run is always valid

If you're building automation pipelines in Python and want a complete publishing workflow — from generating content to scheduling posts and tracking runs — my pipeline guide covers the full stack: germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99).

Python Regex: re Module Patterns That Actually Make Sense

German Yamil — Fri, 22 May 2026 00:00:30 +0000

🎁 Free: Python Publishing Checklist — 7 automation steps · $9.99 pipeline: complete source code, 30-day guarantee.

Regular expressions intimidate most beginners — and honestly, that's fair. A pattern like r'(?P<version>\d+\.\d+\.\d+)' looks like line noise until you know what each piece does. But regex is one of those tools that unlocks whole categories of automation work: log parsing, slug validation, text cleanup at scale. This article walks through the Python re module from the ground up, with concrete examples you'd actually write in a script.

🎁 Free: AI Publishing Checklist — 7 steps in Python · Full pipeline: germy5.gumroad.com/l/xhxkzz (pay what you want, min $9.99)

Why Regex Exists (and When to Reach for It)

Python's string methods — str.find(), str.replace(), str.split() — cover a huge range of tasks. But they break down the moment the pattern isn't fixed.

# str methods: works fine for exact substrings
log_line = "2024-03-15 ERROR app crashed"
if "ERROR" in log_line:
    print("Found error")

# str methods: breaks for variable patterns
# How do you extract ANY date in YYYY-MM-DD format?
# You'd need split + indexing + validation — fragile and verbose

Regex solves this by letting you describe the shape of what you're looking for, not just the exact text. One pattern handles thousands of variants automatically.

re.search() vs re.match() vs re.fullmatch()

This is the most common source of confusion with the re module. All three find patterns — but they look in different places.

re.match() — only checks at the start of the string
re.search() — scans the entire string, returns first match
re.fullmatch() — requires the pattern to match the entire string

import re

text = "App version 2.1.0 deployed"

# match() fails — "version" isn't at position 0
print(re.match(r'\d+\.\d+\.\d+', text))   # None

# search() finds it anywhere
m = re.search(r'\d+\.\d+\.\d+', text)
print(m.group())  # '2.1.0'

# fullmatch() fails — text is more than just a version number
print(re.fullmatch(r'\d+\.\d+\.\d+', text))  # None
print(re.fullmatch(r'\d+\.\d+\.\d+', "2.1.0"))  # Match object

Rule of thumb: use re.search() by default. Switch to re.match() when you know the pattern starts at position zero, and re.fullmatch() for input validation.

re.findall() and re.finditer()

When you need all matches — not just the first — use re.findall() for a list or re.finditer() for an iterator of match objects.

log = """
ERROR 2024-03-15 disk full
INFO  2024-03-16 backup started
ERROR 2024-03-17 network timeout
"""

# findall returns a list of strings
errors = re.findall(r'\d{4}-\d{2}-\d{2}', log)
print(errors)  # ['2024-03-15', '2024-03-16', '2024-03-17']

# finditer returns match objects — useful when you need position info
for m in re.finditer(r'ERROR (\d{4}-\d{2}-\d{2})', log):
    print(f"Error on {m.group(1)} at position {m.start()}")

Use finditer() when you're processing large text and want to avoid building a full list in memory, or when you need .start(), .end(), or .span() metadata.

Basic Patterns: The Building Blocks

You don't need to memorize every metacharacter. These ten cover 80% of real-world use cases:

Pattern	Matches
`.`	Any character except newline
`\d`	Any digit (0–9)
`\w`	Word character (letters, digits, underscore)
`\s`	Whitespace (space, tab, newline)
`*`	Zero or more of the preceding
`+`	One or more of the preceding
`?`	Zero or one (makes preceding optional)
`^`	Start of string (or line with MULTILINE)
`$`	End of string (or line with MULTILINE)
`{n,m}`	Between n and m repetitions

# Matching a log timestamp: YYYY-MM-DD HH:MM:SS
pattern = r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
re.search(pattern, "Event at 2024-03-15 14:22:01 UTC")

Always use raw strings (r'...') for regex patterns. Without the r, Python processes backslashes first, which causes subtle bugs.

Character Classes [] and Negation [^]

Square brackets define a set of characters where any one character can match. A caret inside the brackets negates the set.

# Match any vowel
re.findall(r'[aeiou]', "python regex")  # ['o', 'e', 'e']

# Match any character that is NOT a digit
re.findall(r'[^\d]', "abc123")  # ['a', 'b', 'c']

# Match a slug: lowercase letters, digits, hyphens
slug_pattern = r'[a-z0-9-]+'
re.fullmatch(slug_pattern, "python-regex-guide")  # Match
re.fullmatch(slug_pattern, "Python Regex Guide")  # None

Character classes are especially useful for cleaning user input or validating slugs, usernames, and similar constrained strings.

Groups () and Named Groups (?P...)

Parentheses group part of a pattern and let you extract it with .group() or re.findall(). Named groups make your code self-documenting.

# Unnamed groups — accessed by index
m = re.search(r'(\d{4})-(\d{2})-(\d{2})', "Date: 2024-03-15")
print(m.group(0))  # '2024-03-15' (full match)
print(m.group(1))  # '2024'
print(m.group(2))  # '03'

# Named groups — accessed by name
m = re.search(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
    "Date: 2024-03-15"
)
print(m.group("year"))   # '2024'
print(m.group("month"))  # '03'
print(m.groupdict())     # {'year': '2024', 'month': '03', 'day': '15'}

Named groups pay off quickly when you're returning data from a parsing function — the dictionary is immediately usable without counting group indices.

re.sub() — Substitution and Replacement

re.sub(pattern, replacement, string) is the regex-powered str.replace(). The replacement can reference groups with \1, \2, or named groups with \g<name>.

# Normalize date separators
text = "Dates: 2024/03/15 and 2024.04.20"
normalized = re.sub(r'(\d{4})[/.](\d{2})[/.](\d{2})', r'\1-\2-\3', text)
print(normalized)  # 'Dates: 2024-03-15 and 2024-04-20'

# Redact email addresses in log output
log = "User user@example.com logged in from 192.168.1.1"
safe_log = re.sub(r'[\w.+-]+@[\w-]+\.\w+', '[REDACTED]', log)
print(safe_log)  # 'User [REDACTED] logged in from 192.168.1.1'

# re.sub with a function — dynamic replacements
def double_number(m):
    return str(int(m.group()) * 2)

re.sub(r'\d+', double_number, "port 80 and port 443")
# 'port 160 and port 886'

Compiled Patterns with re.compile()

When you use the same pattern repeatedly — inside a loop, across many files — compile it once and reuse the object.

# Without compile — pattern is re-parsed every iteration
for line in log_lines:
    if re.search(r'\d{4}-\d{2}-\d{2}', line):
        process(line)

# With compile — pattern parsed once
DATE_RE = re.compile(r'\d{4}-\d{2}-\d{2}')
for line in log_lines:
    if DATE_RE.search(line):
        process(line)

The compiled object has the same methods: .search(), .match(), .findall(), .sub(). The performance difference matters at scale; for a one-off match it's negligible. A good pattern is to define compiled regexes at module level as constants.

Flags: IGNORECASE, MULTILINE, DOTALL

Flags modify how patterns interpret the text.

# re.IGNORECASE — case-insensitive matching
re.findall(r'error', "Error: FATAL ERROR occurred", re.IGNORECASE)
# ['Error', 'ERROR']

# re.MULTILINE — ^ and $ match start/end of each LINE
text = "first line\nsecond line\nthird line"
re.findall(r'^\w+', text, re.MULTILINE)
# ['first', 'second', 'third']

# re.DOTALL — . matches newline too
html = "<div>\nsome text\n</div>"
re.search(r'<div>(.*)</div>', html, re.DOTALL).group(1)
# '\nsome text\n'

# Combine flags with |
re.findall(r'^error', text, re.IGNORECASE | re.MULTILINE)

You can also embed flags inline in the pattern with (?i), (?m), (?s) — useful when passing patterns as strings to functions that don't expose a flags argument.

Real Pipeline Patterns

Here's where everything comes together. These are patterns you'd use in actual automation scripts.

Parse Dev.to article slugs from a markdown file:

# Before: str methods — brittle, breaks on query params or anchors
url = "https://dev.to/username/my-article-slug-abc123"
slug = url.split("/")[-1]  # fragile if URL has trailing slash or params

# After: regex — handles variations cleanly
DEVTO_RE = re.compile(r'dev\.to/[\w-]+/([\w-]+)')
m = DEVTO_RE.search(url)
slug = m.group(1) if m else None  # 'my-article-slug-abc123'

Validate email format:

EMAIL_RE = re.compile(r'^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$')

def is_valid_email(email):
    return bool(EMAIL_RE.fullmatch(email.strip()))

print(is_valid_email("user@example.com"))    # True
print(is_valid_email("not-an-email"))        # False
print(is_valid_email("user@.com"))           # False

Extract version numbers from deployment logs:

VERSION_RE = re.compile(r'v?(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)')

def extract_versions(log_text):
    return [m.groupdict() for m in VERSION_RE.finditer(log_text)]

log = "Deployed v2.1.0, rollback from 1.9.12 available"
print(extract_versions(log))
# [{'major': '2', 'minor': '1', 'patch': '0'},
#  {'major': '1', 'minor': '9', 'patch': '12'}]

These patterns are reusable, testable, and readable — especially with named groups and compiled constants.

If you're building automation scripts and pipelines in Python, the full pipeline guide at germy5.gumroad.com/l/xhxkzz covers how to chain regex parsing with file I/O, API calls, and structured output in a complete workflow.

How to Turn Your Python Scripts Into a Side Income Stream

German Yamil — Tue, 19 May 2026 23:50:05 +0000

🎁 Free: Python Publishing Checklist — 7 automation steps · $9.99 pipeline: complete source code, 30-day guarantee.

You've written Python scripts that solve real problems. Someone else has the same problem and would pay to have it solved.

That gap is where side income lives.

Here's the playbook — from script to product to sale.

What Makes a Python Script Worth Selling

Not every script is a product. The ones that sell share a few properties:

Saves meaningful time. Scripts that save 30 minutes a day are worth $30-50/month to the right buyer. Scripts that save 2 hours a week are worth $100+/month.

Solves a recurring problem. One-time scripts are curiosities. Scripts that run daily or weekly are infrastructure.

Works without deep Python knowledge. Buyers aren't always developers. A script with a clean CLI or GUI reaches more buyers than one that requires editing source code.

Three Packaging Models

1. Sell the Script (One-time, $10-50)

The simplest model. Package your script as a download with documentation.

product/
├── main.py          # The script
├── README.md        # Setup + usage
├── requirements.txt # Dependencies
└── examples/        # Sample inputs/outputs

Best for: utility scripts, data processing tools, automation helpers.

2. Sell Documentation (One-time, $15-30)

Sometimes the value isn't the code — it's knowing how to build the system. A detailed guide with working examples sells to developers who want to learn, not just copy.

This is the model I use. The Python AI Publishing Pipeline sells the architecture and scripts behind a content automation system. Buyers aren't just getting code — they're getting a system design they can adapt.

3. Sell Access (Recurring, $5-20/month)

Wrap your script in a simple web API or SaaS interface. Higher build cost, recurring revenue.

Best for: scripts with ongoing maintenance, data that changes, or high-frequency use cases.

Finding Buyers

The order matters:

1. Communities first. Post in subreddits where your target buyers hang out:

r/learnpython, r/Python, r/programming (developers)
r/freelance, r/entrepreneur (business buyers)
Topic-specific subs (r/SEO for content tools, r/datascience for data scripts)

2. Dev.to and Hashnode. Write about the problem your script solves. Include the product at the end. This is the content marketing play — slower, but compounds.

3. X (Twitter) and LinkedIn. Build-in-public posts showing the script working get attention. Short videos of the output convert better than text.

What Actually Converts

After 45 articles and tracking what readers click:

Works well:

Showing real output (actual terminal output, actual numbers)
Before/after comparisons ("3 hours manually → 4 seconds automated")
Honest failure stories ("here's where my first version broke")

Works poorly:

Generic claims ("this will save you tons of time")
Long preambles before the actual code
Paywalled demos

The pattern that converts: solve a small problem in the article for free, then offer the complete system for $20.

A Python Script Worth Selling: Real Example

Here's the core of my publish queue — the script that runs every day and handles article publishing, cross-posting, and link patching:

def cmd_publish_next():
    q = load_queue()
    if not q['pending']:
        return  # Nothing to publish today

    next_item = q['pending'][0]
    filepath = os.path.join(MARKETING_DIR, next_item['filename'])

    # Publish to Dev.to
    result = publish_article(filepath)
    url = f"https://dev.to{result['path']}"

    # Cross-post everywhere
    crosspost(url, next_item['filename'])      # Hashnode
    attach_cover(result['id'], next_item['filename'])  # Cover image
    patch_stale_links(url, next_item['filename'])      # Fix old articles

    # Update queue state
    q['pending'].pop(0)
    q['published'].append({
        "filename": next_item['filename'],
        "date": str(date.today()),
        "url": url,
        "id": result['id'],
    })
    save_queue(q)

This runs at 10am every day. I haven't touched it in weeks. It's published 45 articles.

That's the kind of system worth productizing.

The Math

Price:     $9.99/sale
Platform:  Gumroad (~10% fee) → ~$18/sale
Goal:      $500/month passive
Sales needed: 28 sales/month (~1/day)

Traffic needed (at 1% conversion): 2,800 visitors/month
Articles needed (at 60 views/article): ~47 articles
Time to get there: ~6 months of daily publishing

It's not fast. But it's automatic once the system is running.

Starting This Week

Pick the script. What have you built that saves you time? Start there.
Document it. Write a README that a non-Python developer could follow.
Price it. Start at $15-20 for scripts, $19-29 for guides with architecture.
List it. Gumroad is the easiest — free account, 10% transaction fee, instant setup.
Write one article. Show the problem the script solves. Add the Gumroad link at the end.

The first sale will take longer than you expect. The tenth sale will come faster than you think.

Get the Complete System

The Python AI Publishing Pipeline — the scripts, architecture, and setup guide behind this content system.

📋 Free: AI Publishing Checklist — 7 steps to ship a Python ebook, PDF, no email required.

🚀 Full pipeline: germy5.gumroad.com/l/xhxkzz — $9.99, 30-day money-back guarantee.

If this was useful, the ❤️ button helps other developers find it.

Building a Python content pipeline? I sell the complete automation system as a one-time download — Dev.to API, Claude API, launchd, Gumroad. Check it out ($9.99)

DEV Community: German Yamil

Python sqlite3: A Database in One File, No Server Needed

What SQLite Is (and Isn't)

Creating a Database

Creating Tables

CRUD Operations

NEVER Use String Formatting for Queries

Fetching Multiple Rows

Row Factory: Get Dicts Instead of Tuples

Transactions

Schema Migrations

When to Switch to PostgreSQL

Further Reading

Get the Full Pipeline

The Python Automation Stack I Use to Generate Content While I Sleep

The Problem I Was Solving

The Stack

What the Pipeline Actually Does

The Real Numbers (After 3 Months)

The Content Strategy Shift

Auto-Generation When Queue Runs Low

What I'd Do Differently

The Compounding Effect

The Product

Further Reading

Get the Full Pipeline

Python click: Build Beautiful CLI Tools in Minutes

click vs argparse

Basic Commands

Arguments vs Options

Type Validation

Prompts and Confirmation

Multiple Commands (CLI Groups)

Colors and Formatting

Passing Context Between Commands

Making it Installable

When to Use click vs argparse

Further Reading

Get the Full Pipeline

Python pytest: Write Tests That Actually Help You

Why Testing Matters (and Why pytest)

Basic Test Structure

Testing Exceptions

Fixtures: Reusable Setup

Parametrize: Test Multiple Inputs

Mocking with monkeypatch

Using pytest-mock for Cleaner Mocks

Test Organization

Useful pytest Options

What to Test

Further Reading

Get the Full Pipeline

Python requests: The Complete HTTP Client Guide

Why requests Over urllib

GET Requests

POST Requests

Headers and Authentication

Error Handling

Sessions: Reuse Connections

Timeouts

Working with Response Data

File Upload

Retry Logic

Quick Reference

Further Reading

Get the Full Pipeline

Python asyncio: async/await Without the Confusion

Why async/await Exists

The Core Concepts

async def — defining a coroutine

await — pause until done

asyncio.gather() — run multiple tasks concurrently

When to Use async

Practical Example: Fetch Multiple APIs

Common Mistakes

Mistake 1: Calling async functions without await

Mistake 2: Using blocking calls inside async functions

Mistake 3: Mixing sync and async without a bridge

async for and async with

Quick Reference

enumerate() — Never Write `i = 0; i += 1` Again