30 Claude Prompts That Write Python Code

You are a senior Python engineer who writes clean, reusable API client libraries. <context> I need a self-contained Python module: a reusable REST client class I can import and use, with sessions, retries, and pagination handled for me. </context> <inputs> - API base URL: [URL] - Auth type: [API KEY HEADER / BEARER TOKEN / NONE] - Endpoints I use most: [E.G. GET /users, POST /orders] - Pagination style: [PAGE / CURSOR / LINK HEADER] - Rate limit to respect: [E.G. 60 REQ/MIN] </inputs> <task> Write a client class that wraps a requests.Session, injects auth, exposes get/post/put/delete helpers plus a paginate() generator that yields all items across pages, retries transient errors (429 and 5xx) with exponential backoff, and raises a clear custom exception carrying the response body on failure. Add typed method stubs for the listed endpoints and a short usage example under the main guard. </task> <constraints> - Use requests (pip line) and standard typing; read the API key or token from an environment variable, never hardcoded. - Timeouts on every request; respect the rate limit; log requests at debug level. - Full docstrings, type hints, and comments; PEP 8. </constraints> <format> Return the complete module in one code block, then a note on importing it and adding a new endpoint method. </format>

You are a Python integrations engineer. <context> I need a self-contained Python wrapper around a specific service's API that handles token auth (including refresh) and gives me clean, named methods, runnable with a usage example. </context> <inputs> - Service and base URL: [E.G. INTERNAL BILLING API, URL] - Auth flow: [STATIC TOKEN / OAUTH CLIENT CREDENTIALS WITH REFRESH] - Operations I need: [E.G. LIST INVOICES, CREATE INVOICE, GET CUSTOMER] - Required fields per operation: [DESCRIBE] - Error cases to handle: [E.G. 401 REFRESH, 404 NOT FOUND] </inputs> <task> Write a wrapper class that obtains a token (refreshing automatically on 401 for the client-credentials flow), exposes one clearly named method per operation with typed parameters and return values, validates required fields before sending, and maps API errors to descriptive Python exceptions. Include a runnable example calling one read and one write method. </task> <constraints> - Use requests (pip line); read client id and secret or token from environment variables only. - Cache the token until expiry and refresh transparently; timeouts and retries on transient failures. - Type hints, docstrings, comments on the auth flow; main guard with the example. </constraints> <format> Return the complete module in one code block, then a note on the environment variables and adding another operation. </format>

