sniffio

Sniffio solves one problem exceptionally well: detecting which async library (asyncio, trio, curio) your code is currently running under. The entire API is essentially one function—`current_async_library()`—which returns a string identifier. This simplicity is its greatest strength from a security perspective.

In practice, this library introduces virtually zero attack surface. It has no dependencies, performs no network operations, handles no user input, and doesn't touch cryptography. The detection mechanism relies on inspecting stack frames and thread-local state, which is deterministic and side-effect free. Error handling is straightforward: it raises `AsyncLibraryNotFoundError` when not running under a recognized async context, making it easy to handle edge cases without information leakage.

From a supply chain perspective, this is as low-risk as dependencies get. The codebase is under 200 lines, making auditing trivial. It's a foundational utility used by major async libraries like AnyIO and httpx for compatibility layers, so it receives regular maintenance despite its simplicity.

Sniffio is a micro-library with a singular purpose: detect whether your code is running under asyncio, trio, curio, or another async framework. In practice, it's remarkably straightforward—you call `sniffio.current_async_library()` and get back a string like 'asyncio' or 'trio'. That's essentially the entire API surface, and it works reliably.

The library shines in its simplicity and type hint support. IDE autocompletion works perfectly, and the single function signature is immediately clear. Error handling is predictable: it raises `sniffio.AsyncLibraryNotFoundError` when called outside an async context, making it easy to catch and handle appropriately.

The main limitation is that it's really only useful for library authors who need to write async-framework-agnostic code. Application developers rarely need this—you typically know which framework you're using. Documentation is minimal but sufficient given the narrow scope. The package has remained stable for years with infrequent updates, which is actually a good sign for such a focused utility.

In production environments where you're building async libraries that need to work across asyncio, trio, and curio, sniffio does exactly one thing perfectly: tells you which event loop you're running under. The entire API is literally one function - `sniffio.current_async_library()` - which returns a string like 'asyncio' or 'trio'. Zero configuration, zero complexity.

From an operations perspective, this is refreshingly bulletproof. No connection pools to manage, no timeouts to tune, no retry logic needed. It's pure runtime introspection with negligible memory footprint and effectively zero performance impact. The library uses thread-local state detection, so it works correctly even with multiple event loops in different threads. Error handling is straightforward: raises `sniffio.AsyncLibraryNotFoundError` if called outside an async context, which is exactly what you want for fast failure.

The main limitation is narrow scope - if you need more sophisticated async compatibility layers, you'll need additional tooling. But for its intended purpose of runtime detection in cross-compatible async libraries, it's the de facto standard and has remained stable across versions with no breaking changes in years.