:type cls_context: type
        :type key: str

        :rtype: None
507962
def _warn_key_unknown(cls, cls_context, key):
        

        context_name = cls_context.__name__
        warnings.warn(cls._WARNING_KEY_UNKNOWN.format(key, context_name))
1152616
def get(cls, ns, key):
        
        return getattr(db, cls.__name__).find_one(
            ConfigItem.namespace_prefix == ns,
            ConfigItem.key == key
        )
352980
def validate_key(self, key):
        
        if not key:
            name = self.__class__.__name__
            msg = "%s response missing %s" % (name, self.key_name)
            raise ValidationException(msg, self)
        elif not isinstance(key, str):
            msg = "Response contains invalid %s type" % self.key_name
            raise ValidationException(msg, type(key))
684913
def set_header(self, key: str, value: str) -> None:
        
        self.headers[key] = value
1346112
function(key, context) {
        var first, keys, subkey;
        if (typeof context === "undefined" || context === null) {
            context = this;
        }
        if (key.indexOf(".") > -1) {
            keys = key.split(".");
            first = keys.shift();
            subkey = keys.join(".");
            return this._attr_get(keys.join("."), context[first]);
        } else {
            return context[key];
        }
    }
1246864
public Object removeContext(Class<?> key) {
        // hide the context objects of a wrapped ELContext by storing a null value:
        final Object result = putContextInternal(key, null);
        return result == null ? wrapped.getContext(key) : result;
    }
587140
def get(self, key, default=None):
        
        try:
            return self[key]
        except KeyError:
            return default or self._default
1294653
def _get_context(keyspaces, connections):
    """"""

    if keyspaces:
        if not isinstance(keyspaces, (list, tuple)):
            raise ValueError('keyspaces must be a list or a tuple.')

    if connections:
        if not isinstance(connections, (list, tuple)):
            raise ValueError('connections must be a list or a tuple.')

    keyspaces = keyspaces if keyspaces else [None]
    connections = connections if connections else [None]

    return product(connections, keyspaces)
711850
def template(self, key):
        
        try:
            return self._templates[key]
        except KeyError:
            return Template.Plugins[key]
1178457
def stack_get(self, key):
        
        task = Task.current_task()
        try:
            context = task._context_stack
        except AttributeError:
            return
        if key in context:
            return context[key][-1]
1285924
def redis_key(cls, key):
        
        keyspace = cls.keyspace
        tpl = cls.keyspace_template
        key = "%s" % key if keyspace is None else tpl % (keyspace, key)
        return cls.keyparse.encode(key)
384322
@Override
    public void putContext(@SuppressWarnings("rawtypes") Class key,
            Object contextObject) {
        if (wrappedContext == null) {
            super.putContext(key, contextObject);
        } else {
            wrappedContext.putContext(key, contextObject);
        }
    }
185447
def sourcekey(self, **kwargs):
        
        kwargs_copy = self.base_dict.copy()
        kwargs_copy.update(**kwargs)
        self._replace_none(kwargs_copy)        
        try:
            return NameFactory.sourcekey_format.format(**kwargs_copy)
        except KeyError:
            return None
737294
def getContext(self, context_name = 'default'):
		
		if context_name == 'default' and 'default' not in self.contexts:
			self('default')

		return self.contexts[context_name]
1205662
def key(self, key=""):
    
    params = join_params(self.parameters, {"key": key})

    return self.__class__(**params)
834478
def config_(cls, key, default=None):
        
        return cls._app.config.get(key, default)
106595
def item(self, key):
    
    return _item.Item(self._name, key, context=self._context)