You are a Python engineer who writes fast, well-behaved concurrent clients. <context> I have many API calls to make and need a self-contained Python script that runs them concurrently but stays under the rate limit, runnable as-is. </context> <inputs> - Endpoint template: [E.G. https://api.example.com/items/{id}] - The list of ids or params: [PATH TO CSV OR INLINE LIST] - Concurrency limit: [E.G. 10 IN FLIGHT] - Rate limit: [E.G. 100 REQ/MIN] - Output path: [JSON LINES / CSV] </inputs> <task> Write a script that reads the inputs, fires requests concurrently with a bounded worker pool, enforces the rate limit with a token-bucket or sliding-window limiter, retries failures with backoff, and streams results to the output file as they complete so a crash does not lose everything. Print a periodic progress count and a final success and failure tally. </task> <constraints> - Use concurrent.futures or asyncio with aiohttp; pick one and justify it in a comment; list any pip deps. - Never exceed the concurrency or rate limit; handle 429 with Retry-After. - Write results incrementally; docstrings, comments on the limiter, main guard. </constraints> <format> Return the full script in one code block, then a note on tuning concurrency versus rate limit and resuming a partial run. </format>

You are a backend Python engineer who builds secure webhook endpoints. <context> I need a self-contained Python webhook receiver (Flask) that verifies signatures, parses the payload, and acts on events, runnable locally for testing. </context> <inputs> - Provider: [E.G. STRIPE / GITHUB / CUSTOM] - Signature scheme: [E.G. HMAC-SHA256 OF BODY WITH SHARED SECRET, HEADER NAME] - Events to handle: [E.G. payment.succeeded, subscription.canceled] - Action per event: [E.G. WRITE TO DB, ENQUEUE JOB, LOG] - Port: [E.G. 5000] </inputs> <task> Write a Flask app with a POST /webhook route that reads the raw body, verifies the HMAC signature in constant time against the shared secret, rejects invalid or replayed requests (timestamp tolerance), routes valid events to a handler function per event type, and returns 200 quickly for accepted events. Include a small helper that generates a valid test signature so I can curl it locally. </task> <constraints> - Use Flask (pip line) and standard hmac and hashlib; read the secret from an environment variable. - Constant-time comparison (hmac.compare_digest); verify BEFORE parsing JSON; reject stale timestamps. - Docstrings, comments on the verification, main guard running the dev server. </constraints> <format> Return the complete app in one code block, then a note on the environment variable, the test curl command, and moving to a production server. </format>

You are a Python data-integration engineer. <context> I need a self-contained Python script that pulls records from an API and syncs them into a local SQLite database, running incrementally so re-runs only fetch what changed. </context> <inputs> - API list endpoint: [URL] - Unique record id field: [E.G. id] - Updated-at field for incremental sync: [E.G. updated_at] - Fields to store: [FIELD: TYPE, ...] - SQLite file path: [PATH] </inputs> <task> Write a script that creates the SQLite table if missing (with the given schema and a primary key), reads the last sync timestamp from a small state table, fetches only records updated since then (paginating as needed), and upserts them into the database in a transaction. Print how many rows were inserted versus updated and store the new high-water mark. Make it safe to run repeatedly. </task> <constraints> - Use requests (pip line) and the standard library sqlite3; parameterized queries only, never string-format SQL. - Upsert with INSERT ... ON CONFLICT; wrap each batch in a transaction; store state so partial runs resume. - Docstrings, comments on the incremental logic, main guard. </constraints> <format> Return the full script in one code block, then a note on scheduling it and adding a new field to the schema. </format>

You are a Python systems engineer who writes safe file-management tools. <context> I need a self-contained Python script that finds duplicate files under a folder by content, not just name, and helps me remove them safely, runnable with a preview mode. </context> <inputs> - Root folder: [PATH] - File types to consider: [ALL / SPECIFIC EXTENSIONS] - What to do with duplicates: [REPORT ONLY / DELETE / HARDLINK / MOVE TO FOLDER] - Which copy to keep: [OLDEST / NEWEST / SHORTEST PATH] - Minimum file size to check: [E.G. 1KB] </inputs> <task> Write a script that walks the tree, groups files first by size then confirms duplicates by hashing (reading in chunks so large files do not blow memory), and reports each duplicate set with the keeper marked. In report mode it only prints; in an action mode it applies the chosen operation, but only after a confirmation prompt or a --yes flag. Print the total space that can be reclaimed. </task> <constraints> - Standard library only (os, pathlib, hashlib, argparse); hash in chunks; skip symlinks. - Destructive actions require --yes or an interactive confirmation; never delete the keeper. - Docstrings, comments on the two-pass hashing, main guard. </constraints> <format> Return the full script in one code block, then a note on running the safe preview first and choosing the keep rule. </format>

You are a Python engineer who builds image-processing utilities with Pillow. <context> I need a self-contained Python script that batch-resizes and converts images in a folder, runnable as-is and non-destructive by default. </context> <inputs> - Source folder: [PATH] - Target size: [E.G. MAX 1200PX LONG EDGE / EXACT 800x800] - Output format: [JPEG / PNG / WEBP] - Quality or compression: [E.G. JPEG 82] - Output folder: [PATH] </inputs> <task> Write a script that finds images in the source folder, resizes each while preserving aspect ratio (or crops to exact size if requested), converts to the target format, strips or preserves EXIF as chosen, and writes to the output folder keeping original filenames with the new extension. Skip non-images, report each file's before-and-after dimensions and size, and print the total space saved. </task> <constraints> - Use Pillow (pip install pillow); never overwrite originals, write to the output folder only. - Handle RGBA-to-JPEG conversion (flatten on white) and EXIF orientation; skip corrupt files with a warning. - Docstrings, comments, main guard; a --dry-run listing planned conversions. </constraints> <format> Return the full script in one code block, then a note on adjusting quality and adding a watermark step later. </format>

You are a Python engineer who builds log-analysis tooling. <context> I need a self-contained Python script that parses a log file and prints a useful summary: error counts, top offenders, and a timeline, runnable in the terminal. </context> <inputs> - Log file path (or glob): [PATH] - Log format: [E.G. COMMON LOG FORMAT / JSON LINES / CUSTOM REGEX] - What to count: [E.G. STATUS CODES, ERROR TYPES, IPs, ENDPOINTS] - Time window: [ALL / LAST N HOURS] - Top-N to show: [E.G. 10] </inputs> <task> Write a script that reads the log (streaming line by line so it handles huge files), parses each line per the format, and prints: total lines, counts by the chosen dimension ranked top-N, error rate over time bucketed by hour, the most frequent endpoints, and a sample of the most common error lines. Handle unparseable lines by counting them separately. </task> <constraints> - Standard library only (re, collections, argparse, gzip for .gz logs); stream, do not load the whole file. - Compile regexes once; never crash on a malformed line, tally it as unparsed. - Docstrings, comments on the parsing regex, main guard. </constraints> <format> Return the full script in one code block, then a note on adapting the regex to your log format and adding a new metric. </format>

You are a Python engineer who builds document-processing utilities. <context> I need a self-contained Python script that merges, splits, and extracts pages from PDFs on the command line, runnable as-is. </context> <inputs> - Mode: [MERGE / SPLIT / EXTRACT PAGES] - Input file(s) or folder: [PATHS] - For split: [EVERY N PAGES / AT SPECIFIC PAGE NUMBERS / ONE FILE PER PAGE] - For extract: [PAGE RANGE, E.G. 3-7] - Output path or folder: [PATH] </inputs> <task> Write a CLI with three subcommands: merge (combine multiple PDFs in the given order into one file), split (break a PDF by the chosen rule), and extract (pull a page range into a new PDF). Preserve bookmarks where possible, validate that inputs exist and are real PDFs, and print what was written. Use argparse subcommands so it reads like a real tool. </task> <constraints> - Use pypdf (pip install pypdf); never overwrite an existing output without a --force flag. - Validate page numbers against the document length with clear errors; skip encrypted PDFs with a warning. - Docstrings, comments, main guard with argparse subcommands. </constraints> <format> Return the full script in one code block, then a note on the exact commands for merge, split, and extract. </format>

You are a Python systems engineer. <context> I need a self-contained Python script that analyzes disk usage under a folder and shows me where the space actually goes, runnable in the terminal like a scriptable du. </context> <inputs> - Root folder: [PATH] - Depth to report: [E.G. TOP 2 LEVELS] - Sort by: [SIZE DESC / FILE COUNT] - Highlight files larger than: [E.G. 100MB] - Output: [CONSOLE TABLE / CSV] </inputs> <task> Write a script that walks the tree, sums sizes per directory (including nested contents), and prints a ranked tree up to the chosen depth with human-readable sizes and each folder's share of the total. Separately list individual files above the size threshold. Handle permission errors gracefully and show the grand total. Optionally export the full breakdown to CSV. </task> <constraints> - Standard library only (os, pathlib, argparse); count each file once; skip symlinks to avoid double counting and loops. - Human-readable sizes (KB/MB/GB); catch and report permission errors without stopping. - Docstrings, comments on the recursive sizing, main guard. </constraints> <format> Return the full script in one code block, then a note on changing the depth and threshold. </format>

You are a Python engineer who builds clean command-line tools. <context> I need a self-contained Python CLI to manage a to-do list from the terminal, with data saved between runs, runnable as-is. </context> <inputs> - Storage: [JSON FILE / SQLITE] - Fields per task: [E.G. TITLE, DUE DATE, PRIORITY, DONE] - Commands I want: [ADD, LIST, DONE, REMOVE, EDIT] - List filters and sorting: [E.G. BY DUE DATE, SHOW ONLY OPEN] - Where to store the file: [PATH, DEFAULT ~/.todos.json] </inputs> <task> Write a CLI using argparse subcommands for each command, persisting tasks to the chosen store between runs. add creates a task, list prints a formatted table with filters and sorting, done marks complete, remove deletes by id, and edit updates fields. Assign stable ids, format the table with aligned columns and a friendly empty state, and confirm each action. </task> <constraints> - Standard library only (argparse, json or sqlite3, pathlib, datetime); create the store on first run. - Validate dates and ids with clear errors; never corrupt the file on a crash, write atomically. - Docstrings, comments, main guard with argparse subcommands. </constraints> <format> Return the complete tool in one code block, then a note on the commands and where data is stored. </format>

You are a Python engineer who builds practical personal-finance tools. <context> I need a self-contained Python CLI to log expenses and see summaries, backed by SQLite, runnable as-is. </context> <inputs> - Fields per expense: [DATE, AMOUNT, CATEGORY, NOTE] - Categories: [E.G. FOOD, TRANSPORT, RENT, FUN] - Reports I want: [MONTHLY TOTAL, BY CATEGORY, BUDGET VS ACTUAL] - Monthly budget per category: [OPTIONAL AMOUNTS] - Database path: [PATH] </inputs> <task> Write a CLI with subcommands: add (log an expense), list (filter by month and category), report (monthly totals, breakdown by category with percentages, and budget-versus-actual if budgets are set), and export (write a CSV). Store data in SQLite with a proper schema, validate amounts and dates, and format money and the report tables clearly. </task> <constraints> - Standard library only (argparse, sqlite3, datetime, csv); parameterized SQL only. - Validate that amount is a positive number and the date parses; friendly errors, no tracebacks for user mistakes. - Docstrings, comments, main guard with argparse subcommands. </constraints> <format> Return the complete tool in one code block, then a note on the commands and setting category budgets. </format>

You are a Python engineer with a security mindset. <context> I need a self-contained Python CLI that generates strong passwords and rates the strength of ones I paste in, runnable as-is. </context> <inputs> - Default length: [E.G. 20] - Character sets: [LOWER, UPPER, DIGITS, SYMBOLS, WHICH ARE ON] - Options: [EXCLUDE AMBIGUOUS CHARS / PASSPHRASE MODE WITH WORDS] - Number to generate at once: [E.G. 5] - Strength rules: [E.G. ENTROPY BITS, COMMON-PASSWORD CHECK] </inputs> <task> Write a CLI with two subcommands: gen (produce N passwords of the given length and character sets, or a word-based passphrase, using a cryptographically secure source) and check (rate a password's strength by estimated entropy, character variety, length, and whether it matches obvious weak patterns, returning a score and specific improvement tips). Never write generated passwords to logs. </task> <constraints> - Use the secrets module for all randomness, never random for passwords; standard library only. - Estimate entropy honestly based on the pool size and length; explain the score. - Docstrings, comments, main guard with argparse subcommands. </constraints> <format> Return the complete tool in one code block, then a note on the commands and adjusting the strength thresholds. </format>

You are a Python engineer who builds small static-content tools. <context> I need a self-contained Python CLI that converts a folder of Markdown notes into styled, standalone HTML pages with an index, runnable as-is. </context> <inputs> - Source folder of .md files: [PATH] - Output folder: [PATH] - Styling: [MINIMAL / DARK / MY OWN CSS FILE] - Extras: [TABLE OF CONTENTS / CODE HIGHLIGHTING / GENERATE INDEX PAGE] - Site title: [TITLE FOR THE INDEX] </inputs> <task> Write a CLI that reads each Markdown file, converts it to HTML, wraps it in a clean responsive template with the chosen styling, and writes one HTML file per note plus an index.html linking them all with titles pulled from each file's first heading. Preserve relative links between notes and copy over referenced images. Print what was generated. </task> <constraints> - Use the markdown package (pip install markdown); everything else standard library. - Self-contained output (inline CSS) so pages work offline; never overwrite the source files. - Docstrings, comments, main guard with argparse. </constraints> <format> Return the complete tool in one code block, then a note on running it and swapping in custom CSS. </format>

You are a Python engineer who builds friendly terminal apps. <context> I need a self-contained Python CLI Pomodoro timer that runs focus and break intervals in the terminal with a live countdown and notifications, runnable as-is. </context> <inputs> - Focus length in minutes: [E.G. 25] - Short break and long break: [E.G. 5 / 15] - Cycles before a long break: [E.G. 4] - Notification style: [TERMINAL BELL / DESKTOP NOTIFICATION / BOTH] - Session log: [APPEND COMPLETED SESSIONS TO A FILE?] </inputs> <task> Write a CLI that runs the Pomodoro cycle: a live-updating single-line countdown for each focus and break interval, a clear banner when switching phases, a bell or desktop notification at each transition, and a session summary at the end. Track completed focus sessions this run and optionally append each to a log file with a timestamp. Exit cleanly on Ctrl+C, printing the summary. </task> <constraints> - Standard library first (time, argparse, datetime); if desktop notifications need a package, list it and degrade gracefully to the terminal bell if unavailable. - The countdown must update in place (carriage return), not spam new lines; clean shutdown on Ctrl+C. - Docstrings, comments, main guard. </constraints> <format> Return the complete tool in one code block, then a note on the commands and enabling desktop notifications. </format>