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 Variable f The function to call.
Instance Variable a A tuple of arguments to pass the function.
Instance Variable kw A dictionary of keyword arguments to pass to the function.
Instance Variable 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.
Instance Variable running A flag which is True while f is scheduled to be called (or is currently being called). It is set to True when start is called and set to False when stop is called or if f raises an exception. In either case, it will be False by the time the Deferred returned by start fires its callback or errback. (type: bool)
Method __init__ Undocumented
Method deferred DEPRECATED. Deferred fired when loop stops or fails.
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 reset Skip the next iteration and reset the timer.
Method __call__ Undocumented
Method __repr__ Undocumented
Instance Variable _realLastTime When counting skips, the time at which the skip counter was last invoked. (type: float)
Instance Variable _runAtStart A flag indicating whether the 'now' argument was passed to LoopingCall.start. (type: bool)
Method _intervalOf Determine the number of intervals passed as of the given point in time.
Method _scheduleFrom Schedule the next iteration of this looping call.
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.
running =
A flag which is True while f is scheduled to be called (or is currently being called). It is set to True when start is called and set to False when stop is called or if f raises an exception. In either case, it will be False by the time the Deferred returned by start fires its callback or errback. (type: bool)
_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)
def __init__(self, f, *a, **kw): (source)
Undocumented
@property
def deferred(self): (source)

DEPRECATED. Deferred fired when loop stops or fails.

Use the Deferred returned by LoopingCall.start.

@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.

When running with an interval if 0, count will be always 1.

ParameterscountCallableA 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)
ReturnsAn instance of LoopingCall with call counting enabled, which provides the count as the first positional argument. (type: LoopingCall)
Present Since9.0
def _intervalOf(self, t): (source)

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

ParameterstThe specified time (from the start of the LoopingCall) to be measured in intervals
ReturnsThe 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.

ParametersintervalThe 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.
nowIf True, run this call right now. Otherwise, wait until the interval has elapsed before beginning.
ReturnsA 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.
def stop(self): (source)

Stop running function.

def reset(self): (source)

Skip the next iteration and reset the timer.

Present Since11.1
def __call__(self): (source)
Undocumented
def _scheduleFrom(self, when): (source)

Schedule the next iteration of this looping call.

ParameterswhenThe present time from whence the call is scheduled.
def __repr__(self): (source)
Undocumented
API Documentation for Twisted, generated by pydoctor at 2017-06-11 10:59:01.