Functional interface for concurrent futures, including asynchronous I/O.
Futured provides a simple consistent interface for concurrent functional programming in Python. It wraps any callable to return a
concurrent.futures.Future, wraps any async coroutine to return an
asyncio.Future, and provides concurrent iterators and context managers for futures.
Transform any callable into one which runs in a thread or process pool, and returns a future.
from futured import threaded, processed import requests fetch = threaded(requests.Session().get) fetch(url) # return Future fs = (fetch(url + path) for path in paths) threaded.results(fs) # generate results from futures threaded.results(fs, timeout=...) # generate results as completed fetch.map(urls) # generate results in order fetch.map(urls, timeout=...) # generate results as completed fetch.mapzip(urls) # generate (url, result) pairs as completed
Thread and process pool executors may be used as context managers, customized with options, and reused with different callables.
threaded(max_workers=...)(func, ...) processed(max_workers=...)(func, ...)
futured classes have a
waiting context manager which collects results from tasks. Futures can be registered at creation, or appended to the list of tasks.
with threaded.waiting(*fs) as tasks: tasks.append(future) tasks # list of completed results
The same interface works for
from futured import asynced import httpx fetch = asynced(httpx.Client().get) fetch(url) # return coroutine asynced.results(fs) # generate results from futures asynced.results(fs, timeout=...) # generate results as completed fetch.map(urls) # generate results in order fetch.map(urls, timeout=...) # generate results as completed fetch.mapzip(urls) # generate (url, result) pairs as completed
asynced provides utilities for calling coroutines from a synchronous context.
waiting is similar to trio's nursery, but returns results from a synchronous
asynced.run(async_func, ...) # call and run until complete asynced.run(async_gen, ...) # call and run synchronous iterator with asynced.waiting(*fs) as tasks: # concurrent coroutines completed in a block
futured wrappers can be used as decorators, but arguments can also be partially bound.
@threaded def slow(): ... fetch = threaded(requests.Session().get, url) fetch(params=...)
Methods are supported, as well as a
decorated utility for automatically subclassing.
from futured import decorated FutureSession = decorated(requests.Session, request=threaded) # equivalent to class FutureSession(requests.Session): request = threaded(requests.Session.request)
subprocess.Popen to provide a
Future compatible interface.
from futured import futured, command command('ls').result() # return stdout or raises stderr command('ls').pipe('wc') # pipes into next command, or | ('wc',... ) for line in command('ls'): # iterable lines command.coroutine('ls') # return coroutine futured(command, 'ls') # supports `map` interface asynced(command.coroutine, 'ls') # supports `map` interface with timeout
forked allows iteration in separate child processes.
from futured import forked for value in forked(values, max_workers=...): # in a child process # in parent after children have exited
% pip install futured
100% branch coverage.
% pytest [--cov]
- Python >=3.6 required
- Stream completed futures from a pending pool
- Executed functions are context managers
forkedhas optional maximum number of workers
command.coroutinecreates asyncio subprocesses
futured.mapzipgenerates results zipped with arguments
asynced.runsupports asynchronous iterators
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
|Filename, size||File type||Python version||Upload date||Hashes|
|Filename, size futured-1.2-py3-none-any.whl (6.5 kB)||File type Wheel||Python version py3||Upload date||Hashes View|
|Filename, size futured-1.2.tar.gz (8.3 kB)||File type Source||Python version None||Upload date||Hashes View|