Das deutsche Python-Forum

Code: Alles auswählen

from time import sleep

@background
def test():
    sleep(10)
    return "blub"

controller = test()
print controller.running
sleep(4)
print controller.running
sleep(7)
print controller.running
print controller.result

Code: Alles auswählen

Traceback (most recent call last):
  File "C:\Dokumente und Einstellungen\Beere\Desktop\muell.py", line 9, in -toplevel-
    print controller.running
AttributeError: 'str' object has no attribute 'running'

Code: Alles auswählen

import sys
import inspect
import new
import itertools
import threading

class decorator(object):
    """General purpose decorator factory: takes a caller function as
    input and returns a decorator. A caller function is any
    function like this::

        def caller(func, *args, **kw):
            # do something
            return func(*args, **kw)
    """
    def __init__(self, caller):
        self.caller = caller

    def __call__(self, func):
        return self._decorate(func, self.caller)

    def _getinfo(self, func):
        assert inspect.ismethod(func) or inspect.isfunction(func)
        regargs, varargs, varkwargs, defaults = inspect.getargspec(func)
        argnames = list(regargs)
        if varargs:
            argnames.append(varargs)
        if varkwargs:
            argnames.append(varkwargs)
        counter = itertools.count()
        fullsign = inspect.formatargspec(
            regargs, varargs, varkwargs, defaults,
            formatvalue=lambda value: '=defarg[%i]' % counter.next())[1:-1]
        shortsign = inspect.formatargspec(
            regargs, varargs, varkwargs, defaults,
            formatvalue=lambda value: '')[1:-1]
        dic = dict(('arg%s' % n, name) for n, name in enumerate(argnames))
        dic.update(name=func.__name__, argnames=argnames, shortsign=shortsign,
            fullsign = fullsign, defarg = func.func_defaults or ())
        return dic

    def _decorate(self, func, caller):
        """
        Takes a function and a caller and returns the function
        decorated with that caller. The decorated function is obtained
        by evaluating a lambda function with the correct signature.
        """
        infodict = self._getinfo(func)
        if '__call_' in infodict['argnames'] or\
           '__func_' in infodict['argnames']:
            raise NameError, "You cannot use __call_ or __func_ as argument names!"
        execdict = dict(__func_=func, __call_=caller, defarg=func.func_defaults or ())
        if func.__name__ == "<lambda>":
            lambda_src = "lambda %(fullsign)s: __call_(__func_, %(shortsign)s)" \
                        % infodict
            dec_func = eval(lambda_src, execdict)
        else:
            func_src = """def %(name)s(%(fullsign)s):
            return __call_(__func_, %(shortsign)s)""" % infodict
            exec func_src in execdict
            dec_func = execdict[func.__name__]
        dec_func.__doc__ = func.__doc__
        dec_func.__dict__ = func.__dict__
        return dec_func

@decorator
def background(func, *args):
    """
    Run a function in the background.
        Returns a ThreadController object providing a
        running and result property.
    """
    class BackgroundThread(threading.Thread):
        def __init__(self):
            super(BackgroundThread, self).__init__()
            self.running = False
            self.result = None

        def run(self):
            self.running = True
            self.result = func(*args)
            self.running = False

    class ThreadController(object):

        def __init__(self, thread):
            self.thread = thread

        def _get_result(self):
            if self.thread.running:
                raise RuntimeError, 'Thread still running'
            return self.thread.result

        running = property(lambda s: s.thread.running)
        result = property(_get_result)

    t = BackgroundThread()
    t.start()
    return ThreadController(t)