Removes the specified key from the cauldron configs if the key exists

    :param key:
        The key in the cauldron configs object to remove
    :param value:
    :param persists:
359199
def set_key(key: str, value: typing.List[str], persists: bool = True):
    

    if key.endswith('_path') or key.endswith('_paths'):
        for index in range(len(value)):
            value[index] = environ.paths.clean(value[index])

    if len(value) == 1:
        value = value[0]

    environ.configs.put(**{key: value}, persists=persists)
    environ.configs.save()
    environ.log('[SET]: "{}" to "{}"'.format(key, value))
15533
def discard(self, key):
        
        if key in self:
            i = self.map[key]
            del self.items[i]
            del self.map[key]
            for k, v in self.map.items():
                if v >= i:
                    self.map[k] = v - 1
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
1291753
def _purge_config_file(self, key):
        
        state = self.__load_state()
        del state['remove_configs'][key]
        self.__dump_state(state)
21486
def remove(self, key):
        ''''''
        copydict = ImmutableDict()
        copydict.tree = self.tree.remove(hash(key))
        copydict._length = self._length - 1
        return copydict
1214948
def delete(self, key):
    '''
    '''
    self.cache_datastore.delete(key)
    self.child_datastore.delete(key)
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
925814
def clear_lock(self, key):
        
        lock_path = self._get_lock_path(key)
        os.remove(lock_path)
726450
public static Single<Long> remove(String cacheKey, Object value) {
        return remove(CacheService.CACHE_CONFIG_BEAN, cacheKey, value);
    }
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
1180982
def delete(self, key):
        
        if not is_string(key):
            raise Exception("Key must be string")

        if len(key) > 32:
            raise Exception("Max key length is 32")

        self.root_node = self._delete_and_delete_storage(
            self.root_node,
            bin_to_nibbles(to_string(key)))
        self._update_root_hash()
518703
def unstore(self, key, pk, value):
        

        self.connection.zrem(key, pk)
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]
108613
def pop(self, key):
        
        r = self[key]
        self.remove(key)
        return r
333865
def set(self, key, value):
        
        # the configuration changes, so we invalidate the cached config
        self._full_config = None
        self._override[key] = value
1163168
def delete(self, key, cas=0):
        
        server = self._get_server(key)
        return server.delete(key, cas)
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