twisted.internet.threads

module documentation

(source)

Extended thread dispatching support.

For basic support see reactor threading API docs.

Function	`blockingCallFromThread`	Run a function in the reactor from a thread, and wait for the result synchronously. If the function returns a `Deferred`, wait for its result and return that.
Function	`callMultipleInThread`	Run a list of functions in the same thread.
Function	`deferToThread`	Run a function in a thread and return the result as a Deferred.
Function	`deferToThreadPool`	Call the function `f` using a thread from the given threadpool and return the result as a Deferred.
Function	`_runMultiple`	Run a list of functions.
Constant	`_P`	Undocumented
Type Variable	`_R`	Undocumented

def blockingCallFromThread(reactor: IReactorFromThreads, f: Callable[_P, _R] | Callable[_P, defer.Deferred[_R]], *a: _P.args, **kw: _P.kwargs) -> _R: (source) ¶

Run a function in the reactor from a thread, and wait for the result synchronously. If the function returns a Deferred, wait for its result and return that.

Parameters
reactor:`IReactorFromThreads`	The `IReactorThreads` provider which will be used to schedule the function call.
f:any callable.	the callable to run in the reactor thread
*a:`_P.args`	the arguments to pass to `f`.
**kw:`_P.kwargs`	the keyword arguments to pass to `f`.

Returns
`_R`	the result of the `Deferred` returned by `f`, or the result of `f` if it returns anything other than a `Deferred`.

Raises
`Exception`	If `f` raises a synchronous exception, `blockingCallFromThread` will raise that exception. If `f` returns a `Deferred` which fires with a `Failure`, `blockingCallFromThread` will raise that failure's exception (see `Failure.raiseException`).

def callMultipleInThread(tupleList): (source) ¶

Run a list of functions in the same thread.

tupleList should be a list of (function, argsList, kwargsDict) tuples.

def deferToThread(f: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> defer.Deferred[_R]: (source) ¶

Run a function in a thread and return the result as a Deferred.

Parameters
f:`Callable[_P, _R]`	The function to call.
*args:`_P.args`	positional arguments to pass to f.
**kwargs:`_P.kwargs`	keyword arguments to pass to f.

Returns
`defer.Deferred[_R]`	A Deferred which fires a callback with the result of f, or an errback with a `twisted.python.failure.Failure` if f throws an exception.

def deferToThreadPool(reactor: IReactorFromThreads, threadpool: ThreadPool, f: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> defer.Deferred[_R]: (source) ¶

Call the function f using a thread from the given threadpool and return the result as a Deferred.

This function is only used by client code which is maintaining its own threadpool. To run a function in the reactor's threadpool, use deferToThread.

Parameters
reactor:`IReactorFromThreads`	The reactor in whose main thread the Deferred will be invoked.
threadpool:`ThreadPool`	An object which supports the `callInThreadWithCallback` method of `twisted.python.threadpool.ThreadPool`.
f:`Callable[_P, _R]`	The function to call.
*args:`_P.args`	positional arguments to pass to f.
**kwargs:`_P.kwargs`	keyword arguments to pass to f.

Returns
`defer.Deferred[_R]`	A Deferred which fires a callback with the result of f, or an errback with a `twisted.python.failure.Failure` if f throws an exception.

def _runMultiple(tupleList): (source) ¶

Run a list of functions.

_P = (source) ¶

Undocumented

Value

ParamSpec('_P')

_R = (source) ¶

Undocumented

Value

TypeVar('_R')