Forem: Art Baker

I Built a Free Developer Tools Bot for Telegram

Art Baker — Sat, 18 Apr 2026 18:58:23 +0000

I got tired of opening browser tabs just to test a regex or format some JSON. So I built a Telegram bot that does it all in-chat.

What It Does

@Devtoolkit26_bot — message it on Telegram and use these commands:

/regex pattern text — Test regex patterns instantly
/json {"key": "value"} — Format and validate JSON
/base64e text — Encode to base64
/base64d encoded — Decode from base64
/wordcount text — Count words, characters, lines, sentences
/hash text — Generate MD5 + SHA256 hashes
/uuid — Generate a random UUID
/timestamp — Current UTC time in multiple formats
/urlencode text — URL encode/decode

Why Telegram?

No context switching — test things without leaving your chat
Works on mobile — useful when you're reviewing code on your phone
Shareable — send it to your team, everyone gets it instantly
Free — 20 uses per day, unlimited with Telegram Stars

How I Built It

Python + python-telegram-bot library. The whole thing is under 300 lines:

from telegram import Update
from telegram.ext import Application, CommandHandler

async def regex_test(update, ctx):
    text = update.message.text.replace("/regex", "", 1).strip()
    parts = text.split(" ", 1)
    pattern, search_text = parts[0], parts[1]
    matches = re.findall(pattern, search_text)
    await update.message.reply_text(f"Matches: {matches}")

app = Application.builder().token(TOKEN).build()
app.add_handler(CommandHandler("regex", regex_test))
app.run_polling()

Each command is a simple function that parses input, does the operation, and returns the result. No database, no external APIs, no hosting costs.

Try It

Open Telegram and search for @Devtoolkit26_bot, or click: https://t.me/Devtoolkit26_bot

Send /start to see all commands.

If you're building Python tools, check out my Python Automation Toolkit — 10 standalone scripts for common dev tasks. Also: Regex Pattern Cookbook with 50 production patterns.

Python File Automation: Rename, Organize, and Process Files in Bulk

Art Baker — Sat, 18 Apr 2026 03:38:48 +0000

If you've ever manually renamed 500 files or sorted a messy Downloads folder, this is for you.

Bulk Rename with Regex

import os, re

def bulk_rename(directory, pattern, replacement):
    renamed = 0
    for filename in os.listdir(directory):
        new_name = re.sub(pattern, replacement, filename)
        if new_name != filename:
            os.rename(
                os.path.join(directory, filename),
                os.path.join(directory, new_name)
            )
            print(f"  {filename} -> {new_name}")
            renamed += 1
    print(f"Renamed {renamed} files")

# Examples:
# Remove spaces: bulk_rename("./photos", r"\s+", "_")
# Add prefix: bulk_rename("./docs", r"^", "2024_")
# Fix extensions: bulk_rename("./data", r"\.jpeg$", ".jpg")

Organize Files by Extension

import shutil
from pathlib import Path

def organize_by_type(directory):
    type_map = {
        "Images": [".jpg", ".jpeg", ".png", ".gif", ".svg"],
        "Documents": [".pdf", ".doc", ".docx", ".txt", ".md"],
        "Data": [".csv", ".json", ".xlsx", ".xml"],
        "Code": [".py", ".js", ".html", ".css"],
    }

    for file in Path(directory).iterdir():
        if file.is_file():
            ext = file.suffix.lower()
            folder = "Other"
            for name, extensions in type_map.items():
                if ext in extensions:
                    folder = name
                    break
            dest = Path(directory) / folder
            dest.mkdir(exist_ok=True)
            shutil.move(str(file), str(dest / file.name))
            print(f"  {file.name} -> {folder}/")

Find and Remove Duplicates

import hashlib
from collections import defaultdict

