def poll(name=None):
    global apps
    for app in apps:
        app.poll()

<timers>
  <timer script="TimerPoll" enabled="y" second="0.10" send_to="12" active_closed="y" >
  </timer>
</timers>

## I use Python 2.5.1 which has the with statement in __future__
## Python < 2.5 needs to replace the:
##     with <lock>:
##         <code>
## blocks with:
##     try:
##         <lock>.acquire()
##         <code>
##     finally:
##         <lock>.release()
## The following line must be before any other Python statements in the file:
from __future__ import with_statement

import threading
_qcode = []
_qlock = threading.RLock()

def TimerPoll(name):
    global _qcode, _qlock
    while len(_qcode):
        with _qlock:
            code, locals = _qcode.pop(0)
        exec code in globals(), locals

def TimerQueue(code, locals = {}):
    global _qcode, _qlock
    with _qlock:
        _qcode.append((code, locals))

def some_function_with_lots_of_processing():
    data = []
    world.Note("Started!")
    time.sleep(2.0) # busy, busy
    update_interim_results(data)
    time.sleep(3.0) # so much hard work
    update_final_results(data)

def update_interim_results():
    world.Note("Interim Results Available!")

def update_final_results():
    world.Note("Job's Done!")

def actual_sfwlop():
    data = []
    TimerQueue("world.Note(\"Started!\")")
    time.sleep(2.0) # busy, busy
    TimerQueue("update_interim_results(data)", { 'data': data[:] }) # making shallow copy to avoid sync and validity issues
    time.sleep(3.0) # so much hard work
    TimerQueue("update_final_results(data)", locals())

def update_interim_results(data):
    world.Note("Interim Results Available! %s" % repr(data))

def update_final_results(data):
    world.Note("Job's Done! %s" % repr(data))

def sfwlop():
    threading.Thread(target=actual_sfwlop).start()

from __future__ import with_statement
import functools, threading, types

def synchronized(p = None):
    def wrapping(f):
        @functools.wraps(f)
        def wrapper(*p, **kw):
            with lock:
                return f(*p, **kw)
        return wrapper
    if 'acquire' in dir(p) and 'release' in dir(p):
        lock = p
        return wrapping
    else:
        lock = threading.RLock()
    if isinstance(p, types.FunctionType):
        return wrapping(p)
    if isinstance(p, types.ClassType) or isinstance(p, object):
        for k in dir(p):
            if k not in p.__dict__:
                continue
            f = p.__dict__[k]
            if not isinstance(f, types.FunctionType):
                continue
            setattr(p, k, wrapping(f))
        return p
    return wrapping

@synchronized
def f():
    thread_name = threading.currentThread().getName()
    print "Only one thread can be in this function at any time! That thread is currently: %s" % thread_name
    time.sleep(2.0)
    print "%s leaving!" % thread_name

class C:
    def f():
        thread_name = threading.currentThread().getName()
        print "Only one thread can be in this function at any time! That thread is currently: %s" % thread_name
        time.sleep(2.0)
        print "%s leaving!" % thread_name
C = synchronized(C) # have to wait for Python 2.6 for the @syntax :(

myset = {}
myset[key] = true -- we just added key to the set
myset[key2] = nil -- we just removed key2 from the set

-- test for membership:
if myset[key] then
  print("the key is in the set")
end