Unsubscribe a hook from an event
355204
def unsubscribe(self, event, hook):
        
        if hook in self._hooks[event]:
            self._hooks[event].remove(hook)
637064
def uninstall_handle_input(self):
        """"""
        if self.hooked is None:
            return
        ctypes.windll.user32.UnhookWindowsHookEx(self.hooked)
        self.hooked = None
1077386
public void unsubscribe_event(int event_id) throws DevFailed {
        //	Get callback struct for event ID
        EventCallBackStruct callbackStruct =
                getCallBackStruct(event_callback_map, event_id);
        if (callbackStruct != null) {
            removeCallBackStruct(event_callback_map, callbackStruct);
            unsubscribeTheEvent(callbackStruct);
        }
        else {
            //	If not found check if in failed map
            callbackStruct =
                    getCallBackStruct(failed_event_callback_map, event_id);
            if (callbackStruct != null)
                removeCallBackStruct(failed_event_callback_map, callbackStruct);
            else
                Except.throw_event_system_failed("API_EventNotFound",
                        "Failed to unsubscribe event, the event id (" + event_id +
                                ") specified does not correspond with any known one",
                        "EventConsumer.unsubscribe_event()");
        }
    }
244473
def __unhook_dll(self, event):
        
        debug = event.debug
        pid   = event.get_pid()
        for hook_api_stub in self.__get_hooks_for_dll(event):
            hook_api_stub.unhook(debug, pid)
1326905
def unsubscribe(self, name):
        """"""
        self._wait_for_connect()
        if name not in self.subscriptions:
            raise MeteorClientException('No subscription for {}'.format(name))
        self.ddp_client.unsubscribe(self.subscriptions[name]['id'])
        del self.subscriptions[name]
        self.emit('unsubscribed', name)
727397
function() {
      if (Explorer.hook) {
        MathJax.Hub.UnRegister.MessageHook(Explorer.hook);
        Explorer.hook = null;
      }
    }
761384
async def removeHook(self, *args, **kwargs):
        

        return await self._makeApiCall(self.funcinfo["removeHook"], *args, **kwargs)
1076000
function Off(event, method) {
      return function (target, key, descriptor) {
          key = hyphenate(key);
          var original = descriptor.value;
          descriptor.value = function offer() {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              if (original.apply(this, args) !== false) {
                  if (method) {
                      if (typeof this[method] === 'function') {
                          this.$off(event || key, this[method]);
                      }
                      else {
                          throw new TypeError('must be a method name');
                      }
                  }
                  else if (event) {
                      this.$off(event || key);
                  }
                  else {
                      this.$off();
                  }
              }
          };
      };
  }
1333129
function unbind (type, callback) {
        if (!events.has(type)) {
          throw new Error('Unknown event: ' + type);
        }

        if (typeof callback !== 'function') {
          throw new Error('Callback must be a function, instead got: ' + (typeof callback));
        }

        var eventsOfType = events.get(type, Immutable.List());

        if (eventsOfType.includes(callback)) {
          events = events.set(type, eventsOfType.delete(eventsOfType.indexOf(callback)));
        }

        return self;
      }
949770
public void unsubscribe() {
        List<InvocationHandler> handler = this.handlers.get(target);
        if (handler != null) {
            handler.remove(this.handler);
        }
    }
186204
function () {
            /*  determine parameters  */
            var params = $cs.params("unawait", arguments, {
                id: { pos: 0, req: true }
            });

            /*  unsubscribe from service event if it is not yet unsubscribed  */
            if (this._subscription(params.id))
                this.unsubscribe(params.id);
            return;
        }
990026
def unsubscribe(self, event):
        """"""
        # TODO: Automatic Unsubscription
        uuids = event.data

        if not isinstance(uuids, list):
            uuids = [uuids]

        result = []

        for uuid in uuids:
            if uuid in self.subscriptions:
                self.subscriptions[uuid].pop(event.client.uuid)

                if len(self.subscriptions[uuid]) == 0:
                    del (self.subscriptions[uuid])

                result.append(uuid)

        result = {
            'component': 'hfos.events.objectmanager',
            'action': 'unsubscribe',
            'data': {
                'uuid': result, 'success': True
            }
        }

        self._respond(None, result, event)
1067296
function() {
    this.unsubscribeAll();
    
    // Column is late-binding in attach()
    var oColumn = this.getColumn();
    if(oColumn) {
        oColumn.editor = null;
    }
    
    var elContainer = this.getContainerEl();
    Ev.purgeElement(elContainer, true);
    elContainer.parentNode.removeChild(elContainer);
}
1201738
def clean(self):
        
        if self.event not in HOOK_EVENTS.keys():
            raise ValidationError(
                "Invalid hook event {evt}.".format(evt=self.event)
            )
1373197
function unsubscribe(f) {
    return function () {

      // remove from fitties array
      fitties = fitties.filter(function (_) {
        return _.element !== f.element;
      });

      // stop observing DOM
      if (f.observeMutations) {
        f.observer.disconnect();
      }

      // reset font size to inherited size
      f.element.style.cssText = f.originalStyle;
    };
  }
1374137
def unsubscribe(self, socket_id, channel):
        """"""
        con = self._get_connection(socket_id, create=False)
        if con is not None:
            con.subscriptions.discard(channel)
        try:
            self.subscriptions[channel].discard(socket_id)
        except KeyError:
            pass
923302
def unsubscribe(self, message, handler):
        '''
        
        '''
        with self._lock:
            self._subscribers[message].remove(WeakCallable(handler))