Remove all callbacks

        :param str name: Hook name
517981
def unregister_all(self, name):
        
        try:
            templatehook = self._registry[name]
        except KeyError:
            return

        templatehook.unregister_all()
630447
def remove_all_callbacks(self):
        
        for action in self.registered_shortcut_callbacks.keys():
            for callback in self.registered_shortcut_callbacks[action]:
                self.shortcut_manager.remove_callback_for_action(action, callback)
        # delete all registered shortcut callbacks
        self.registered_shortcut_callbacks = {}
652599
public void removeCallbacks(Runnable r) {
        assert handler != null;
        if (!sanityCheck("removeCallbacks " + r)) {
            return;
        }
        handler.removeCallbacks(r);
    }
695567
def _remove_session_callback(self, callback_obj, originator):
        ''' 

        '''
        try:
            callback_objs = [callback_obj]
            self._session_callbacks.remove(callback_obj)
            for cb, cb_objs in list(self._callback_objs_by_callable[originator].items()):
                try:
                    cb_objs.remove(callback_obj)
                    if not cb_objs:
                        del self._callback_objs_by_callable[originator][cb]
                except KeyError:
                    pass
        except KeyError:
            raise ValueError("callback already ran or was already removed, cannot be removed again")
        # emit event so the session is notified and can remove the callback
        for callback_obj in callback_objs:
            self._trigger_on_change(SessionCallbackRemoved(self, callback_obj))
867854
def unregister_callback(callback_id):
    """"""
    global _callbacks
    obj = _callbacks.pop(callback_id, None)
    threads = []
    if obj is not None:
        t, quit = obj
        quit.set()
        threads.append(t)
    for t in threads:
        t.join()
644334
public function clearHooks($name = null)
    {
        if (!is_null($name) && isset($this->hooks[(string) $name])) {
            $this->hooks[(string) $name] = array(array());
        } else {
            foreach ($this->hooks as $key => $value) {
                $this->hooks[$key] = array(array());
            }
        }
    }
900914
def remove_hook(self, key_name, hook_name):
        """"""
        kf = self.dct[key_name]
        if 'hooks' in kf:
            if hook_name in kf['hooks']:
                return kf['hooks'].pop(hook_name)
558755
def remove_callback(self, callback):
        """"""
        if callback in self._async_callbacks:
            self._async_callbacks.remove(callback)
983470
def off(hook_type, name = ANY_STATE, &callback)
      sync_exclusive do
        hooks.unregister hook_type, name, callback
      end
    end
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
1201738
def clean(self):
        
        if self.event not in HOOK_EVENTS.keys():
            raise ValidationError(
                "Invalid hook event {evt}.".format(evt=self.event)
            )
1020584
def off(self, name, callback, once=False):
        

        if name not in self.event_listeners:
            return

        self.event_listeners[name].remove((callback, once))
398274
@SuppressWarnings("WeakerAccess")
    public void removeWeakCallback(@NonNull Callback callback) {
        for (int i = mCallbacks.size() - 1; i >= 0; i--) {
            Callback currentCallback = mCallbacks.get(i).get();
            if (currentCallback == null || currentCallback == callback) {
                // found callback, or empty weak ref
                mCallbacks.remove(i);
            }
        }
    }
328490
def remove_argument(self, name):
        
        for index, arg in enumerate(self.args[:]):
            if name == arg.name:
                del self.args[index]
                break
        return self
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
236792
def remove_handler(self, name):
        ''' 
        '''
        index = None
        for i, h in enumerate(self.capture_handlers):
            if h['name'] == name:
                index = i

        if index is not None:
            self.capture_handlers[index]['logger'].close()
            del self.capture_handlers[index]
178322
def remove(self, name):
        """"""
        self.gui.removeAction(self._actions_dict[name].qaction)
        del self._actions_dict[name]
        delattr(self, name)