gevent/gevent

Features

• Coroutine-Based Asynchronous I/O - Implements an asynchronous I/O system using coroutines to manage high concurrency without the overhead of OS threads.
• Module Monkey Patching - Replaces blocking standard library functions with cooperative versions to enable asynchronous behavior in third-party code.
• Standard Library Monkey Patching - Replaces blocking standard library functions with cooperative versions to enable asynchronous behavior across third-party modules.
• Cooperative Yielding - Pauses the current coroutine for a specified duration or yields control to other tasks to prevent blocking.
• Asynchronous Network Frameworks - Provides a foundational library for building event-driven protocol servers and clients that yield execution during I/O.
• IO Multiplexing - Implements kernel-level IO event notification to monitor multiple file descriptors on a single thread.
• High-Concurrency Networking - Provides a foundation for building TCP, UDP, and HTTP servers that handle thousands of simultaneous connections.
• Network Server Implementations - Provides infrastructure to run asynchronous TCP, UDP, and HTTP servers that handle client requests without blocking.
• Asynchronous UDP Servers - Creates a datagram server to handle connectionless network traffic asynchronously.
• TCP Server Management - Accepts incoming TCP connections and spawns a handler function for each client connection asynchronously.
• Non-Blocking Socket I/O - Interfaces with the event loop to provide non-blocking reading and writing of network sockets.
• I/O Polling - Monitors multiple file descriptors for I/O readiness to pause only the current execution context.
• User-Space Stack Switching - Performs low-level stack switching in user space to yield execution between concurrent coroutines.
• Asynchronous Task Managers - Provides a system to run functions in the background and manage their execution via task handles and callbacks.
• Cooperative Function Replacements - Replaces blocking standard library functions with cooperative versions to enable asynchronous behavior in third-party code.
• Cooperative Multitasking - Implements an execution model where tasks manually yield control during I/O waits to maximize resource utilization.
• Coroutine Lifecycle Management - Spawns, joins, and terminates lightweight threads to retrieve return values or handle execution exceptions.
• Coroutine Local Storages - Stores data unique to the current coroutine to prevent state leakage between concurrent execution paths.
• Execution Yielding & Pausing - Suspends the current execution unit for a specified duration or until the event loop becomes idle.
• Event Loop Backends - Provides a consistent API to wrap various platform-specific polling mechanisms for the event loop.
• Event Loops - Schedules and executes asynchronous tasks while managing the lifecycle and execution order of coroutines.
• Threading API Emulation - Implements a compatible version of the standard threading API using lightweight coroutines to maintain compatibility.
• Asynchronous Task Managers - Coordinates the spawning, synchronization, and termination of lightweight execution units within a single-threaded event loop.
• Coroutine Spawning - Starts new execution units that run specified functions with given arguments and exit upon completion.
• Fiber-Based Concurrent Execution - Uses lightweight pseudo-threads (greenlets) to manage thousands of simultaneous tasks without OS thread overhead.
• Asynchronous Event Loops - Uses single-threaded event loops and coroutines for non-blocking network and disk I/O management.
• HTTP Request Handling - Handles multiple incoming HTTP connections concurrently using lightweight coroutines to prevent request blocking.
• Concurrent Server Base Classes - Provides base classes for TCP, SSL, and WSGI servers that manage multiple concurrent connections.
• WSGI-Based Request Handling - Implements standardized web request processing for Python applications following the WSGI specification.
• Blocking Completion Waits - Blocks execution until one or more lightweight execution units finish their tasks.
• Thread Pool Offloading - Runs blocking or CPU-intensive work in subprocesses and thread pools to keep the main event loop responsive.
• Execution Time Limits - Sets maximum time durations for specific operations to interrupt code that runs longer than expected.
• Graceful Shutdowns - Closes listening sockets upon termination while allowing active connections to complete before exiting.
• DNS Resolution - Provides non-blocking domain name resolution using a thread pool to prevent application stalls.
• Asynchronous UDP Operations - Sends and receives datagrams using non-blocking sockets to prevent I/O operations from halting other tasks.
• Traffic Proxying - Provides tools for routing and forwarding network traffic between clients and servers.
• Unix Domain Socket Support - Exchanges data between processes on the same host using local Unix domain socket files.
• Concurrent Queues - Synchronizes data exchange between concurrent coroutines using multi-producer, multi-consumer queues.
• Subprocess Management Libraries - Provides programmatic control over the execution and lifecycle of external system processes without blocking.
• Blocking I/O Offloading - Integrates with external polling mechanisms to offload blocking I/O and yield control back to the event loop.
• Concurrent Thread Execution - Runs tasks in a dedicated thread pool that bypasses monkey-patching to maintain native OS thread compatibility.
• Coroutine Termination - Stops executing coroutines by raising exceptions within them with optional blocking until termination.
• Inter-Coroutine Communication - Provides low-level mechanisms for passing values, signals, or exceptions between individual coroutines.
• Mutual Exclusion Locks - Prevents multiple concurrent tasks from accessing a shared resource using reentrant locks and binary semaphores.
• Blocking Task Delegation - Offloads synchronous or CPU-bound functions to a native thread pool to prevent event loop stalls.
• Monkey-Patching State Inspection - Verifies if modules have been replaced by cooperative versions and retrieves original standard library implementations.
• Shared Data Synchronization - Synchronizes access to shared data using lock mechanisms with blocking and timeout options.
• SSL/TLS Connection Security - Implements secure transport layers using SSL contexts to encrypt communication between clients and servers.
• Subprocess Command Execution - Runs system commands asynchronously and manages their output to keep the main event loop responsive.
• Concurrency Semaphores - Limits access to shared resources using semaphores to throttle concurrent requests.
• Concurrency Synchronization Primitives - Coordinates access to shared resources using locks and event notifications to prevent data races.
• Concurrent State Coordination - Coordinates execution between concurrent units using events and queues to manage shared state.
• Concurrent Task Runners - Maintains a collection of active coroutines to monitor progress, count running tasks, and verify status.
• Concurrent Task Limiters - Constrains the number of active execution units running at once using a pool to prevent resource exhaustion.
• Concurrent Workload Coordination - Manages the distribution and execution of large volumes of asynchronous tasks and streaming workloads.
• Blocking Detection Tools - Provides tools to detect and alert when a task blocks the event loop for more than a specified threshold.
• Asynchronous File I/O - Provides non-blocking interfaces for binary and text file operations to avoid stalling the execution thread.
• Task Completion Tracking - Monitors the progress of a batch of asynchronous tasks and blocks until all are processed.
• Thread-Local Context Management - Implements thread-local storage to maintain data unique to each concurrent task and avoid explicit parameter passing.
• Concurrent Request Limits - Implements restrictions on the absolute number of simultaneous active requests to prevent resource exhaustion.
• Coroutine State Inspection - Provides capabilities to inspect the execution stacks, spawn hierarchy, and local storage of active coroutines.
• WSGI Application Servers - Implements a WSGI-compliant application server to handle multiple simultaneous HTTP requests asynchronously.
• WSGI Servers - Provides a web server gateway that interfaces between web servers and WSGI-compliant Python applications asynchronously.
• Web Server Hosting - Hosts WSGI-compliant web servers with integrated SSL/TLS encryption for secure client-server communication.
• Asynchronous Programming - Uses coroutines for high-concurrency networking.

Star history