Asynchronous API¶

Pulsar asynchronous api is built on top of the new python asyncio module.

Async object interface¶

This small class is the default interface for asynchronous objects. It is provided mainly for documentation purposes.

class pulsar.async.futures.AsyncObject[source]¶

Interface for async objects

_loop¶: The event loop associated with this object

_logger¶: Optional logger instance, used by the logger attribute

debug¶: True when in debug mode

logger¶

The logger for this object.

It is either the _logger or the logger of the _loop

timeit(method, times, *args, **kwargs)[source]¶

Useful utility for benchmarking an asynchronous method.

Parameters:	method – the name of the `method` to execute times – number of times to execute the `method` args – positional arguments to pass to the `method` kwargs – key-valued arguments to pass to the `method`
Returns:	a `Future` which results in a `Bench` object if successful

The usage is simple:

>>> b = self.timeit('asyncmethod', 100)

class pulsar.async.futures.Bench(times, loop=None)[source]¶

Execute a given number of asynchronous requests and wait for results.

taken¶: The total time taken for execution

Async Utilities¶

A collection of asynchronous utilities which facilitates manipulation and interaction with asynchronous components.

task¶

pulsar.async.futures.task(function)[source]¶

Thread-safe decorator to run a function in an event loop.

Parameters:	function – a callable which can return coroutines, `asyncio.Future` or synchronous data. Can be a method of an async object, in which case the loop is given by the object `_loop` attribute.
Returns:	a `Future`

Maybe Async¶

pulsar.async.futures.maybe_async(value, loop=None)[source]¶

Handle a possible asynchronous value.

Return an asynchronous instance only if value is a generator, a Future.

Parameters:	value – the value to convert to an asynchronous instance if it needs to. loop – optional `EventLoop`.
Returns:	a `Future` or a synchronous `value`.

Chain Future¶

pulsar.async.futures.chain_future(future, callback=None, errback=None, next=None)[source]¶

Chain a Future to an existing future.

This function chain the next future to an existing future. When the input future receive a result the optional callback is executed and its result set as the results of next. If an exception occurs the optional errback is executed.

Parameters:	future – the original `Future` (can be a coroutine) callback – optional callback to execute on the result of `future` errback – optional callback to execute on the exception of `future` next – optional `Future` to chain. If not provided a new future is created
Returns:	the future `next`

Multi Async¶

pulsar.async.futures.multi_async(data=None, loop=None, type=None, raise_on_error=True)¶: Handle several futures at once. Thread safe.

Async While¶

pulsar.async.futures.async_while(timeout, while_clause, *args)[source]¶

The asynchronous equivalent of while while_clause(*args):

Use this function within a coroutine when you need to wait while_clause to be satisfied.

Parameters:	timeout – a timeout in seconds after which this function stop. while_clause – while clause callable. args – optional arguments to pass to the `while_clause` callable.
Returns:	A `Future`.

Run in loop¶

pulsar.async.futures.run_in_loop(loop, callable, *args, **kwargs)[source]¶

Run callable in the event loop thread, thread safe.

Parameters:	loop – The event loop where `callable` is run
Returns:	a `Future`

Lock¶

class pulsar.async.lock.LockBase(name, *, loop=None, timeout=None, blocking=True)[source]¶

A asynchronous locking primitive associated to a given name.

An asynchronous lock is in one of two states, ‘locked’ or ‘unlocked’. It is created in the unlocked state. It has two basic methods, acquire() and release. When the state is unlocked, :meth:().acquire` changes the state to locked and returns immediately.

When the state is locked, acquire() wait until a call to release() changes it to unlocked, then the acquire() call resets it to locked and returns.

blocking¶: The time to wait for the lock to be free when acquiring it. When False it does not block, when True it blocks forever, when a positive number blocks for blocking seconds.

timeout¶: Free the lock after timeout seconds. If timeout is None (default) does not free the lock until release is called.

acquire()[source]¶: Try to acquire the lock

locked()[source]¶: Return True if the lock is acquired

release()[source]¶: Release the lock

class pulsar.async.lock.Lock(name, *, loop=None, timeout=None, blocking=True)[source]¶: An asynchronous lock