twisted.internet.task.LoopingCall : API documentation

Call a function repeatedly.

If f returns a deferred, rescheduling will not take place until the deferred has fired. The result value is ignored.

Instance Variables	f	The function to call.
	a	A tuple of arguments to pass the function.
	kw	A dictionary of keyword arguments to pass to the function.
	clock	A provider of `twisted.internet.interfaces.IReactorTime`. The default is `twisted.internet.reactor`. Feel free to set this to something else, but it probably ought to be set before calling `start`.
	_expectNextCallAt	The time at which this instance most recently scheduled itself to run. (type: `float` )
	_realLastTime	When counting skips, the time at which the skip counter was last invoked. (type: `float` )
	_runAtStart	A flag indicating whether the 'now' argument was passed to `LoopingCall.start`. (type: `bool` )

Method	__init__	Undocumented
Class Method	withCount	An alternate constructor for `LoopingCall` that makes available the number of calls which should have occurred since it was last invoked.
Method	start	Start running function every interval seconds.
Method	stop	Stop running function.
Method	__call__	Undocumented
Method	__repr__	Undocumented
Method	_intervalOf	Determine the number of intervals passed as of the given point in time.
Method	_reschedule	Schedule the next iteration of this looping call.

def __init__(self, f, *a, **kw): (source)

Undocumented

@classmethod
def withCount(cls, countCallable): (source)

An alternate constructor for LoopingCall that makes available the number of calls which should have occurred since it was last invoked.

Note that this number is an int value; It represents the discrete number of calls that should have been made. For example, if you are using a looping call to display an animation with discrete frames, this number would be the number of frames to advance.

The count is normally 1, but can be higher. For example, if the reactor is blocked and takes too long to invoke the LoopingCall, a Deferred returned from a previous call is not fired before an interval has elapsed, or if the callable itself blocks for longer than an interval, preventing itself from being called.

Parameters	countCallable	A callable that will be invoked each time the resulting LoopingCall is run, with an integer specifying the number of calls that should have been invoked. (type: 1-argument callable which takes an `int` )
Returns	An instance of `LoopingCall` with call counting enabled, which provides the count as the first positional argument. (type: `LoopingCall` )
Present Since	9.0

def _intervalOf(self, t): (source)

Determine the number of intervals passed as of the given point in time.

Parameters	t	The specified time (from the start of the `LoopingCall`) to be measured in intervals
Returns	The `int` number of intervals which have passed as of the given point in time.

def start(self, interval, now=True): (source)

Start running function every interval seconds.

Parameters	interval	The number of seconds between calls. May be less than one. Precision will depend on the underlying platform, the available hardware, and the load on the system.
	now	If True, run this call right now. Otherwise, wait until the interval has elapsed before beginning.
Returns	A Deferred whose callback will be invoked with `self` when `self.stop` is called, or whose errback will be invoked when the function raises an exception or returned a deferred that has its errback invoked.

t.i.t.LoopingCall : class documentation