Unwatches all previously specified keys
3257
async def _unwatch(self, conn):
        ""
        await conn.send_command('UNWATCH')
        res = await conn.read_response()
        return self.watching and res or True
88984
def watch(self, *keys):
        
        if self.explicit_transaction:
            raise RedisError("Cannot issue a WATCH after a MULTI")
        self.watching = True
        for key in keys:
            self._watched_keys[key] = deepcopy(self.mock_redis.redis.get(self.mock_redis._encode(key)))
15146
private void removeExistingKeys(Collection<Data> keys) {
        if (keys == null || keys.isEmpty()) {
            return;
        }
        Storage storage = recordStore.getStorage();
        keys.removeIf(storage::containsKey);
    }
483589
def clear(self):
        
        all_keys = self._find_keys_raw(settings.THUMBNAIL_KEY_PREFIX)
        if all_keys:
            self._delete_raw(*all_keys)
121657
function unwatchFile(watcher, filename) {
    if (watcher) {
        watcher.close && watcher.close();
    } else {
        fs.unwatchFile(filename);
    }
}
1040579
def remove_watcher(self, fd):
        """"""
        if not isinstance(fd, int):
            fd = fd.fileno()

        if fd not in self.callbacks:
            return

        self.callbacks.pop(fd, None)
        self.epoll.unregister(fd)
328749
public function clearWatched(): self
    {
        foreach ($this->watchedFiles as $wd) {
            inotify_rm_watch($this->inotify, $wd);
        }

        $this->watchedFiles = [];

        return $this;
    }
192488
def _remove_existing(self):
        
        for key in self._keys:
            if key in os.environ:
                LOG.debug('%r: removing old key %r', self, key)
                del os.environ[key]
        self._keys = []
498630
function unwatch (poet) {
  poet.watchers.forEach(function (watcher) {
    watcher.watcher.close();
  });
  poet.futures.forEach(function (future) {
    clearTimeout(future);
  });
  poet.watchers = [];
  poet.futures = [];
  return poet;
}
479830
function unwatchPath(path) {
    Object.keys(_watcherMap).forEach(function (keyPath) {
        if (keyPath.indexOf(path) === 0) {
            _unwatchPath(keyPath);
        }
    });
}
439181
def unset(self, key):
        
        key = key.strip().upper()
        if key not in dir(default_settings) and key not in self._defaults:
            self.logger.debug("Unset %s", key)
            delattr(self, key)
            self.store.pop(key, None)
754053
def remove_all_timers(self):
        """"""
        with self.lock:
            if self.rtimer is not None:
                self.rtimer.cancel()

            self.timers = {}
            self.heap = []
            self.rtimer = None
            self.expiring = False
647956
def remove_from_watched(self, watched):
        
        assert isinstance(watched, github.Repository.Repository), watched
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            "/repos/" + watched._identity + "/subscription"
        )
197919
protected void unsetKeyringMonitorRegistration() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "unsetKeyringMonitorRegistration");
        }
        if (keyringMonitorRegistration != null) {
            keyringMonitorRegistration.unregister();
            keyringMonitorRegistration = null;
        }
    }
1037630
def unwatch(self_,watcher):
        
        try:
            self_._watch('remove',watcher)
        except:
            self_.warning('No such watcher {watcher} to remove.'.format(watcher=watcher))
1158374
def remove_all_for(self, key):
        
        if not isinstance(key, _string_type):
            raise TypeError("Key need to be a string.")

        for idx in _range(self.__kcount[key]):
            super(VDFDict, self).__delitem__((idx, key))

        self.__omap = list(filter(lambda x: x[1] != key, self.__omap))

        del self.__kcount[key]
503138
def _prune(self):
        """"""
        delkeys = [k for k in self.keys() if k not in self.__ringbuffer]
        for k in delkeys:  # necessary because dict is changed during iterations
            super(KRingbuffer,self).__delitem__(k)