def clearFutureCallbacks(self):
""" cancel callbacks, event registrations """
for cb in self._calllaters:
self._eventmanager.cancelCallLater(cb)
for cb, event in self._registered:
self._eventmanager.unregister(cb, event)
if self.verbose and (len(self._calllaters) > 0 or len(self._registered) > 0):
print "BEM.clearFutureCallbacks: removing CL [%s], E [%s]" % (
','.join(func_name(cb) for cb in self._calllaters),
','.join('%s->%s' % (event_name(e), func_name(cb)) for cb, e in self._registered))
del self._calllaters[:]
self._registered.clear()
self._cb_to_wrapper.clear()
def wrapper(self, *args, **kw):
not_stopped = [k for k in behavior_names if not getattr(self, k).stopped]
wanted_func_name = func_name(f)
for conflicted in not_stopped:
info("ERROR: Stopping %s to run %s (note - not using BD's)" % (conflicted, wanted_func_name))
getattr(self, conflicted).stop() # TODO - onDone chain those things
return f(self, *args, **kw)
def wrapper(self, *args, **kw):
if hasattr(self, '_once_per_step_time') and self._world.time == self._once_per_step_time:
print "ERROR: called twice per round: %s" % func_name(f)
import pdb; pdb.set_trace()
return
self._once_per_step_time = self._world.time
self._last_tb = gettb()
return f(self, *args, **kw)
def register_oneshot(self, callback, event):
def on_one_event():
if self.verbose:
info( "EventManager: one shot removal, before: %s, %s" % (
len(self._events[event]), self._events[event]))
self.unregister(on_one_event, event)
if self.verbose:
info( "EventManager: one shot removal, after: %s, %s" % (
len(self._events[event]), self._events[event]))
callback()
on_one_event.func_name = 'on_one_event__%s' % (func_name(callback))
self.register(on_one_event, event)
def _start(self, firstTime, targets, center_on_targets,
timeout, timeoutCallback, searchPlannerMaker):
'''
Search fo the objects in /targets/.
If /center_on_targets/ is True, center on those objects.
If a /timeout/ is provided, quit the search after that many seconds.
If a /timeoutCallback/ is provided, call that when and if a timeout occurs.
'''
self._reset()
# Forget where you've previously seen these objects - you wouldn't be looking for them if they were still there.
# TODO - history? (i.e. do keep these things, but with times - that would be perfect for
# later applying a filter, i.e. kalman or particle or whatever. The localizer would keep track of those things).
for target in targets:
target.centered_self.clear()
self.log("search started for %s %s, seenTargets = %s." % (','.join([
'%s%s%s' % (t.name, ' sighted?! ' if t.centered_self.sighted else '',
' sighted_centered?! ' if t.centered_self.sighted_centered else '')
for t in targets]),
'with centering' if center_on_targets else 'no centering',
func_name(self._seenTargets)))
self._search_count[0] += 1
self.targets = targets[:]
self._center_on_targets = center_on_targets
self._timeoutCallback = timeoutCallback
# Register for the timeout, if one has been asked for.
if not timeout is None:
self._eventmanager.callLater(timeout, self._onTimeout)
# For each target you are searching for, have a callback lined up for the event of seeing it.
for target in targets:
event = target.in_frame_event
callback = lambda obj=target, event=event: self._onSeen(obj, event)
self._eventmanager.register(callback, event)
self._eventToCallbackMapping[event] = callback
# Launch the search, according to some search strategy. Do this after setting self.targets, so it can decide
# based on the searched for targets.
self._searchPlanner = searchPlannerMaker(self, center_on_targets)
self._eventmanager.callLater(0, self._nextSearchMove) # The centered_selves have just been cleared. # TODO: Necessary.
# shortcut if we already see some or all of the targets
for target in self.targets:
if target.seen:
self._onSeen(target, target.in_frame_event) # TODO - recently_seen?
def register(self, callback, event):
""" set a callback on an event.
"""
# add to _callbacks
assert(callable(callback))
if callback not in self._callbacks:
self._callbacks[callback] = set()
if event in self._callbacks[callback]:
if burst.options.verbose_reregister:
info( "WARNING: harmless re-register of %s to %s" % (func_name(callback), event_name(event)))
return
self._callbacks[callback].add(event)
# add to _events
self._events[event].add(callback)
if self.verbose:
info( "EventManager: #_events[%d] = %s" % (event, len(self._events[event])))
def _printOnDone(self, cb):
print "BurstDeferredMaker: short circuit of %s" % func_name(cb)
def _applyIfNotStopped(self, f, args, kw):
if self.stopped:
print "%s, %s: Who is calling me at this time? I am stopped" % (self, func_name(f))
return
return apply(f, args, kw)
