Curio¶
Curio is a coroutine-based library for concurrent Python systems programming. It provides standard programming abstractions such as as tasks, sockets, files, locks, and queues. You’ll find it to be familiar, small, fast, and fun.
Curio is the work of David Beazley (https://www.dabeaz.com), who has been teaching and talking about concurrency related topics for more than 20 years, both as a university professor and as an independent researcher.
Requirements¶
Curio requires Python 3.7 or newer. It has no third-party dependencies and works on both POSIX and Windows.
Documentation¶
- A Tutorial Introduction
- How-To
- How do you write a TCP server?
- How do you write a UDP Server?
- How do you make an outgoing connection?
- How do you write an SSL-enabled server?
- How do you perform a blocking operation?
- How do you perform a CPU intensive operation?
- How do you apply a timeout?
- How can a timeout be applied to a block of statements?
- How do you shield operations from timeouts or cancellation?
- How can tasks communicate?
- How can a task and a thread communicate?
- How can synchronous code set an asynchronous event?
- How do you catch signals?
- How do you run external commands in a subprocess?
- How can you communicate with a subprocess over a pipe?
- How can two different Python interpreters send messages to each other?
- How does a coroutine get its enclosing Task instance?
- How do you use contextvars?
- Reference Manual
- Coroutines
- Basic Execution
- Tasks
- Task Groups
- Time
- Timeouts
- Cancellation Control
- Synchronization Primitives
- Queues
- Universal Synchronizaton
- Blocking Operations and External Work
- I/O Classes
- Networking
- Subprocesses
- Asynchronous Threads
- Scheduler Activations
- Asynchronous Metaprogramming
- Exceptions
- Low-level Traps and Scheduling
- Debugging and Diagnostics
Curio University¶
Curio is based on ideas resulting from more than 12 years of exploration into various facets of Python’s concurrency and coroutine model. Dave has given numerous talks/tutorials on this topic at PyCon and elsewhere. Here is a detailed list of presentations to help you understand how Curio works and some of the system thinking that has gone into it. All of these talks are more general than Curio–you’ll learn a lot about Python concurrency in general.
- Build Your Own Async
- Workshop talk at PyCon India, 2019. This workshop talks about the fundamentals of building a simple async concurrency library from scratch using both callbacks and coroutines.
- Die Threads
- Keynote talk at EuroPython, 2018. Asynchronous programming is most commonly described as an alternative to thread programming. But what if you reinvented thread programming run on top of asynchronous programming? This talk explores this concept. It might be the most “experimental” talk related to Curio.
- The Other Async (Threads + Asyncio = Love)
- Keynote talk at PyGotham, 2017. This talk steps through the thinking and design of building a so-called “Universal Queue” that works with both async programs and threads using a common programming interface.
- Fear and Awaiting in Async
- Keynote talk at PyOhio 2016. A no-holds-barred tour through the possibilities that await programmers who embrace the new async/await syntax in Python. Covers the basics of coroutines, async iteration, async context managers, and a lot of advanced metaprogramming including decorators, descriptors, and metaclasses. Also discusses the importance of API design in async programming.
- Topics of Interest (Async)
- Keynote talk at Python Brasil 2015. Perhaps the first “Curio” talk. A small concurrency library similar to Curio is live-coded and discussed along with other topics related to async.
- Python Concurrency from the Ground Up (LIVE)
- Conference talk at PyCon 2015. This live-coded talk discusses threads, generators, coroutines, the Global Interpreter Lock (GIL), and more.
- Understanding the Python GIL
- Conference talk from PyCon 2010. Understand the inner workings of the infamous Global Interpreter Lock and how it impacts thread performance. See also this related talk from the RuPy 2011 conference.
- A Curious Course on Coroutines and Concurrency [Materials]
- Tutorial at PyCon 2009. Coroutines were first introduced in Python 2.5. This tutorial explores the foundations of using coroutines for various problems in data processing and concurrency. This tutorial gives much of the background that led to the current incarnation of Python coroutines.
- An Introduction to Python Concurrency
- Tutorial at USENIX Technical Conference, 2009. A comprehensive overview of concurrency programming in Python. Includes threads, processes, and event-driven I/O. A good overview of basic programming concepts.