"Kenneth's looking for a gap in the Python ecosystem—something that could become a popular "for humans" library in the style of Requests. The pattern is taking something from the stdlib or existing libraries that's powerful but clunky, and making it elegant and intuitive for everyday use. This is a creative brainstorm where I should think about what's genuinely missing and what would resonate with developers.
I'm considering whether I need to search for the latest library popularity data, but I have solid knowledge of both the stdlib and major ecosystem libraries. My understanding of what's painful to use and what's been successfully "humanized" is strong enough to have a substantive conversation here—Kenneth will appreciate real thinking over surface-level suggestions.
Before I propose anything, I should do a quick sanity check on my candidate ideas to make sure I'm not suggesting something that already shipped in 2024-2025. That's the responsible move.
Let me think through the actual gaps by reasoning about what makes a good "Requests-style" library: the underlying capability exists but the API is hostile or verbose, there's a human mental model that doesn't match the current interface, it's small and focused, and people hit it constantly. I'm brainstorming candidate pain points in the stdlib and ecosystem, starting with datetime and durations—though that space is already well-covered by libraries like pendulum, arrow, and humanize.
Subprocess is another obvious candidate since
subprocess.run is notoriously clunky, and while there are alternatives like sh, plumbum, and delegator, none of them have really "won" yet. Logging is the canonical example of a hostile stdlib API, but loguru has already filled that gap and is extremely popular. Now I'm looking at argparse and CLI tools as the next candidate.
CLI argument parsing is already well-covered by click, typer, and fire. For config files and settings, there are several options like pydantic-settings, dynaconf, and environs, but the space is crowded without a clear winner. File and path operations beyond pathlib is interesting — while pathlib handles basic operations, there's a real gap around atomic writes and high-level file operations like copying and moving, where people often get the os.replace and tempfile dance wrong.
For retries and backoff, tenacity dominates but is verbose, leaving room for something simpler. Caching has multiple solutions (functools.lru_cache, cachetools, diskcache) and is fairly crowded. Parallelism and concurrency for humans is still being evaluated.
Parallelism has a real gap — the boilerplate around ThreadPoolExecutor and ProcessPoolExecutor is tedious for the common case of mapping a function over a list in parallel, though joblib.Parallel and
multiprocessing.Pool.map already address this. Temp files are handled adequately by the stdlib. Email sending, though, is genuinely painful — constructing multipart emails with attachments using smtplib and email.mime requires assembling multiple MIME objects, encoding, and setting headers manually, which feels like a classic opportunity for a "for humans" library.
There are some options like yagmail (popular but Gmail-focused), redmail, and envelopes, but they're either Gmail-centric or less widely adopted, so the pain point isn't decisively solved despite the stdlib being genuinely awful. For reading structured data files generically across formats like JSON, YAML, TOML, and CSV, there's anyconfig and srsly that attempt to address this.
Hashing and checksums used to require manual chunked reading loops, but Python 3.11 added hashlib.file_digest() so that gap has closed. HTTP is well-covered by requests and httpx, progress bars by tqdm, terminal output by rich, and validation by pydantic. Money and currency handling (dealing with Decimal, rounding, and exchange rates) is genuinely tricky and has libraries like py-moneyed and money, while units are handled by pint — these are somewhat niche but do exist.
For parsing human-friendly input like "1.5k" or "3 GB" or "2 hours", humanfriendly with its parse_size and parse_timespanfunctions handles it, and humanize does the reverse conversion. It's covered but humanfriendly is surprisingly underknown. Environment variable management via .env files is straightforward with python-dotenv, and for scheduling there's schedule(which literally markets itself as "Python job scheduling for humans") for simple cases and APScheduler for more complex scenarios.
For visualization, matplotlib, plotly, and seaborn all work well. State machines can be handled with transitions though it's pretty niche. Comparing nested structures is clunky with the standard difflib, but deepdiff fills that gap nicely. Clipboard access is simple with pyperclip, and for notifications across multiple platforms apprise is the clear winner since it can send to nearly all services. Pluralization and English inflection are covered by inflect and humanize, and I'm still working through the remaining categories.
For archives, the standard library has shutil.make_archive and unpack_archive which are solid, plus zipfile and tarfile for more granular control—though there's a small gap when you need to read from an archive without knowing its type upfront, which patool can help with.
Now I'm thinking about the real gaps in the ecosystem. Looking at what causes genuine pain and hasn't been decisively solved yet, email sending stands out as a major one—the standard library's MIME assembly is genuinely painful to work with, and while libraries like yagmail, redmail, and emails exist, none has become the obvious go-to the way requests is for HTTP.
The ideal API would be dead simple: just specify the recipient, subject, body, and any attachments, with SMTP configuration pulled from environment variables. The catch is that email-sending feels like a somewhat solved space, and SMTP itself is becoming less relevant as people migrate to SendGrid, SES, and Resend APIs. But that's actually an argument for a unified wrapper that handles both SMTP and the popular HTTP email services behind a single human-friendly interface—something genuinely missing and useful, though it risks creeping toward being another "apprise for email."
For atomic file writes, the real pain point is correctness: partial writes and crashes mid-operation leave corrupted files behind. The library would be tiny in scope, letting you write data atomically without worrying about half-written files. The objection is that it's niche and experts already know the os.replace pattern, but that's exactly the point—this is for people tired of retyping the same recipe.
Parallel execution is probably the single most common concurrency need: map a function over items, collect results, show progress, and handle errors gracefully. Right now that either means wrestling with concurrent.futures boilerplate or pulling in joblib as a heavy scientific dependency. A minimal library could offer threads by default with an option to switch to processes, returning ordered results with sensible error handling.
tqdm already has thread_map and process_map buried in tqdm.contrib.concurrent, which does almost exactly this, but it's obscure and feels bolted-on. There's real room for a clean, focused standalone alternative.
For subprocess, that's Kenneth Reitz's domain with delegator, so I'll skip it as not novel enough. Config loaders are crowded. The last angle is unifying size and duration parsing—humanize handles output formatting while humanfriendlyhandles input parsing, but they're split across two libraries with different design philosophies.
A single library that does both directions cleanly for sizes, durations, and numbers could win on taste and cohesion, though humanize is already pretty solid. Temp/scratch spaces feel weak. Reading any tabular file with a single call like load("data.csv") is a real niche for scripts—srsly and anyconfig exist but are obscure, though the scope gets fuzzy. Cross-process file locking for humans is another angle, but I'm running into the same pattern: the capability exists somewhere, but there's an opening for something cleaner and more delightful.
Pretty error context is niche. A tiny library answering human questions about the runtime—am I on macOS or Linux, how much RAM, am I in Docker or CI or a venv—would be cute but narrow. Date ranges and iteration are more interesting:
pandas.date_range is heavy, dateutil.rrule is powerful but cryptic, so there's room for something that lets you iterate Mondays in March or days between two dates with a simple, human-friendly API."