| Server IP : 61.19.30.66 / Your IP : 216.73.216.15 Web Server : Apache/2.2.22 (Ubuntu) System : Linux klw 3.11.0-15-generic #25~precise1-Ubuntu SMP Thu Jan 30 17:39:31 UTC 2014 x86_64 User : www-data ( 33) PHP Version : 5.3.10-1ubuntu3.48 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority, MySQL : ON | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /usr/lib/python2.7/dist-packages/twisted/internet/ |
Upload File : |
ó
wGNc @ s¿ d Z e Z d d l Z d d l m Z d d l m Z d d l m Z d d l
m Z m Z d d l
m Z d d' d „ ƒ YZ d
e f d „ ƒ YZ d e f d
„ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d Z d „ Z d e f d „ ƒ YZ d e f d „ ƒ YZ e ƒ Z d „ Z d! „ Z d" d( d# „ ƒ YZ! d$ „ Z" d d" d d d% d& g Z# d S() s@
Scheduling utility methods and classes.
@author: Jp Calderone
iÿÿÿÿN( t
implements( t reflect( t Failure( t baset defer( t IReactorTimet LoopingCallc B s˜ e Z d Z d Z e Z d Z d Z d Z e Z
d Z d „ Z d „ Z
e e
ƒ Z
d „ Z e d „ Z d „ Z d „ Z d „ Z d „ Z d
„ Z RS( sô Call a function repeatedly.
If C{f} returns a deferred, rescheduling will not take place until the
deferred has fired. The result value is ignored.
@ivar f: The function to call.
@ivar a: A tuple of arguments to pass the function.
@ivar kw: A dictionary of keyword arguments to pass to the function.
@ivar clock: A provider of
L{twisted.internet.interfaces.IReactorTime}. The default is
L{twisted.internet.reactor}. Feel free to set this to
something else, but it probably ought to be set *before*
calling L{start}.
@type _expectNextCallAt: C{float}
@ivar _expectNextCallAt: The time at which this instance most recently
scheduled itself to run.
@type _realLastTime: C{float}
@ivar _realLastTime: When counting skips, the time at which the skip counter
was last invoked.
@type _runAtStart: C{bool}
@ivar _runAtStart: A flag indicating whether the 'now' argument was passed
to L{LoopingCall.start}.
g c O s8 | | _ | | _ | | _ d d l m } | | _ d S( Niÿÿÿÿ( t reactor( t ft at kwt twisted.internetR t clock( t selfR R R
R ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt __init__< s
c s+ ‡ ‡ f d † } | | ƒ ‰ d ˆ _ ˆ S( s
An alternate constructor for L{LoopingCall} that makes available the
number of calls which should have occurred since it was last invoked.
Note that this number is an C{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 L{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 I{itself} from being called.
@param 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 countCallable: 1-argument callable which takes an C{int}
@return: An instance of L{LoopingCall} with call counting enabled,
which provides the count as the first positional argument.
@rtype: L{LoopingCall}
@since: 9.0
c s„ ˆ j j ƒ } ˆ j } | d k rI ˆ j } ˆ j rI | ˆ j 8} qI n | ˆ _ ˆ j | ƒ } ˆ j | ƒ } | | } ˆ | ƒ S( N( R t secondst
_realLastTimet Nonet starttimet _runAtStartt intervalt _intervalOf( t nowt lastTimet lastIntervalt thisIntervalt count( R
t
countCallable( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt counterb s
N( R R ( t clsR R ( ( R
R s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt withCountD s
c C s$ | | j } t | | j ƒ } | S( sD
Determine the number of intervals passed as of the given point in
time.
@param t: The specified time (from the start of the L{LoopingCall}) to
be measured in intervals
@return: The C{int} number of intervals which have passed as of the
given point in time.
( R t intR ( R
t tt elapsedTimet intervalNum( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR x s
c C s˜ | j s t d ƒ ‚ | d k r. t d ‚ n t | _ t j ƒ } | _ | j j ƒ | _ | j | _
| | _ | | _ | rŠ | ƒ n
| j
ƒ | S( sˆ
Start running function every interval seconds.
@param 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.
@param now: If True, run this call right now. Otherwise, wait
until the interval has elapsed before beginning.
@return: A Deferred whose callback will be invoked with
C{self} when C{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.
s. Tried to start an already running LoopingCall.i s interval must be >= 0( t runningt AssertionErrort
ValueErrort TrueR t Deferredt deferredR R R t _expectNextCallAtR R t _reschedule( R
R R t d( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt startˆ s
c C sj | j s t d ƒ ‚ t | _ | j d k rf | j j ƒ d | _ | j d } | _ | j | ƒ n d S( s Stop running function.
s1 Tried to stop a LoopingCall that was not running.N( R# R$ t Falset callR t cancelR( t callback( R
R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt stop¨ s
c C s] | j s t d ƒ ‚ | j d k rY | j j ƒ d | _ | j j ƒ | _ | j ƒ n d S( sT
Skip the next iteration and reset the timer.
@since: 11.1
s2 Tried to reset a LoopingCall that was not running.N( R# R$ R. R R/ R R R) R* ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt reset´ s
c sc ‡ f d † } ‡ f d † } d ˆ _ t j ˆ j ˆ j ˆ j Ž } | j | ƒ | j | ƒ d S( Nc s: ˆ j r ˆ j ƒ n ˆ j d } ˆ _ | j ˆ ƒ d S( N( R# R* R( R R0 ( t resultR+ ( R
( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt cbà s
c s- t ˆ _ ˆ j d } ˆ _ | j | ƒ d S( N( R- R# R( R t errback( t failureR+ ( R
( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt ebÊ s ( R R. R t
maybeDeferredR R R
t addCallbackt
addErrback( R
R4 R7 R+ ( ( R
s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt __call__Â s
c C s° | j d k r+ | j j d | ƒ | _ d S| j j ƒ } | j | | j } t | j | j | | ƒ } | | k r‡ | | j 7} n | | _ | j j | | | ƒ | _ d S( sC
Schedule the next iteration of this looping call.
i N( R R t callLaterR. R R) t max( R
t currentTimet
untilNextTimet nextTime( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR* Õ s c C sŽ t | j d ƒ rM | j j } t | j d ƒ r_ | j j j d | } q_ n t j | j ƒ } d | j | t j | j ƒ t j | j ƒ f S( Nt func_namet im_classt .s LoopingCall<%r>(%s, *%s, **%s)(
t hasattrR RA RB t __name__R t safe_reprR R R
( R
t func( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt __repr__ì s N( RE t
__module__t __doc__R R. R- R# R( R R) R R R R t classmethodR R& R, R1 R2 R; R* RH ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR s$ 1 t SchedulerErrorc B s e Z d Z RS( sï
The operation could not be completed because the scheduler or one of its
tasks was in an invalid state. This exception should not be raised
directly, but is a superclass of various scheduler-state-related
exceptions.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRL ú s t SchedulerStoppedc B s e Z d Z RS( st
The operation could not complete because the scheduler was stopped in
progress or was already stopped.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRM s t TaskFinishedc B s e Z d Z RS( sž
The operation could not complete because the task was already completed,
stopped, encountered an error or otherwise permanently stopped running.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRN s t TaskDonec B s e Z d Z RS( sR
The operation could not complete because the task was already completed.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRO s t TaskStoppedc B s e Z d Z RS( sH
The operation could not complete because the task was stopped.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRP s t
TaskFailedc B s e Z d Z RS( s]
The operation could not complete because the task died with an unhandled
error.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRQ " s t NotPausedc B s e Z d Z RS( s^
This exception is raised when a task is resumed which was not previously
paused.
( RE RI RJ ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRR * s t _Timerc B s e Z d Z d „ Z d „ Z RS( g{®Gáz„?c C s t j ƒ | j | _ d S( N( t timet MAX_SLICEt end( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR 4 s c C s t j ƒ | j k S( N( RT RV ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR; 8 s ( RE RI RU R R; ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRS 2 s g:Œ0âŽyE>c C s d d l m } | j t | ƒ S( Niÿÿÿÿ( R ( R R R< t _EPSILON( t xR ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt _defaultScheduler> s t CooperativeTaskc B sV e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z
RS( sñ
A L{CooperativeTask} is a task object inside a L{Cooperator}, which can be
paused, resumed, and stopped. It can also have its completion (or
termination) monitored.
@see: L{CooperativeTask.cooperate}
@ivar _iterator: the iterator to iterate when this L{CooperativeTask} is
asked to do work.
@ivar _cooperator: the L{Cooperator} that this L{CooperativeTask}
participates in, which is used to re-insert it upon resume.
@ivar _deferreds: the list of L{defer.Deferred}s to fire when this task
completes, fails, or finishes.
@type _deferreds: L{list}
@type _cooperator: L{Cooperator}
@ivar _pauseCount: the number of times that this L{CooperativeTask} has
been paused; if 0, it is running.
@type _pauseCount: L{int}
@ivar _completionState: The completion-state of this L{CooperativeTask}.
C{None} if the task is not yet completed, an instance of L{TaskStopped}
if C{stop} was called to stop this task early, of L{TaskFailed} if the
application code in the iterator raised an exception which caused it to
terminate, and of L{TaskDone} if it terminated normally via raising
L{StopIteration}.
@type _completionState: L{TaskFinished}
c C sG | | _ | | _ g | _ d | _ d | _ d | _ | j | ƒ d S( sq
A private constructor: to create a new L{CooperativeTask}, see
L{Cooperator.cooperate}.
i N( t _iteratort _cooperatort
_deferredst _pauseCountR t _completionStatet _completionResultt _addTask( R
t iteratort
cooperator( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR g s c C sB t j ƒ } | j d k r. | j j | ƒ n | j | j ƒ | S( sÉ
Get a L{defer.Deferred} notification of when this task is complete.
@return: a L{defer.Deferred} that fires with the C{iterator} that this
L{CooperativeTask} was created with when the iterator has been
exhausted (i.e. its C{next} method has raised L{StopIteration}), or
fails with the exception raised by C{next} if it raises some other
exception.
@rtype: L{defer.Deferred}
N( R R' R_ R R] t appendR0 R` ( R
R+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt whenDoneu s
c C s? | j ƒ | j d 7_ | j d k r; | j j | ƒ n d S( s@
Pause this L{CooperativeTask}. Stop doing work until
L{CooperativeTask.resume} is called. If C{pause} is called more than
once, C{resume} must be called an equal number of times to resume this
task.
@raise TaskFinished: if this task has already finished or completed.
i N( t _checkFinishR^ R\ t _removeTask( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt pause‰ s
c C s_ | j d k r t ƒ ‚ n | j d 8_ | j d k r[ | j d k r[ | j j | ƒ n d S( sˆ
Resume processing of a paused L{CooperativeTask}.
@raise NotPaused: if this L{CooperativeTask} is not paused.
i i N( R^ RR R_ R R\ Ra ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt resume˜ s
c C sS | | _ | | _ | j s. | j j | ƒ n x | j D] } | j | ƒ q8 Wd S( s
@param completionState: a L{TaskFinished} exception or a subclass
thereof, indicating what exception should be raised when subsequent
operations are performed.
@param deferredResult: the result to fire all the deferreds with.
N( R_ R` R^ R\ Rg R] R0 ( R
t completionStatet deferredResultR+ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt
_completeWith¥ s c C s* | j ƒ | j t ƒ t t ƒ ƒ ƒ d S( s»
Stop further processing of this task.
@raise TaskFinished: if this L{CooperativeTask} has previously
completed, via C{stop}, completion, or failure.
N( Rf Rl RP R ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR1 ½ s
c C s | j d k r | j ‚ n d S( sk
If this task has been stopped, raise the appropriate subclass of
L{TaskFinished}.
N( R_ R ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRf È s c s¤ y ˆ j j ƒ } WnC t k
r< ˆ j t ƒ ˆ j ƒ nd ˆ j t ƒ t ƒ ƒ nH Xt | t j ƒ r ˆ j
ƒ ‡ f d † } | j ‡ f d † | ƒ n d S( sÛ
Perform one unit of work for this task, retrieving one item from its
iterator, stopping if there are no further items in the iterator, and
pausing if the result was a L{defer.Deferred}.
c s ˆ j t ƒ | ƒ d S( N( Rl RQ ( R ( R
( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt failLaterà s c s
ˆ j ƒ S( N( Ri ( R3 ( R
( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt <lambda>â s N( R[ t nextt
StopIterationRl RO RQ R t
isinstanceR R' Rh t addCallbacks( R
R3 Rm ( ( R
s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt _oneWorkUnitÑ s
( RE RI RJ R Re Rh Ri Rl R1 Rf Rs ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRZ C s "
t
Cooperatorc B sz e Z d Z e e e d „ Z d d „ Z d „ Z d „ Z
d „ Z d „ Z d „ Z
e Z d „ Z d „ Z d
„ Z RS( s%
Cooperative task scheduler.
c C sI g | _ t d ƒ | _ | | _ | | _ d | _ t | _ | | _ d S( sA
Create a scheduler-like object to which iterators may be added.
@param 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.
@param 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.
@param started: A boolean which indicates whether iterators should be
stepped as soon as they are added, or if they will be queued up until
L{Cooperator.start} is called.
N( (
t _taskst itert
_metaratort _terminationPredicateFactoryt
_schedulerR t _delayedCallR- t _stoppedt _started( R
t terminationPredicateFactoryt schedulert started( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR ì s c C s; | d k r t j ƒ } n t | | ƒ j ƒ j | ƒ | S( sƒ
Add an iterator to the list of iterators this L{Cooperator} is
currently running.
@param 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.
@return: a Deferred that will fire when the iterator finishes.
N( R R R' RZ Re t
chainDeferred( R
Rb t doneDeferred( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt coiterate
s c C s
t | | ƒ S( s
Start running the given iterator as a long-running cooperative task, by
calling next() on it as a periodic timed event.
@param iterator: the iterator to invoke.
@return: a L{CooperativeTask} object representing this task.
( RZ ( R
Rb ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt cooperate s c C sV | j r8 | j j | ƒ | j t ƒ t t ƒ ƒ ƒ n | j j | ƒ | j ƒ d S( sH
Add a L{CooperativeTask} object to this L{Cooperator}.
N( R{ Ru Rd Rl RM R R* ( R
t task( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRa ' s
c C s@ | j j | ƒ | j r< | j r< | j j ƒ d | _ n d S( sF
Remove a L{CooperativeTask} from this L{Cooperator}.
N( Ru t removeRz R/ R ( R
R„ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRg 4 s
c c sX | j ƒ } xE | j rS x# | j D] } | V| ƒ r" d Sq" Wt | j ƒ | _ q Wd S( s
Yield all L{CooperativeTask} objects in a loop as long as this
L{Cooperator}'s termination condition has not been met.
N( Rx Ru Rw Rv ( R
t
terminatorR ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt _tasksWhileNotStopped? s c C s8 d | _ x | j ƒ D] } | j ƒ q W| j ƒ d S( s)
Run one scheduler tick.
N( R Rz R‡ Rs R* ( R
t taskObj( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt _tickM s c C sJ | j s t | _ d S| j d k rF | j rF | j | j ƒ | _ n d S( N( R| R& t _mustScheduleOnStartRz R Ru Ry R‰ ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR* X s
c C s2 t | _ t | _ | j r. | ` | j ƒ n d S( s)
Begin scheduling steps.
N( R- R{ R& R| RŠ R* ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR, ` s
c C sn t | _ x- | j D]" } | j t ƒ t t ƒ ƒ ƒ q Wg | _ | j d k rj | j j ƒ d | _ n d S( s
Stop scheduling steps. Errback the completion Deferreds of all
iterators which have been added and forget about them.
N( R& R{ Ru Rl RM R Rz R R/ ( R
Rˆ ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR1 k s
N( RE RI RJ RS RY R& R R R‚ Rƒ Ra Rg R‡ R‰ R- RŠ R* R, R1 ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRt ç s
c C s
t j | ƒ S( s³
Cooperatively iterate over the given iterator, dividing runtime between it
and all other iterators which have been passed to this function and not yet
exhausted.
( t _theCooperatorR‚ ( Rb ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR‚ } s c C s
t j | ƒ S( sõ
Start running the given iterator as a long-running cooperative task, by
calling next() on it as a periodic timed event.
@param iterator: the iterator to invoke.
@return: a L{CooperativeTask} object representing this task.
( R‹ Rƒ ( Rb ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRƒ ‡ s t Clockc B s] e Z d Z e e ƒ d Z d „ Z d „ Z d „ Z d „ Z d „ Z
d „ Z d „ Z RS( s×
Provide a deterministic, easily-controlled implementation of
L{IReactorTime.callLater}. This is commonly useful for writing
deterministic unit tests for code which schedules events using this API.
g c C s
g | _ d S( N( t calls( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR ž s c C s | j S( s&
Pretend to be time.time(). This is used internally when an operation
such as L{IDelayedCall.reset} needs to determine a a time value
relative to the current time.
@rtype: C{float}
@return: The time which should be considered the current time.
( t rightNow( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR ¢ s c C s | j j d „ ƒ d S( sR
Sort the pending calls according to the time they are scheduled.
c S s t | j ƒ | j ƒ ƒ S( N( t cmpt getTime( R t b( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRn ² s N( R t sort( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt
_sortCalls® s c O sU t j | j ƒ | | | | | j j d „ | j ƒ } | j j | ƒ | j ƒ | S( sL
See L{twisted.internet.interfaces.IReactorTime.callLater}.
c S s d S( N( R ( t c( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRn ¼ s ( R t DelayedCallR R R… Rd R“ ( R
t whent whatR R
t dc( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyR< µ s
c C s | j S( sQ
See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls}
( R ( R
( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt getDelayedCallsà s c C s‡ | j | 7_ | j ƒ xg | j r‚ | j d j ƒ | j ƒ k r‚ | j j d ƒ } d | _ | j | j | j Ž | j ƒ q Wd S( sô
Move time on this clock forward by the given amount and run whatever
pending calls should be run.
@type amount: C{float}
@param amount: The number of seconds which to advance this clock's
time.
i i N(
RŽ R“ R R R t popt calledRG t argsR
( R
t amountR. ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt advanceÊ s
+ c C s" x | D] } | j | ƒ q Wd S( so
Advance incrementally by the given set of times.
@type timings: iterable of C{float}
N( Rž ( R
t timingsR ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt pumpÜ s
(
RE RI RJ R R RŽ R R R“ R< R™ Rž R ( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRŒ ” s
c sV ‡ f d † } t j | ƒ } | j ‡ ‡ ‡ f d † ƒ | j | | j d ƒ ‰ | S( s
Call the given function after a certain period of time has passed.
@type clock: L{IReactorTime} provider
@param clock: The object which will be used to schedule the delayed
call.
@type delay: C{float} or C{int}
@param delay: The number of seconds to wait before calling the function.
@param callable: The object to call after the delay.
@param *args: The positional arguments to pass to C{callable}.
@param **kw: The keyword arguments to pass to C{callable}.
@rtype: L{defer.Deferred}
@return: A deferred that fires with the result of the callable when the
specified time has elapsed.
c s ˆ j ƒ d S( N( R/ ( R( ( t delayedCall( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt deferLaterCancelý s c s
ˆ ˆ ˆ Ž S( N( ( t ignored( t callableRœ R
( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyRn s N( R R' R9 R< R0 R ( R t delayR¤ Rœ R
R¢ R+ ( ( R¤ Rœ R¡ R
s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt
deferLaterç s
R‚ R¦ ( ( ($ RJ t typet
__metaclass__RT t zope.interfaceR t twisted.pythonR t twisted.python.failureR R R R t twisted.internet.interfacesR R t ExceptionRL RM RN RO RP RQ RR t objectRS RW RY RZ Rt R‹ R‚ Rƒ RŒ R¦ t __all__( ( ( s9 /usr/lib/python2.7/dist-packages/twisted/internet/task.pyt <module> s: â
¤”
S