FM / vine

/opt/imh-python/lib/python3.9/site-packages/vine/

/opt/imh-python/lib/python3.9/site-packages/vine

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
abstract.py	1620	0644	edit dl rm
funtools.py	2862	0644	edit dl rm
promises.py	7681	0644	edit dl rm
synchronization.py	2960	0644	edit dl rm
utils.py	853	0644	edit dl rm
__init__.py	1041	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/vine/promises.py (7681B)

"""Promise implementation."""
import inspect
import sys
from collections import deque
from weakref import WeakMethod, ref

from .abstract import Thenable
from .utils import reraise

__all__ = ['promise']

@Thenable.register
class promise:
    """Promise of future evaluation.

This is a special implementation of promises in that it can
    be used both for "promise of a value" and lazy evaluation.
    The biggest upside for this is that everything in a promise can also be
    a promise, e.g. filters, callbacks and errbacks can all be promises.

Usage examples:

.. code-block:: python

>>> p = promise()
        >>> p.then(promise(print, ('OK',)))  # noqa
        >>> p.on_error = promise(print, ('ERROR',))  # noqa
        >>> p(20)
        OK, 20
        >>> p.then(promise(print, ('hello',)))  # noqa
        hello, 20

>>> p.throw(KeyError('foo'))
        ERROR, KeyError('foo')

>>> p2 = promise()
        >>> p2.then(print)  # noqa
        >>> p2.cancel()
        >>> p(30)

Example:
    .. code-block:: python

from vine import promise, wrap

class Protocol:

def __init__(self):
                self.buffer = []

def receive_message(self):
                return self.read_header().then(
                    self.read_body).then(
                        wrap(self.prepare_body))

def read(self, size, callback=None):
                callback = callback or promise()
                tell_eventloop_to_read(size, callback)
                return callback

def read_header(self, callback=None):
                return self.read(4, callback)

def read_body(self, header, callback=None):
                body_size, = unpack('>L', header)
                return self.read(body_size, callback)

def prepare_body(self, value):
                self.buffer.append(value)
    """

if not hasattr(sys, 'pypy_version_info'):  # pragma: no cover
        __slots__ = (
            'fun', 'args', 'kwargs', 'ready', 'failed',
            'value', 'ignore_result', 'reason', '_svpending', '_lvpending',
            'on_error', 'cancelled', 'weak', '__weakref__',
            # adding '__dict__' to get dynamic assignment if needed
            "__dict__",
        )

def __init__(self, fun=None, args=None, kwargs=None,
                 callback=None, on_error=None, weak=False,
                 ignore_result=False):
        self.weak = weak
        self.ignore_result = ignore_result
        self.fun = self._get_fun_or_weakref(fun=fun, weak=weak)
        self.args = args or ()
        self.kwargs = kwargs or {}
        self.ready = False
        self.failed = False
        self.value = None
        self.reason = None
        # Optimization
        # Most promises will only have one callback, so we optimize for this
        # case by using a list only when there are multiple callbacks.
        #   s(calar) pending / l(ist) pending
        self._svpending = None
        self._lvpending = None
        self.on_error = on_error
        self.cancelled = False

if callback is not None:
            self.then(callback)

if self.fun:
            assert self.fun and callable(fun)

@staticmethod
    def _get_fun_or_weakref(fun, weak):
        """Return the callable or a weak reference.

Handles both bound and unbound methods.
        """
        if not weak:
            return fun

if inspect.ismethod(fun):
            return WeakMethod(fun)
        else:
            return ref(fun)

def __repr__(self):
        return ('<{0} --> {1!r}>' if self.fun else '<{0}>').format(
            f'{type(self).__name__}@0x{id(self):x}', self.fun,
        )

def cancel(self):
        self.cancelled = True
        try:
            if self._svpending is not None:
                self._svpending.cancel()
            if self._lvpending is not None:
                for pending in self._lvpending:
                    pending.cancel()
            if isinstance(self.on_error, Thenable):
                self.on_error.cancel()
        finally:
            self._svpending = self._lvpending = self.on_error = None

def __call__(self, *args, **kwargs):
        retval = None
        if self.cancelled:
            return
        final_args = self.args + args if args else self.args
        final_kwargs = dict(self.kwargs, **kwargs) if kwargs else self.kwargs
        # self.fun may be a weakref
        fun = self._fun_is_alive(self.fun)
        if fun is not None:
            try:
                if self.ignore_result:
                    fun(*final_args, **final_kwargs)
                    ca = ()
                    ck = {}
                else:
                    retval = fun(*final_args, **final_kwargs)
                    self.value = (ca, ck) = (retval,), {}
            except Exception:
                return self.throw()
        else:
            self.value = (ca, ck) = final_args, final_kwargs
        self.ready = True
        svpending = self._svpending
        if svpending is not None:
            try:
                svpending(*ca, **ck)
            finally:
                self._svpending = None
        else:
            lvpending = self._lvpending
            try:
                while lvpending:
                    p = lvpending.popleft()
                    p(*ca, **ck)
            finally:
                self._lvpending = None
        return retval

def _fun_is_alive(self, fun):
        return fun() if self.weak else self.fun

def then(self, callback, on_error=None):
        if not isinstance(callback, Thenable):
            callback = promise(callback, on_error=on_error)
        if self.cancelled:
            callback.cancel()
            return callback
        if self.failed:
            callback.throw(self.reason)
        elif self.ready:
            args, kwargs = self.value
            callback(*args, **kwargs)
        if self._lvpending is None:
            svpending = self._svpending
            if svpending is not None:
                self._svpending, self._lvpending = None, deque([svpending])
            else:
                self._svpending = callback
                return callback
        self._lvpending.append(callback)
        return callback

def throw1(self, exc=None):
        if not self.cancelled:
            exc = exc if exc is not None else sys.exc_info()[1]
            self.failed, self.reason = True, exc
            if self.on_error:
                self.on_error(*self.args + (exc,), **self.kwargs)

def throw(self, exc=None, tb=None, propagate=True):
        if not self.cancelled:
            current_exc = sys.exc_info()[1]
            exc = exc if exc is not None else current_exc
            try:
                self.throw1(exc)
                svpending = self._svpending
                if svpending is not None:
                    try:
                        svpending.throw1(exc)
                    finally:
                        self._svpending = None
                else:
                    lvpending = self._lvpending
                    try:
                        while lvpending:
                            lvpending.popleft().throw1(exc)
                    finally:
                        self._lvpending = None
            finally:
                if self.on_error is None and propagate:
                    if tb is None and (exc is None or exc is current_exc):
                        raise
                    reraise(type(exc), exc, tb)

@property
    def listeners(self):
        if self._lvpending:
            return self._lvpending
        return [self._svpending]

cmd: