The decorators would abstract the logic of spawning a process or thread and
maintaining its lifecycle.
I think it could be a good fit for the `concurrent.futures` module.
Decorated functions would return a `Future` object and run the logic in a
separate thread or process.
@concurrent.futures.thread
def function(arg, kwarg=0):
return arg + kwarg
future = function(1, kwarg=2)
future.result()
The Process decorator in particular would support use cases such as running
unstable code within an application taking advantage of process separation
benefits.
I often found myself relying on external APIs which would either crash or
run indefinitely affecting my application stability and performance.
@concurrent.futures.process(timeout=60):
def unstable_function(arg, kwarg=0):
# hang or segfault here
return arg + kwarg
future = unstable_function(1, kwarg=2)
try:
future.result()
except TimeoutError as error:
print("Function took more than %d seconds" % error.args[1])
except ProcessExpired as error:
print("Process exit code %d" % error.exitcode)
In case of timeout, the process would be terminated reclaiming back its
resources.
Few years ago I wrote a library for this purpose which turned out pretty
handy in reducing the boilerplate code when dealing with threads and
processes. It could be a starting point for discussing about the
implementation.
https://pypi.python.org/pypi/Pebble
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
