Remove an item from the cache
345944
def delete(self, *raw_args, **raw_kwargs):
        
        args = self.prepare_args(*raw_args)
        kwargs = self.prepare_kwargs(**raw_kwargs)
        key = self.key(*args, **kwargs)
        item = self.cache.get(key)
        if item is not None:
            self.cache.delete(key)
581013
def clear(self):
        """"""
        if self._cache is not None:
            with self._cache as c:
                c.clear()
                c.out_deque.clear()
960658
def delete(self, item):
        """"""
        uri = "/%s/%s" % (self.uri_base, utils.get_id(item))
        return self._delete(uri)
1026944
def remove(self, item):
        
        index = self.index(item)
        self.real_list.remove(item)
        self.observer(UpdateType.DELETED, item, index)
758388
def clear_cache(self):
        """"""
        self.logger.debug("Clearing cache")
        if os.path.isdir(self.songcache_dir):
            for filename in os.listdir(self.songcache_dir):
                file_path = os.path.join(self.songcache_dir, filename)
                try:
                    if os.path.isfile(file_path):
                        os.unlink(file_path)
                except PermissionError:
                    pass
                except Exception as e:
                    logger.exception(e)
        self.logger.debug("Cache cleared")
357606
def delete(self, key: str) -> None:
        
        if key in self._write_cache():
            self._write_cache()[key].delete()
            del self._write_cache()[key]

        if key in self._cache():
            del self._cache()[key]

        self._flush_external_cache()
151827
public int remove(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    synchronized (this) {
      Item prev = null;
      for (Item item = _entries[hash]; item != null; item = item._next) {
        Object itemKey = item._key;
      
        if (itemKey == key || itemKey.equals(key)) {
          int oldValue = item._value;

          if (prev != null)
            prev._next = item._next;
          else
            _entries[hash] = item._next;

          _size--;

          return oldValue;
        }

        prev = item;
      }
    }

    return NULL;
  }
1157054
def remove_cached_item(self, path):
        
        item_path = '%s/%s/%s' % (
                current_app.static_folder,
                self.cache_folder,
                path.strip('/')
            )

        if os.path.isfile(item_path):
            os.remove(item_path)

        return True
469895
function (key) {
      if (!supported) {
        try {
          $cookieStore.remove(key);
          return true;
        } catch (e) {
          return false;
        }
      }
      storage.removeItem(key);
      return true;
    }
601447
def remove_file(self, path):
        """"""
        self.get_file(path).remove()
        self.remove_cache_buster(path)
224803
def remove_cached_item(self, path):
        
        item_path = '%s/%s' % (
                self.cache_folder,
                path.strip('/')
            )

        self.blob_service.delete_blob(self.container_name, item_path)

        while self.blob_service.exists(self.container_name, item_path):
            time.sleep(0.5)

        return True
705351
def clear_cache(self):
        """"""
        for cmd in (self.cat_file_all, self.cat_file_header):
            if cmd:
                cmd.__del__()

        self.cat_file_all = None
        self.cat_file_header = None
        return self
1187306
def delete(self, *args, **kwargs):
        """"""
        cache_key = self.make_key(args, kwargs)
        with self._cache_lock:
            try:
                del self._cache[cache_key]
            except KeyError:
                pass
952096
def remove_instance(self, item):
        """"""
        self.instances.remove(item)
        self.remove_item(item)
687496
function removeItem(key) {
    delete storage[key];
    window.name = qs.stringify(storage, prefix);

    windowStorage.length--;
  }
641427
def removeItem( self, item ):
        
        # for nodes and connections, call the prepareToRemove method before 
        # removing
        if ( isinstance( item, XNode ) or 
             isinstance( item, XNodeConnection ) ):
            # make sure this item is ok to remove
            if ( not item.prepareToRemove() ):
                return False
        
        # remove the item using the base class method
        try:
            self._cache.remove(item)
        except KeyError:
            pass
        
        # mark the scene as modified
        self.setModified(True)
        super(XNodeScene, self).removeItem(item)
        
        if not self.signalsBlocked():
            self.itemsRemoved.emit()
        
        return True
768840
def remove(self, item):
        
        with self.lock:
            if item in self.set:
                self.set.remove(item)
                return True
            return False