Resolving Promises

Promise.__init__

__init__(function[, daemon=False, print_exception=logging.ERROR])

The constructor creates a threading.Thread wrapping the function. To start it, call the resulting object as a function with it’s arguments. (Explained in Promise.__call__)

>>> promise = Promise(func, print_exception=None)
>>> promise()

param function:

Function, Event, Condition, or anything else to resolve.

param daemon:

Sets up daemon flag in the thread. May be set later. Optional.

param print_exception:

Sets up the final exception printing level. Pass False to suppress.

Promise.__call__

__call__(*args, **kwargs)

Starts the thread and passes the arguments of the function into it. Returns self, for simple adding Promise.then, Promise.wait or Promise.catch.

Promise.wait

wait([timeout=None])

Pauses the current thread to wait until the underlying promise resolves.

If timeout is set, raises easync.TimeoutError if it’s reached.

Returns result of the underlying function if there’s any.

Promise.then

then([resolved=None, rejected=None, print_exception=Promise.print_exception])

This method sets callbacks for a Promise.

NOTE this method suppresses the Promise default error handling by setting Promise.print_exception to False. You can then re-enable printouts manually, overriding the Promise.print_exception yourself.

NOTE calling this method twice on the same Promise object will result in duplicated exception printouts unless changed.

The result is a new Promise which resolves in:

callback exception:

If the called callback (either resolved or rejected) failed or raised anything.

reject:

If the underlying Promise rejected and no rejected callback was passed.

callback return:

The result of the called callback.

resolve:

The result of the underlying Promise if it resolves and no resolved callback was passed.

This is done to have this kind of behaviour:

>>> Promise(action)(...args).then(parse_result).then(parse_one_more_result).catch(any_exception).then(cleanup)

function resolved(result):

The positive callback for the Promise. Has to accept one positional argument - the result.

function rejected(exception, exc_info):

The negative callback for the Promise. Has to accept two positional arguments - the caught exception and it’s exc_info.

print_exception:

Passed into the corresponding argument of the newly created Promise.

return:

New Promise.

Promise.catch

catch([callback=None, print_exception=Promise.print_exception])

The same as Promise.then (resolved=None, callback, print_exception).

Promise.resolve

Promise.resolve(thing)

Resolves thing, regardless of what it is, to result.

param thing:

any

return:

resolved Promise with the Promise.result equals to thing.

Promise.reject

Promise.reject(thing)

Rejects thing, regardless of what it is.

NOTE, if this will be called, the Promise.exc_info will be set None.

param thing:

any

return:

rejected Promise with the Promise.exception equals to thing.

Promise.all

Promise.all(things)

Resolves when all the items in the enumerate(things) are resolved. Or rejects when any of the items is rejected.

param things:

list of things or anything to be enumerate’d.

result:

list of results of all the Promises for each of the items.

exception:

first caught exception.

Promise.race

Promise.race(things)

Resolves when any of the items in the enumerate(things) is resolved. Or rejects when any of the items is rejected.

param things:

list of things or anything to be enumerate’d.

result:

the result of the first resolved item.

exception:

first caught exception.

get_result

get_result(obj)

Returns the first found attribute of result or success of the object obj, if any. Otherwise returns None.

is_failed

is_failed(obj)

Returns:

found property:

if one of error, exception, failure is found.

True:

if one of failed or is_failed is true.

True:

if success is present and is False.

None:

Otherwise