Reset _observed events. Remove self from observers.
        :return: Nothing
5943
def forget(self):
        
        self._observed_events = {}
        if self in self._observers:
            self._observers.remove(self)
305220
def remove_all_listeners(self, event=None):
        
        if event is not None:
            self._events[event] = OrderedDict()
        else:
            self._events = defaultdict(OrderedDict)
749586
def remove_event_handler(self, callback, event=None):
        
        found = 0
        if event and not isinstance(event, type):
            event = type(event)

        i = len(self._event_builders)
        while i:
            i -= 1
            ev, cb = self._event_builders[i]
            if cb == callback and (not event or isinstance(ev, event)):
                del self._event_builders[i]
                found += 1

        return found
1339305
def notifyObservers(self, arg=None):
        ''''''

        self.mutex.acquire()
        try:
            if not self.changed:
                    return
            # Make a local copy in case of synchronous
            # additions of observers:
            localArray = self.obs[:]
            self.clearChanged()
        finally:
            self.mutex.release()
        # Update observers
        for observer in localArray:
            observer.update(self, arg)
1147282
function(updater) {
                    for (var name in readInfo.observed) {
                        var ob = readInfo.observed[name];
                        ob.obj.unbind(ob.event, onchanged);
                    }
                }
585755
private void resetEvents()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "resetEvents");

        // Reset all callbacks
        PRE_COMMIT_ADD = null;
        PRE_COMMIT_REMOVE = null;
        POST_COMMIT_ADD_1 = null;
        POST_COMMIT_ADD_2 = null;
        POST_COMMIT_REMOVE_1 = null;
        POST_COMMIT_REMOVE_2 = null;
        POST_COMMIT_REMOVE_3 = null;
        POST_COMMIT_REMOVE_4 = null;
        POST_ROLLBACK_ADD_1 = null;
        POST_ROLLBACK_ADD_2 = null;
        POST_ROLLBACK_REMOVE_1 = null;
        POST_ROLLBACK_REMOVE_2 = null;
        POST_ROLLBACK_REMOVE_3 = null;
        POST_ROLLBACK_REMOVE_4 = null;
        UNLOCKED_1 = null;
        UNLOCKED_2 = null;
        UNLOCKED_3 = null;
        PRE_UNLOCKED_1 = null;
        PRE_UNLOCKED_2 = null;
        REFERENCES_DROPPED_TO_ZERO = null;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "resetEvents");
    }
519289
def destroy(self):
        
        self.disconnect_all_signals()
        controller_names = [key for key in self.__child_controllers]
        for controller_name in controller_names:
            self.remove_controller(controller_name)
        self.relieve_all_models()
        if self.parent:
            self.__parent = None
        if self._view_initialized:
            # print(self.__class__.__name__, "destroy view", self.view, self)
            self.view.get_top_widget().destroy()
            self.view = None
            self._Observer__PROP_TO_METHS.clear()  # prop name --> set of observing methods
            self._Observer__METH_TO_PROPS.clear()  # method --> set of observed properties
            self._Observer__PAT_TO_METHS.clear() # like __PROP_TO_METHS but only for pattern names (to optimize search)
            self._Observer__METH_TO_PAT.clear()  # method --> pattern
            self._Observer__PAT_METH_TO_KWARGS.clear()  # (pattern, method) --> info
            self.observe = None
        else:
            logger.warning("The controller {0} seems to be destroyed before the view was fully initialized. {1} "
                           "Check if you maybe do not call {2} or there exist most likely threading problems."
                           "".format(self.__class__.__name__, self.model, ExtendedController.register_view))
166568
function () {
                        for (var name in observing) {
                            var ob = observing[name];
                            ob.observe.obj.unbind(ob.observe.attr, onchanged);
                            delete observing[name];
                        }
                    }
759490
def resetMonitors(self):
        
        Debug.error("*** BE AWARE: experimental - might not work ***")
        Debug.error("Re-evaluation of the monitor setup has been requested")
        Debug.error("... Current Region/Screen objects might not be valid any longer")
        Debug.error("... Use existing Region/Screen objects only if you know what you are doing!")
        self.__init__(self._screenId)
        self.showMonitors()
1330801
def disable(self):
        

        self.ticker_text_label.hide()
        if self.current_observed_sm_m:
            self.stop_sm_m_observation(self.current_observed_sm_m)
678304
def reset(self):
        
        self.counter += 1
        local_counter = self.counter

        def timer_timeout():
            if self.counter == local_counter and self.running:
                self.callback()

        self.loop.call_later(self.timeout, timer_timeout)
532499
def reset(self, indices=None):
    
    if indices is None:
      indices = tf.range(len(self._batch_env))
    observ_dtype = self._parse_dtype(self._batch_env.observation_space)
    observ = tf.py_func(
        self._batch_env.reset, [indices], observ_dtype, name='reset')
    observ = tf.check_numerics(observ, 'observ')
    reward = tf.zeros_like(indices, tf.float32)
    done = tf.zeros_like(indices, tf.bool)
    with tf.control_dependencies([
        tf.scatter_update(self._observ, indices, observ),
        tf.scatter_update(self._reward, indices, reward),
        tf.scatter_update(self._done, indices, done)]):
      return tf.identity(observ)
1002472
def removeObserver(self, observer):
        
        with self._lock:
            self._weak_observers.remove(weakref.ref(observer))
            if len(self._weak_observers) == 0:
                self.stopThread()
1012966
def remove(self, what, call):
        
        type = observerTypeEnum.typeOf(what)
        self._observers.remove({
                                    "observing": what,
                                    "type": type,
                                    "call": call
                                 })
1122781
def reset(self) -> None:
        
        self._overallstart = get_now_utc_pendulum()
        self._starttimes.clear()
        self._totaldurations.clear()
        self._count.clear()
        self._stack.clear()
793162
def clear(self):
        '''  '''
        self._undos.clear()
        self._redos.clear()
        self._savepoint = None
        self._receiver = self._undos
215840
def unregister(self, observers):
        
        """

        if isinstance(observers, list) or isinstance(observers, tuple):
            for observer in observers:
                try:
                    index = self._observers.index(observer)
                    self._observers.remove(self._observers[index])
                except ValueError:
                    # logging
                    print('{observer} not in list...'.format(observer))

        elif isinstance(observers, base.Observer):
            try:
                index = self._observers.index(observers)
                self._observers.remove(self._observers[index])
            except ValueError:
                # logging
                print('{observer} not in list...'.format(observers))

        else:
            err_message = ('ConfigReader.register support'
                           'ListType, TupleType and {observer} Object.'
                           ''.format(base.Observer.__name__)
                           )

            raise ValueError(err_message)