keys : typing.Sequence[~ModelUnsetKeys]
        Returns -> typing.Sequence[~ErrorResult]
505720
async def UnsetModelDefaults(self, keys):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='ModelManager',
                   request='UnsetModelDefaults',
                   version=2,
                   params=_params)
        _params['keys'] = keys
        reply = await self.rpc(msg)
        return reply
37570
def model_exceptions(vk, model):
    
    model['exceptions'] = {}
    model['errors'] = {}

    all_codes = model['enums']['VkResult']
    success_names = set()
    error_names = set()

    commands = [x for x in vk['registry']['commands']['command']]

    for command in commands:
        successes = command.get('@successcodes', '').split(',')
        errors = command.get('@errorcodes', '').split(',')
        success_names.update(successes)
        error_names.update(errors)

    for key, value in all_codes.items():
        if key.startswith('VK_RESULT') or key == 'VK_SUCCESS':
            continue
        name = inflection.camelize(key.lower())

        if key in success_names:
            model['exceptions'][value] = name
        elif key in error_names:
            model['errors'][value] = name
        else:
            print('Warning: return code %s unused' % key)
747623
def ensure_keys(walk, *keys):
    
    all_retrieved = True
    for k in keys:
        try:
            walk(k)
        except WalkKeyNotRetrieved:
            all_retrieved = False
    return all_retrieved
988476
def get_unset_inputs(self):
        
        return set([k for k, v in self._inputs.items() if v.is_empty(False)])
1116052
def matching_key_for(self, key):
		
		try:
			return next(e_key for e_key in self.keys() if e_key == key)
		except StopIteration:
			raise KeyError(key)
1119287
function (key) {
            var modelVal = this.getModelVal();
            modelVal = this.multiple ? modelVal : [modelVal];
            return (_.indexOf(_.map(modelVal, toStr), toStr(key)) > -1);
        }
593361
def keys
      map { |line| line.kind_of?(Array) ? line.first.key : line.key }
    end
1057926
def model_set(method_name):
    

    def model_set(value, context, **_params):
        method = getattr(context["model"], method_name)
        return _set(method, context["key"], value, (), {})

    return model_set
299736
def mget(self, *keys):
        
        return list(map(
            self._loads, self._client.hmget(self.key_prefix, *keys)))
859241
def _real_key(self, key):
        
        if key is not None:
            try:
                return key.lower()
            except AttributeError:
                raise TypeError(
                    _format("NocaseDict key {0!A} must be a string, "
                            "but is {1}", key, type(key)))

        if self.allow_unnamed_keys:
            return None

        raise TypeError(
            _format("NocaseDict key None (unnamed key) is not "
                    "allowed for this object"))
855464
def injectables_specs_for_key(self, key):
    
    mapping = self.injectables_spec_mapping
    if key not in mapping:
      raise self.NoMappingForKey(key)
    specs = mapping[key]
    assert isinstance(specs, list), (
      'invalid `injectables_spec_mapping` on {!r} for key "{}". '
      'expected a `list` but instead found a `{}`: {}'
    ).format(self, key, type(specs), specs)
    return [Address.parse(s).spec for s in specs]
186672
def missingkeys_nonstandard(block, commdct, dtls, objectlist, afield='afiled %s'):
    """"""
    afield = 'afield %s'
    for key_txt in objectlist:
        key_i = dtls.index(key_txt.upper())
        comm = commdct[key_i]
        if block:
            blk = block[key_i]
        for i, cmt in enumerate(comm):
            if cmt == {}:
                first_i = i
                break
        for i, cmt in enumerate(comm):
            if i >= first_i:
                if block:
                    comm[i]['field'] = ['%s' % (blk[i])]
                else:
                    comm[i]['field'] = [afield % (i - first_i + 1,),]
234631
def get_keys(self, lst):
        
        pk_name = self.get_pk_name()
        if self.is_pk_composite():
            return [[getattr(item, pk) for pk in pk_name] for item in lst]
        else:
            return [getattr(item, pk_name) for item in lst]
124279
def get_kbr_keys(kb_name, searchkey="", searchvalue="", searchtype='s'):
    
    if searchtype == 's' and searchkey:
        searchkey = '%'+searchkey+'%'
    if searchtype == 's' and searchvalue:
        searchvalue = '%'+searchvalue+'%'
    if searchtype == 'sw' and searchvalue:  # startswith
        searchvalue = searchvalue+'%'
    if not searchvalue:
        searchvalue = '%'
    if not searchkey:
        searchkey = '%'

    query = db.session.query(models.KnwKBRVAL).join(models.KnwKB) \
        .filter(models.KnwKBRVAL.m_key.like(searchkey),
                models.KnwKBRVAL.m_value.like(searchvalue),
                models.KnwKB.name.like(kb_name))

    return [(k.m_key,) for k in query.all()]
455043
def keys(pattern = SCAN_PATTERN, count = DEFAULT_COUNT)
      return redis(&:keys) if pattern.nil?

      redis { |conn| conn.scan_each(match: prefix(pattern), count: count).to_a }
    end
1188610
def encode_keys(self, keys):
        
        return dict(((k, self.encode(v)) for k, v in six.iteritems(keys) if not
                     is_null(v)))
1173801
def iterkeys(self):
        ""
        return chain(self._pb.StringMap.keys(),
                     self._pb.IntMap.keys(),
                     self._pb.FloatMap.keys(),
                     self._pb.BoolMap.keys())