Unset on all references

        :param key: The key to be unset
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)
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)
1101313
public function offsetUnset( $key )
    {
        $key = strtolower( $key );
        if ( array_key_exists( $key, $this->lookup ) )
        {
            unset( $this->map[$this->lookup[$key]] );
            unset( $this->lookup[$key] );
        }
    }
367144
public function offsetUnset($key)
    {
        if (isset($this->keys[$key])) {
            unset($this->values[$key], $this->keys[$key]);
        }
    }
381873
def unset(self, key):
    

    try:
      try:
        self.bucket.delete(key)
      except couchbase.exception.MemcachedError, inst: 
        if str(inst) == "Memcached error #1:  Not found":
          # for some reason the py cb client raises an error when
          # a key isnt found, instead we just want a none value.
          return
        else:
          raise
      except:
        raise
    except:
      raise
1080435
def clear(self, key):
        # type: (Hashable) -> DataLoader
        
        cache_key = self.get_cache_key(key)
        self._promise_cache.pop(cache_key, None)
        return self
1033547
public function offsetUnset($key)
    {
        $this->checkKey($this->key_type, $key);
        unset($this->container[$key]);
    }
870358
def forget(self, key):
        
        path = self._path(key)

        if os.path.exists(path):
            os.remove(path)

            return True

        return False
706206
def del_reference(self, source, target, **kwargs):
        
        rc = api.get_tool("reference_catalog")
        uid = api.get_uid(target)
        rc.deleteReference(source, uid, self.relationship)
        # unlink the version of the reference
        self.link_version(source, target)
224660
def del_key(self, ref):
        
        if ref not in self.keys:
            response = self.request("client_del_key %s" % (ref))
            self.keys.remove(ref)
            if "success" in response:
                return None
            else:
                return response
1227708
def pop (self, key):
        """"""
        if key in self._keys:
            self._keys.remove(key)
        super(ListDict, self).pop(key)
409340
def pop(self, key, default=NONE):
        
        if key in self:
            self._list_remove(key)
            return self._pop(key)
        else:
            if default is NONE:
                raise KeyError(key)
            else:
                return default
1220274
def copy(self, key):
        
        copy = Set(key=key, db=self.db)
        copy.clear()
        copy |= self
        return copy
518703
def unstore(self, key, pk, value):
        

        self.connection.zrem(key, pk)
1066894
public function offsetUnset($key)
    {
        $key = $this->normalize($key);
        unset($this->bindings[$key], $this->instances[$key], $this->resoleved[$key]);
    }
376836
def delete(self, key):
    '''
    '''
    try:
      del self._collection(key)[key]

      if len(self._collection(key)) == 0:
        del self._items[str(key.path)]
    except KeyError, e:
      pass
784421
def del_key(self, key, key_to_delete):
        ""
        v = self.get(key)
        if key_to_delete in v:
            del v[key_to_delete]
            self.set(key, v)