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)