Skip to content
Small utility library for coroutine-driven asynchronous generic programming in Python +3.4
Branch: master
Clone or download
h2non Merge pull request #43 from dylanjw/fix_doc_typo
Fix typo in doc reference link: series, not searies
Latest commit 1e5ef4d Oct 24, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
docs Fix typo: series, not searies Oct 23, 2018
examples fix(examples): minor linter issues Oct 21, 2017
paco Bump version: 0.2.2 → 0.2.3 Oct 23, 2018
tests
.editorconfig
.gitignore feat(version): pre-release changes Nov 29, 2016
.travis.yml fix(setup): use space based indentation Mar 21, 2018
History.rst feat(history): add changes Oct 23, 2018
LICENSE feat(LICENSE): update copyright year May 28, 2017
MANIFEST.in fix(#15): pip installation, add manifest Oct 25, 2016
Makefile fix(examples): ignore examples linting in Python 3.4 Oct 22, 2017
README.rst
requirements-dev.txt feat(package): add wheel package distribution Jan 6, 2017
setup.py fix(setup): use space based indentation Mar 21, 2018
tox.ini refactor(name): use paco Oct 24, 2016

README.rst

paco Build Status PyPI Coverage Status Documentation Status Stability Quality Versions

Small and idiomatic utility library for coroutine-driven asynchronous generic programming in Python +3.4.

Built on top of asyncio, paco provides missing capabilities from Python stdlib in order to write asynchronous cooperative multitasking in a nice-ish way. Also, paco aims to port some of functools and itertools standard functions to the asynchronous world.

paco can be your utility belt to deal with asynchronous, I/O-bound, non-blocking concurrent code in a cleaner and idiomatic way.

Features

  • Simple and idiomatic API, extending Python stdlib with async coroutines gotchas.
  • Built-in configurable control-flow concurrency support (throttle).
  • No fancy abstractions: it just works with the plain asynchronous coroutines.
  • Useful iterables, decorators, functors and convenient helpers.
  • Coroutine-based functional helpers: compose, throttle, partial, timeout, times, until, race...
  • Asynchronous coroutines port of Python built-in functions: filter, map, dropwhile, filterfalse, reduce...
  • Supports asynchronous iterables and generators (PEP0525)
  • Concurrent iterables and higher-order functions.
  • Better asyncio.gather() and asyncio.wait() with optional concurrency control and ordered results.
  • Works with both async/await and yield from coroutines syntax.
  • Reliable coroutine timeout limit handler via context manager.
  • Designed for intensive I/O bound concurrent non-blocking tasks.
  • Good interoperability with asyncio and Python stdlib functions.
  • Composable pipelines of functors via | operator overloading.
  • Small and dependency free.
  • Compatible with Python +3.4.

Installation

Using pip package manager:

pip install --upgrade paco

Or install the latest sources from Github:

pip install -e git+git://github.com/h2non/paco.git#egg=paco

API

Examples

Asynchronously and concurrently execute multiple HTTP requests.

import paco
import aiohttp

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as res:
            return res

async def fetch_urls():
    urls = [
        'https://www.google.com',
        'https://www.yahoo.com',
        'https://www.bing.com',
        'https://www.baidu.com',
        'https://duckduckgo.com',
    ]

    # Map concurrent executor with concurrent limit of 3
    responses = await paco.map(fetch, urls, limit=3)

    for res in responses:
        print('Status:', res.status)

# Run in event loop
paco.run(fetch_urls())

Concurrent pipeline-style composition of transform functors over an iterable object.

import paco

async def filterer(x):
    return x < 8

async def mapper(x):
    return x * 2

async def drop(x):
    return x < 10

async def reducer(acc, x):
    return acc + x

async def task(numbers):
    return await (numbers
                   | paco.filter(filterer)
                   | paco.map(mapper)
                   | paco.dropwhile(drop)
                   | paco.reduce(reducer, initializer=0))

# Run in event loop
number = paco.run(task((1, 2, 3, 4, 5, 6, 7, 8, 9, 10)))
print('Number:', number) # => 36

License

MIT - Tomas Aparicio

You can’t perform that action at this time.