def find_duplicates(directory):
    hashes = defaultdict(list)
    for root, _, files in os.walk(directory):
        for f in files:
            path = os.path.join(root, f)
            try:
                h = hashlib.md5(open(path, "rb").read()).hexdigest()
                hashes[h].append(path)
            except (PermissionError, OSError):
                continue

    dupes = {h: paths for h, paths in hashes.items() if len(paths) > 1}
    total_saved = 0
    for h, paths in dupes.items():
        size = os.path.getsize(paths[0])
        print(f"  Duplicate ({size/1024:.0f}KB): {len(paths)} copies")
        for p in paths:
            print(f"    {p}")
        total_saved += size * (len(paths) - 1)

    print(f"\nPotential space saved: {total_saved/1024/1024:.1f} MB")
    return dupes

Watch a Folder for New Files

import time

def watch_folder(directory, callback, interval=2):
    seen = set(os.listdir(directory))
    print(f"Watching {directory}...")
    while True:
        current = set(os.listdir(directory))
        new_files = current - seen
        for f in new_files:
            path = os.path.join(directory, f)
            print(f"  New file: {f}")
            callback(path)
        seen = current
        time.sleep(interval)

# Usage: watch_folder("./inbox", lambda f: print(f"Processing {f}"))

These are 4 of the 10 scripts in my Python Automation Toolkit. The full package includes web scraping, email automation, API caching, PDF processing, and a task scheduler.

Each script is under 100 lines, standalone, and well-documented. $12 for the complete set.

How to Build a Web Scraper in Python (Step by Step)

Art Baker — Sat, 18 Apr 2026 03:38:42 +0000

Web scraping is one of the most practical Python skills you can learn. Here's how to build one from scratch.

What You Need

pip install requests beautifulsoup4

Step 1: Fetch the Page

import requests
from bs4 import BeautifulSoup

url = "https://example.com/products"
response = requests.get(url, headers={
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
})
soup = BeautifulSoup(response.text, "html.parser")

Always set a User-Agent. Many sites block requests without one.

Step 2: Find Your Data

Use your browser's DevTools (F12 → Inspect) to identify the HTML structure. Then:

# Find all product cards
products = soup.find_all("div", class_="product-card")

for product in products:
    name = product.find("h2").text.strip()
    price = product.find("span", class_="price").text.strip()
    print(f"{name}: {price}")

Step 3: Handle Pagination

def scrape_all_pages(base_url):
    all_data = []
    page = 1
    while True:
        response = requests.get(f"{base_url}?page={page}")
        soup = BeautifulSoup(response.text, "html.parser")
        items = soup.find_all("div", class_="product-card")
        if not items:
            break
        for item in items:
            all_data.append({
                "name": item.find("h2").text.strip(),
                "price": item.find("span", class_="price").text.strip(),
            })
        page += 1
    return all_data

Step 4: Save to CSV

import csv

