Asynchonous 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