How to use the greenlet.getcurrent function in greenlet

To help you get started, we’ve selected a few greenlet examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github veegee / guv / guv / View on Github external
def just_raise(*a, **kw):
            if throw_args:
                reraise(throw_args[0], throw_args[1], throw_args[2])
                raise greenlet.GreenletExit() = just_raise
        if isinstance(g, GreenThread):
            # it's a GreenThread object, so we want to call its main method to take advantage of
            # the notification
                g.main(just_raise, (), {})

    current = greenlet.getcurrent()
    if current is not hub:
        # arrange to wake the caller back up immediately

github Knio / carhack / can / View on Github external
def read_block(self, mode, pid, timeout=0.5):
        current = greenlet.getcurrent()
        s = self.read_waiters[mode, pid]

        def timeout_cb():
            current.throw(TimeoutError('Read timeout exceeded'))

        _t = ioloop.add_timeout(time.time() + timeout, timeout_cb)
        frame = current.parent.switch()

        return frame
github neumond / python-computer-craft / computercraft / View on Github external
def on_task_result(self, task_id, result):
        assert get_current_greenlet() is self._server_greenlet
        if task_id not in self._greenlets:
            # ignore for dropped tasks
github neumond / python-computer-craft / computercraft / View on Github external
def _is_global_greenlet():
    return not hasattr(get_current_greenlet(), 'cc_greenlet')
github zwegner / mutagen / bootstrap / View on Github external
def perform_value(obj, ctx, value):
    child = greenlet.getcurrent()
    if not child.parent:
        obj.error('unhandled effect %s' % (value.repr(ctx)), ctx=ctx)
        result = child.parent.switch(value)
    except ProgramError as e:
        # Reset exception info to come from this stack, rather than the stack of
        # the handler
        e.stack_trace = ctx.get_stack_trace() =
        raise e
    return result
github benoitc / flower / flower / core / View on Github external
def _coroutine_getmain():
        return _tls.main_coroutine
    except AttributeError:
        main = coroutine()
        main._is_started = -1
        main._greenlet = greenlet.getcurrent()
        _tls.main_coroutine = main
        return _tls.main_coroutine
github eventlet / eventlet / eventlet / hubs / View on Github external
The fileno argument is the file number of the file of interest.  The other
        arguments are either callbacks or None.  If there is a callback for read
        or write, the hub sets things up so that when the file descriptor is
        ready to be read or written, the callback is called.
        The exc callback is called when the socket represented by the file
        descriptor is closed.  The intent is that the the exc callbacks should
        only be present when either a read or write callback is also present,
        so the exc callback happens instead of the respective read or write
        self.readers[fileno] = read or self.readers.get(fileno)
        self.writers[fileno] = write or self.writers.get(fileno)
        self.excs[fileno] = exc or self.excs.get(fileno)
        self.waiters_by_greenlet[greenlet.getcurrent()] = fileno
github bfredl / nvim-ipy / rplugin / python3 / nvim_ipy / View on Github external
def waitfor(self, msg_id, retval=None):
        #FIXME: add some kind of timeout
        gr = greenlet.getcurrent()
        self.handle(msg_id, gr)
        return gr.parent.switch(retval)
github bpython / bpython / bpython / curtsiesfrontend / View on Github external
def __init__(self, interp=None, request_refresh=lambda: None):
        interp is an interpreter object to use. By default a new one is

        request_refresh is a function that will be called each time the running
        code asks for a refresh - to, for example, update the screen.
        self.interp = interp or code.InteractiveInterpreter()
        self.source = None
        self.main_context = greenlet.getcurrent()
        self.code_context = None
        self.request_refresh = request_refresh
        # waiting for response from main thread
        self.code_is_waiting = False
        # sigint happened while in main thread
        self.sigint_happened_in_main_context = False
        self.orig_sigint_handler = None
github veegee / guv / guv / util / View on Github external
def _setup(self):
        self._has_setup = True
        self.cur = None
        self.timings = {}
        self.current_tasklet = greenlet.getcurrent()
        self.thread_id = thread.get_ident()