data = scrape_all_pages("https://example.com/products")
with open("products.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "price"])
    writer.writeheader()
    writer.writerows(data)

Step 5: Add Error Handling

import time

def safe_request(url, retries=3):
    for attempt in range(retries):
        try:
            r = requests.get(url, timeout=10, headers={
                "User-Agent": "Mozilla/5.0"
            })
            r.raise_for_status()
            return r
        except requests.RequestException as e:
            print(f"Attempt {attempt+1} failed: {e}")
            time.sleep(2 ** attempt)
    return None

Common Pitfalls

Rate limiting — Add time.sleep(1) between requests
Dynamic content — If data loads via JavaScript, use Playwright or Selenium instead
Changing HTML — Your selectors will break when the site updates. Use flexible selectors.
Legal — Check the site's robots.txt and terms of service

Want ready-to-use scraping scripts? My Web Scraping Starter Kit includes 5 production scripts covering tables, pagination, login-protected sites, and API extraction.

Also check out: Python Automation Toolkit — 10 scripts for common dev tasks.

The Regex Patterns I Actually Use in Production

Art Baker — Fri, 17 Apr 2026 20:46:47 +0000

I've been collecting regex patterns for years. Most regex tutorials teach you theory — here are the ones I actually paste into production code.

Email Validation (The Real One)

import re
email_re = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')

Not RFC 5322 compliant (nothing practical is), but catches 99% of valid emails and rejects obvious junk.

URL Extraction

url_re = re.compile(r'https?://[^\s<>"{}|\\^`\[\]]+')
urls = url_re.findall(text)

Phone Numbers (US)

phone_re = re.compile(r'\b(?:\+?1[-.]?)?\(?\d{3}\)?[-.]?\d{3}[-.]?\d{4}\b')

Handles: (555) 123-4567, 555-123-4567, +1.555.123.4567

IP Addresses (v4)

ip_re = re.compile(r'\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b')

Date Extraction (Multiple Formats)

date_re = re.compile(r'\b\d{1,2}[/.-]\d{1,2}[/.-]\d{2,4}\b|\b\d{4}[/.-]\d{2}[/.-]\d{2}\b')

Matches: 12/25/2024, 2024-01-15, 3.14.24

HTML Tag Stripping

strip_tags = re.compile(r'<[^>]+>')
clean = strip_tags.sub('', html_string)

Password Strength Check

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

At least 8 chars, one upper, one lower, one digit, one special.

CSV Line Parser (Handles Quoted Commas)

csv_re = re.compile(r',(?=(?:[^"]*"[^"]*")*[^"]*$)')
fields = csv_re.split(line)

Log Level Extraction

log_re = re.compile(r'\b(DEBUG|INFO|WARNING|ERROR|CRITICAL)\b')

Whitespace Normalizer

normalize = re.compile(r'\s+')
clean = normalize.sub(' ', messy_text).strip()

These are 10 of the 50 patterns in my Regex Pattern Cookbook. The full cookbook covers: data validation, text extraction, log parsing, web scraping selectors, file path manipulation, and code analysis patterns.

Each pattern includes the regex, a plain-English explanation of what it does, and example input/output. $9 for the complete set.

Also check out: Python Automation Toolkit — 10 standalone scripts for common dev tasks.

5 Python Scripts I Use Every Week (And You Can Too)

Art Baker — Fri, 17 Apr 2026 20:46:41 +0000

Every developer has a collection of scripts they reach for constantly. Here are the 5 I run almost daily — each under 100 lines, zero complex dependencies.

1. Bulk File Renamer

When you need to rename hundreds of files following a pattern — CSV exports, image dumps, log files:

import os, re

def bulk_rename(directory, pattern, replacement):
    for f in os.listdir(directory):
        new_name = re.sub(pattern, replacement, f)
        if new_name != f:
            os.rename(
                os.path.join(directory, f),
                os.path.join(directory, new_name)
            )
            print(f"  {f} → {new_name}")

2. CSV Column Merger

Got 5 CSV exports with different column orders? This handles it:

import csv, glob

def merge_csvs(pattern, output):
    all_rows = []
    all_fields = set()
    for f in glob.glob(pattern):
        with open(f) as fh:
            reader = csv.DictReader(fh)
            all_fields.update(reader.fieldnames)
            all_rows.extend(list(reader))
    with open(output, 'w', newline='') as fh:
        writer = csv.DictWriter(fh, fieldnames=sorted(all_fields))
        writer.writeheader()
        writer.writerows(all_rows)

3. Duplicate File Finder

Found 40GB of duplicate backups on a client's server with this:

import hashlib, os
from collections import defaultdict

def find_dupes(directory):
    hashes = defaultdict(list)
    for root, _, files in os.walk(directory):
        for f in files:
            path = os.path.join(root, f)
            h = hashlib.md5(open(path, 'rb').read()).hexdigest()
            hashes[h].append(path)
    return {h: paths for h, paths in hashes.items() if len(paths) > 1}

4. API Response Cacher

Wrap any API call with a TTL cache decorator:

import json, time, os, hashlib

def cached(ttl=3600, cache_dir='.cache'):
    os.makedirs(cache_dir, exist_ok=True)
    def decorator(func):
        def wrapper(*args, **kwargs):
            key = hashlib.md5(str((args, kwargs)).encode()).hexdigest()
            path = os.path.join(cache_dir, f"{key}.json")
            if os.path.exists(path):
                data = json.load(open(path))
                if time.time() - data['ts'] < ttl:
                    return data['result']
            result = func(*args, **kwargs)
            json.dump({'ts': time.time(), 'result': result}, open(path, 'w'))
            return result
        return wrapper
    return decorator

5. Directory Watcher

Monitor a folder and trigger actions on new files:

import time, os

def watch(directory, callback, interval=2):
    seen = set(os.listdir(directory))
    while True:
        current = set(os.listdir(directory))
        new = current - seen
        for f in new:
            callback(os.path.join(directory, f))
        seen = current
        time.sleep(interval)

Get the Full Toolkit

These are 5 of the 10 scripts in my Python Automation Toolkit — the full package includes PDF extraction, JSON/CSV conversion, email sender, web scraper template, and a pure-Python scheduler.

Each script is standalone, commented, and production-tested. $12 for the lot.

Also available: 50 Regex Patterns Cookbook for text processing.

5 Python Scripts That Replaced My Manual Workflows

Art Baker — Fri, 17 Apr 2026 18:52:04 +0000

I used to do these 5 things manually. Now I have scripts for all of them.

1. Bulk File Renaming

Before: rename files one by one in Finder.
After: 3 lines of Python.

import re, pathlib

def bulk_rename(dir, pattern, replacement):
    for f in pathlib.Path(dir).iterdir():
        if f.is_file():
            new = re.sub(pattern, replacement, f.name)
            if new != f.name:
                f.rename(f.parent / new)

2. Merging CSVs

Before: copy-paste between spreadsheets for 30 minutes.
After: one function call.

import pandas as pd, glob

def merge_all(directory):
    files = glob.glob(f"{directory}/*.csv")
    return pd.concat([pd.read_csv(f) for f in files], ignore_index=True)

3. Finding Duplicate Files

Before: manually comparing file sizes and names.
After: MD5 hash every file, group matches.

import hashlib, pathlib
from collections import defaultdict

def find_dupes(dir):
    hashes = defaultdict(list)
    for f in pathlib.Path(dir).rglob('*'):
        if f.is_file():
            hashes[hashlib.md5(f.read_bytes()).hexdigest()].append(f)
    return {h: p for h, p in hashes.items() if len(p) > 1}

4. Caching API Calls

Before: hammering the same API endpoint during development.
After: decorator that caches to disk.

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

def cache_api(ttl=3600):
    os.makedirs('.cache', exist_ok=True)
    def deco(fn):
        @wraps(fn)
        def wrap(*a, **kw):
            key = hashlib.md5(str((a,kw)).encode()).hexdigest()
            path = f'.cache/{key}.json'
            if os.path.exists(path) and time.time() - os.path.getmtime(path) < ttl:
                return json.load(open(path))
            r = fn(*a, **kw)
            json.dump(r, open(path, 'w'))
            return r
        return wrap
    return deco

5. Watching a Folder for New Files

Before: refreshing Finder and manually checking.
After: watchdog triggers a callback.

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

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

observer = Observer()
observer.schedule(Handler(), '/path/to/watch')
observer.start()

All 5 of these (plus 5 more) are in my automation toolkit. Each under 100 lines, standalone, documented.

Free preview (3 scripts): github.com/Devtoolkit26/python-automation-toolkit-lite

Full pack: payhip.com/b/QdBYS ($12)

Also: Regex Cookbook ($9) | AI Prompt Pack ($9) | Cheat Sheet ($5)

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?