Remove the key and return the associated value or default if not
            found

            Args:
                key (str): The key to remove
                default (obj): The value to return if key is not present
491021
def pop(self, key, default=None):
        
        return self._dictionary.pop(key.lower(), default)
1000369
def _get_dict_default(obj, key):
    
    try:
        return obj[key]
    except Exception as f:
        pass

    try:
        if float(key) == round(float(key), 0):
            return obj[int(key)]
    except Exception as f:
        pass

    return NullType(obj, key)
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)
1176932
def _default(self, key, default=None):
        
        try:
            value = self.theme.themeables.property(key)
        except KeyError:
            value = None

        return value if value is not None else default
1091979
function(obj, key) {
		var value;
		for (var i = 2; i < arguments.length; i++) {
			value = arguments[i];
			if (value !== undefined) {
				obj[key] = value;
				break;
			}
		}

		if (value === undefined) delete obj[key];

		return obj;
	}
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)
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
162505
def pop(self, key):
        """"""
        arr = dict.pop(self, key).copy()
        self.remover(key)
        return arr
971679
def get_json(self, key, default=None):
        
        value = self.get_str(key)
        if value is not None:
            value = from_json(value)
            if value is not None:
                return value

        if isinstance(default, (dict, list)):
            return default

        return from_json(default)
449412
def get(self, key, default=None):
        
        result = self._loads(self._client.get(self.get_key(key)))
        if result is not None:
            return result
        else:
            return default or self._default
334879
def remove_key(key: str, persists: bool = True):
    

    environ.configs.remove(key, include_persists=persists)
    environ.configs.save()

    environ.log(
        '[REMOVED]: "{}" from configuration settings'.format(key)
    )
1330979
def get_true (self, key, default):
        
        if key not in self or not self[key]:
            return default
        return self[key]
983959
def _api_delete(self, api_key=None, **kwargs):
		
		api_key = api_key or self.default_api_key

		return self.api_retrieve(api_key=api_key).delete(**kwargs)
1285726
def _dig_get(obj, default, *key):
    
    key = _splice_index(*key)

    if len(key) == 1:
        if isinstance(key[0], str):
            return obj.get(key[0], default)
        else:
            try:
                return obj[key[0]]
            except IndexError:
                return default

    return _dig_get(obj[key[0]], default, *key[1:])
1206054
def dict_pop_or(d, key, default=None):
    
    val = default
    with suppress(KeyError):
        val = d.pop(key)
    return val
56097
def _get_value(obj, key, default=missing):
    
    if "." in key:
        return _get_value_for_keys(obj, key.split("."), default)
    else:
        return _get_value_for_key(obj, key, default)
57151
def pop(self, key, default=None):
        ""
        if not isinstance(key, tuple): key = (key,)
        return self.data.pop(key, default)