Returns all keys that have been removed.

        If the keys are in child dictionaries they will be represented with
        . notation
773817
def removed(self):
        '''
        
        '''
        def _removed(diffs, prefix):
            keys = []
            for key in diffs.keys():
                if isinstance(diffs[key], dict) and 'old' not in diffs[key]:
                    keys.extend(_removed(diffs[key],
                                       prefix='{0}{1}.'.format(prefix, key)))
                elif diffs[key]['new'] == self.NONE_VALUE:
                    keys.append('{0}{1}'.format(prefix, key))
                elif isinstance(diffs[key]['new'], dict):
                    keys.extend(
                        _removed(diffs[key]['new'],
                                 prefix='{0}{1}.'.format(prefix, key)))
            return keys

        return sorted(_removed(self._diffs, prefix=''))
553864
def dict_diff(old, new):
    
    old_keys = viewkeys(old)
    new_keys = viewkeys(dict(new))
    out = {}
    for key in new_keys - old_keys:
        out[key] = new[key]
    for key in old_keys - new_keys:
        out[key] = None
    for key in old_keys & new_keys:
        if old[key] != new[key]:
            out[key] = new[key]
    return out
388622
def _remove_keywords(d):
    
    return { k:v for k, v in iteritems(d) if k not in RESERVED }
290132
def _remove_refs(self, keys):
        
        # remove direct refs
        for key in keys:
            del self.relations[key]
        # then remove all entries from each child
        for cached in self.relations.values():
            cached.release_references(keys)
15146
private void removeExistingKeys(Collection<Data> keys) {
        if (keys == null || keys.isEmpty()) {
            return;
        }
        Storage storage = recordStore.getStorage();
        keys.removeIf(storage::containsKey);
    }
1024557
public String getAndRemoveStr(String... keys) {
		Object value = null;
		for (String key : keys) {
			value = remove(key);
			if (null != value) {
				break;
			}
		}
		return (String) value;
	}
1317766
def unused(self, _dict):
        
        for key, value in _dict.items():
            if value is None:
                del _dict[key]
        return _dict
1169728
def delete(self,removed):
        
        if isinstance(removed,dict):
            # remove a single record
            removed = [removed]
        else:
            # convert iterable into a list (to be able to sort it)
            removed = [ r for r in removed ]
        if not removed:
            return 0
        _ids = [ r['__id__'] for r in removed ]
        _ids.sort()
        sql = "DELETE FROM %s WHERE __id__ IN (%s)" %(self.name,
            ",".join([str(_id) for _id in _ids]))
        self.cursor.execute(sql)
        return len(removed)
860196
def clear(self):
        """"""
        for k in list(self.keys()):
            if k not in self.extrakeys:
                del self[k]
747623
def ensure_keys(walk, *keys):
    
    all_retrieved = True
    for k in keys:
        try:
            walk(k)
        except WalkKeyNotRetrieved:
            all_retrieved = False
    return all_retrieved
301134
def forget(self, *keys):
        
        keys = reversed(sorted(keys))

        for key in keys:
            del self[key]

        return self
167226
def _clean_up_key(self, key):
        
        for n in self.naughty: key = key.replace(n, '_')
        return key
732256
protected function getRemovedKeys()
    {
        $removedKeys = [];

        foreach ($this->originalAttributes as $key=>$value) {

            if (!array_key_exists($key, $this->attributes)) {
                $removedKeys[] = $key;
                continue;
            }
        }

        return $removedKeys;
    }
875606
def all_keys(self):
        '''
        
        '''
        keys = self.list_keys()
        keys.update(self.local_keys())
        return keys
85265
def is_complete(self, keys=None, alias=None):
        
        return any(k not in list(self.data.keys()) for k in keys)
247343
def filter(self, **kwargs):
        
        keys = self.filter_keys(**kwargs)
        return self.keys_to_values(keys)
796682
def _sorted_keys(self):
        

        try:
            keys = self._cache['sorted_keys']
        except KeyError:
            keys = self._cache['sorted_keys'] = sorted(self.keys(), key=parse_version)

        return keys