Remove a key-value store entry.

        :param key: string
353768
def remove_kv_store(self, key):
        
        data = {
            'operation': 'DELETE',
            'key': key
        }
        return self.post(self.make_url("/useragent-kv"), data=to_json(data),
                         headers=self.default_headers).text
1036606
def kremove(self, key, value=None):
        
        for item in self:
            if value is None:
                # Just pop the key if present,
                # otherwise return None
                # (shortcut to ignore the exception)
                item.pop(key, None)
            else:
                try:
                    # Use the key as a set
                    item[key].remove(value)
                    # If the set contains a single element
                    # just store the latter
                    if len(item[key]) == 1:
                        item[key] = item[key].pop()
                except KeyError:
                    # This happens when the item
                    # does not contain the key
                    pass
                except AttributeError:
                    # This happens when the key is not a set
                    # and shall be removed only if values match
                    if item[key] == value:
                        item.pop(key)
925814
def clear_lock(self, key):
        
        lock_path = self._get_lock_path(key)
        os.remove(lock_path)
1257699
def delete(key)
      file = filename key
      File.delete file if File.exist? file
    end
272899
function (key) {
      var entry = this._byKey.del(key);
      if (!entry) return;

      delete this._byOrder[entry.index];
      this._len--;

      if (this._len === 0) {
        this._head = this._tail = 0;
      } else {
        // update most index if it was most lecently used entry
        if (entry.index === this._head - 1) this._pop();
        // update least index if it was least lecently used entry
        if (entry.index === this._tail) this._shift();
      }

      return entry.val;
    }
371821
def remove_key(self, store_key):
        
        self._remove_cache[store_key] = True
        if store_key in self._add_cache:
            for hash_value in self._add_cache[store_key]:
                self._reverse_add_cache[hash_value].remove(store_key)
            del self._add_cache[store_key]
        if store_key in self._undefined_cache:
            del self._undefined_cache[store_key]
991125
def removeSessionWithKey(self, key):
        
        self.store.query(
            PersistentSession,
            PersistentSession.sessionKey == key).deleteFromStore()
149019
def delete(self, key):
        
        obj = self._get_content()
        obj.pop(key, None)

        self.write_data(self.path, obj)
1844
def delete(key, parameters = {})
      @stores.map {|s| s.delete(key, parameters)}.any?
    end
943587
function remove (key) {
  if (typeof key !== 'string') {
    throw new Error('Invalid key provided for remove')
  }

  const keys = [`${prefix}${key}`, `${expire}${key}`]
  return storage.remove(keys)
}
1047454
function remove(key) {
           if (!isReserved(key)) {
             if (typeof data[key] !== "undefined") {
               delete data[key];

               if (me.device.localStorage === true) {
                 localStorage.removeItem("me.save." + key);
                 localStorage.setItem("me.save", JSON.stringify(Object.keys(data)));
               }
             }
           }
         }
1370604
def unload_key(self, key):
        """"""
        key_hash = self._hash_for_key(key)
        if key in self:
            del self._cache[key_hash]
928543
def remove(self, key):
        
        self.raise_error_if_not_open()

        if key in self._file:
            del self._file[key]
165780
def pop(self, key, *args, **kwargs):
        
        try:
            val = self[key]
        except KeyError:
            if len(args):
                return args[0]
            if "default" in kwargs:
                return kwargs["default"]
            raise

        try:
            del(self[key])
        except KeyError:
            pass

        return val
249584
function(key) {
            var s = Storage.storage();
            if (s == null) {
                return false;
            }
            s.removeItem(key);
            return true;
        }
809959
def delete_value(self, key):
        
        response = {}
        response['status'] = False
        response['msg'] = "key does not exist"

        file_cache = self.read_file()
        if key in file_cache:
            del file_cache[key]
            self.update_file(file_cache)
            response['status'] = True
            response['msg'] = "success"
        return response
1229708
private void removeEntry(String key) {
        CacheHeader entry = mEntries.get(key);
        if (entry != null) {
            mTotalSize -= entry.size;
            mEntries.remove(key);
        }
    }