1 files changed, 104 insertions, 0 deletions
diff --git a/Doc/library/sched.rst b/Doc/library/sched.rst
new file mode 100644
index 0000000..bf3efbf
--- /dev/null
+++ b/Doc/library/sched.rst
@@ -0,0 +1,104 @@
+
+:mod:`sched` --- Event scheduler
+================================
+
+.. module:: sched
+   :synopsis: General purpose event scheduler.
+.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
+
+
+.. % LaTeXed and enhanced from comments in file
+
+.. index:: single: event scheduling
+
+The :mod:`sched` module defines a class which implements a general purpose event
+scheduler:
+
+
+.. class:: scheduler(timefunc, delayfunc)
+
+   The :class:`scheduler` class defines a generic interface to scheduling events.
+   It needs two functions to actually deal with the "outside world" --- *timefunc*
+   should be callable without arguments, and return  a number (the "time", in any
+   units whatsoever).  The *delayfunc* function should be callable with one
+   argument, compatible with the output of *timefunc*, and should delay that many
+   time units. *delayfunc* will also be called with the argument ``0`` after each
+   event is run to allow other threads an opportunity to run in multi-threaded
+   applications.
+
+Example::
+
+   >>> import sched, time
+   >>> s=sched.scheduler(time.time, time.sleep)
+   >>> def print_time(): print "From print_time", time.time()
+   ...
+   >>> def print_some_times():
+   ...     print time.time()
+   ...     s.enter(5, 1, print_time, ())
+   ...     s.enter(10, 1, print_time, ())
+   ...     s.run()
+   ...     print time.time()
+   ...
+   >>> print_some_times()
+   930343690.257
+   From print_time 930343695.274
+   From print_time 930343700.273
+   930343700.276
+
+
+.. _scheduler-objects:
+
+Scheduler Objects
+-----------------
+
+:class:`scheduler` instances have the following methods:
+
+
+.. method:: scheduler.enterabs(time, priority, action, argument)
+
+   Schedule a new event. The *time* argument should be a numeric type compatible
+   with the return value of the *timefunc* function passed  to the constructor.
+   Events scheduled for the same *time* will be executed in the order of their
+   *priority*.
+
+   Executing the event means executing ``action(*argument)``.  *argument* must be a
+   sequence holding the parameters for *action*.
+
+   Return value is an event which may be used for later cancellation of the event
+   (see :meth:`cancel`).
+
+
+.. method:: scheduler.enter(delay, priority, action, argument)
+
+   Schedule an event for *delay* more time units. Other then the relative time, the
+   other arguments, the effect and the return value are the same as those for
+   :meth:`enterabs`.
+
+
+.. method:: scheduler.cancel(event)
+
+   Remove the event from the queue. If *event* is not an event currently in the
+   queue, this method will raise a :exc:`RuntimeError`.
+
+
+.. method:: scheduler.empty()
+
+   Return true if the event queue is empty.
+
+
+.. method:: scheduler.run()
+
+   Run all scheduled events. This function will wait  (using the :func:`delayfunc`
+   function passed to the constructor) for the next event, then execute it and so
+   on until there are no more scheduled events.
+
+   Either *action* or *delayfunc* can raise an exception.  In either case, the
+   scheduler will maintain a consistent state and propagate the exception.  If an
+   exception is raised by *action*, the event will not be attempted in future calls
+   to :meth:`run`.
+
+   If a sequence of events takes longer to run than the time available before the
+   next event, the scheduler will simply fall behind.  No events will be dropped;
+   the calling code is responsible for canceling  events which are no longer
+   pertinent.
+