A convenience function which pops a key k from source to dest.
    None values are not passed on.  If k already exists in dest an
    error is raised.
6078
def pop_to(source, dest, key, name=None):
    
    value = source.pop(key, None)
    if value is not None:
        safe_setitem(dest, key, value, name=name)
    return value
1301477
def bitop_not(self, dest, key):
        """"""
        return self.execute(b'BITOP', b'NOT', dest, key)
530448
def pop(self):
        
        result = self.redis.spop(self.key)
        if result is None:
            raise KeyError

        return self._unpickle(result)
12111
def pop_arguments(instr, stack):
    
    needed = instr.stack_effect
    if needed >= 0:
        raise DecompilationError(
            "%s is does not have a negative stack effect" % instr
        )

    for popcount, to_pop in enumerate(reversed(stack), start=1):
        needed += to_pop.stack_effect
        if not needed:
            break
    else:
        raise DecompilationError(
            "Reached end of stack without finding inputs to %s" % instr,
        )

    popped = stack[-popcount:]
    stack[:] = stack[:-popcount]

    return popped
11965
function del(/* key-1, key-N, req */) {
  var args = slice.call(arguments, 0)
    , req = typeof args[args.length-1] === 'object' ? args.pop() : null;
  var deleted = 0;
  for(var i = 0;i < args.length;i++) {
    if(this.keyExists(args[i])) {
      this.delKey(args[i], req);
      deleted++;
    }
  }
  return deleted;
}
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
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
490997
def pop(self, key, default=_marker):
        
        try:
            popped = self[key]
            del self[key]
            return popped
        except KeyError:
            if default == _marker:
                raise
            return default
1155599
def get_from_human_key(self, key):
        """"""
        if key in self._identifier_map:
            return self._identifier_map[key]
        raise KeyError(key)
483754
def pop_int(self, key: str, default: Any = DEFAULT) -> int:
        
        value = self.pop(key, default)
        if value is None:
            return None
        else:
            return int(value)
651892
def fromkeys(cls, iterable, value, **kwargs):
        
        return cls(((k, value) for k in iterable), **kwargs)
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
546912
def popdict(src, keys):
    
    new = {}
    for key in keys:
        if key in src:
            new[key] = src.pop(key)
    return new
907690
def des(clas,keyblob,valblob):
    ""
    raise NotImplementedError("don't use tuples, it breaks __eq__. this function probably isn't used in real life")
    raw_keyvals=msgpack.loads(keyblob)
    (namespace,version),keyvals=raw_keyvals[:2],raw_keyvals[2:]
    if namespace!=clas.NAMESPACE or version!=clas.VERSION:
      raise TypeError('des_mismatch got %s want %s'%((namespace,version),(clas.NAMESPACE,clas.VERSION)))
    vals=tuple(msgpack.loads(valblob))
    clas.type_check(zip(*clas.KEY)[1],keyvals,'KEY')
    clas.type_check(zip(*clas.VALUE)[1],vals,'VALUE')
    return clas(tuple(keyvals),vals)
23791
def munge(self, k, v):
        """"""
        if '_config' in self.proxy and k in self.proxy['_config']:
            config = self.proxy['_config'][k].unwrap()
        else:
            config = default_cfg
        return {
            'key': k,
            'reg': self._reg_widget,
            'unreg': self._unreg_widget,
            'gett': self.proxy.__getitem__,
            'sett': self.set_value,
            'listen': self.proxy.connect,
            'unlisten': self.proxy.disconnect,
            'config': config
        }
1316925
def get(self, key: K) -> TOption[T]:
        
        return TOption(self[key]) if key in self else TOption(None)
257688
def _take(d, key, default=None):
    
    if key in d:
        cmd = d[key]
        del d[key]
        return cmd
    else:
        return default