twisted.internet.task.Cooperator : API documentation

class documentation

class twisted.internet.task.Cooperator: (source)

Cooperative task scheduler.

A cooperative task is an iterator where each iteration represents an atomic unit of work. When the iterator yields, it allows the Cooperator to decide which of its tasks to execute next. If the iterator yields a defer.Deferred then work will pause until the defer.Deferred fires and completes its callback chain.

When a Cooperator has more than one task, it distributes work between all tasks.

There are two ways to add tasks to a Cooperator, cooperate and coiterate. cooperate is the more useful of the two, as it returns a CooperativeTask, which can be paused, resumed and waited on. coiterate has the same effect, but returns only a defer.Deferred that fires when the task is done.

Cooperator can be used for many things, including but not limited to:

running one or more computationally intensive tasks without blocking
limiting parallelism by running a subset of the total tasks simultaneously
doing one thing, waiting for a Deferred to fire, doing the next thing, repeat (i.e. serializing a sequence of asynchronous tasks)

Multiple Cooperators do not cooperate with each other, so for most cases you should use the global cooperator.

Method	__init__	Create a scheduler-like object to which iterators may be added.
Method	coiterate	Add an iterator to the list of iterators this `Cooperator` is currently running.
Method	cooperate	Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event.
Method	start	Begin scheduling steps.
Method	stop	Stop scheduling steps. Errback the completion Deferreds of all iterators which have been added and forget about them.
Property	running	Is this `Cooperator` is currently running?
Instance Variable	_tasks	Undocumented
Instance Variable	_metarator	Undocumented
Instance Variable	_terminationPredicateFactory	Undocumented
Instance Variable	_scheduler	Undocumented
Instance Variable	_delayedCall	Undocumented
Instance Variable	_stopped	Undocumented
Instance Variable	_started	Undocumented
Method	_addTask	Add a `CooperativeTask` object to this `Cooperator`.
Method	_removeTask	Remove a `CooperativeTask` from this `Cooperator`.
Method	_tasksWhileNotStopped	Yield all `CooperativeTask` objects in a loop as long as this `Cooperator`'s termination condition has not been met.
Method	_tick	Run one scheduler tick.
Instance Variable	_mustScheduleOnStart	Undocumented
Method	_reschedule	Undocumented

def __init__(self, terminationPredicateFactory=_Timer, scheduler=_defaultScheduler, started=True): (source)

Create a scheduler-like object to which iterators may be added.

Parameters	terminationPredicateFactory	A no-argument callable which will be invoked at the beginning of each step and should return a no-argument callable which will return True when the step should be terminated. The default factory is time-based and allows iterators to run for 1/100th of a second at a time.
	scheduler	A one-argument callable which takes a no-argument callable and should invoke it at some future point. This will be used to schedule each step of this Cooperator.
	started	A boolean which indicates whether iterators should be stepped as soon as they are added, or if they will be queued up until `Cooperator.start` is called.

_tasks = (source)

Undocumented

(type: list)

_metarator = (source)

Undocumented

_terminationPredicateFactory = (source)

Undocumented

_scheduler = (source)

Undocumented

_delayedCall = (source)

Undocumented

_stopped = (source)

Undocumented

(type: bool)

_started = (source)

Undocumented

(type: bool)

def coiterate(self, iterator, doneDeferred=None): (source)

Add an iterator to the list of iterators this Cooperator is currently running.

Equivalent to cooperate, but returns a defer.Deferred that will be fired when the task is done.

Parameters	iterator	Undocumented
	doneDeferred	If specified, this will be the Deferred used as the completion deferred. It is suggested that you use the default, which creates a new Deferred for you.
Returns	a Deferred that will fire when the iterator finishes.

def cooperate(self, iterator): (source)

Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event.

Parameters	iterator	the iterator to invoke.
Returns	a `CooperativeTask` object representing this task.

def _addTask(self, task): (source)

Add a CooperativeTask object to this Cooperator.

def _removeTask(self, task): (source)

Remove a CooperativeTask from this Cooperator.

def _tasksWhileNotStopped(self): (source)

Yield all CooperativeTask objects in a loop as long as this Cooperator's termination condition has not been met.

def _tick(self): (source)

Run one scheduler tick.

_mustScheduleOnStart = (source)

Undocumented

(type: bool)

def _reschedule(self): (source)

Undocumented

def start(self): (source)

Begin scheduling steps.

def stop(self): (source)

Stop scheduling steps. Errback the completion Deferreds of all iterators which have been added and forget about them.

@property
running = (source)

Is this Cooperator is currently running?

(type: bool)

API Documentation for Twisted, generated by pydoctor 20.12.1 at 2021-02-28 19:53:36.