Returns a list of all known eids
354533
def list_eids(self):
		
		entities = self.list()
		return sorted([int(eid) for eid in entities])
532946
def childIds(self):
        
        if self.depth >= len(self.citation.root):
            return []
        elif self._children is not None:
            return self._children
        else:
            self._children = self.getReffs()
            return self._children
865654
def list(gandi, id, altnames, csr, cert, all_status, status, dates, limit):
    
    options = {'items_per_page': limit}

    if not all_status:
        options['status'] = ['valid', 'pending']

    output_keys = ['cn', 'plan']

    if id:
        output_keys.append('id')

    if status:
        output_keys.append('status')

    if dates:
        output_keys.extend(['date_created', 'date_end'])

    if altnames:
        output_keys.append('altnames')

    if csr:
        output_keys.append('csr')

    if cert:
        output_keys.append('cert')

    result = gandi.certificate.list(options)
    for num, cert in enumerate(result):
        if num:
            gandi.separator_line()
        cert['plan'] = package_desc(gandi, cert['package'])
        output_cert(gandi, cert, output_keys)

    return result
376136
def get_events(self, rlzs_by_gsim):
        
        all_eids, rlzs = [], []
        for rlz, eids in self.get_eids_by_rlz(rlzs_by_gsim).items():
            all_eids.extend(eids)
            rlzs.extend([rlz] * len(eids))
        return numpy.fromiter(zip(all_eids, rlzs), events_dt)
795815
def get_ids(self, start=0, rows=1000, **query_dict):
        """"""
        resp_dict = self._get_query(start=start, rows=rows, **query_dict)
        return {
            'matches': resp_dict['response']['numFound'],
            'start': start,
            'ids': [d['id'] for d in resp_dict['response']['docs']],
        }
510960
def get_file_paths(self, id_list):
        
        if id_list is None:
            return []
        try:
            path_array = self._table[id_list - 1]['path']
        except IndexError:
            print("IndexError ", len(self._table), id_list)
            path_array = []
        return [path for path in path_array]
89569
def get_all_db_ids(language=DEFAULT_LANG):
        
        _ids = []
        json_path = DBVuln.get_json_path(language=language)

        for _file in os.listdir(json_path):

            if not _file.endswith('.json'):
                continue

            _id = _file.split('-')[0]
            _ids.append(_id)

        return _ids
41182
def get_jids():
    '''
    
    '''
    serv = _get_serv(ret=None)
    sql = "select distinct(jid) from jids group by load"

    # [{u'points': [[0, jid, load],
    #               [0, jid, load]],
    #   u'name': u'jids',
    #   u'columns': [u'time', u'distinct', u'load']}]
    data = serv.query(sql)
    ret = {}
    if data:
        for _, jid, load in data[0]['points']:
            ret[jid] = salt.utils.jid.format_jid_instance(jid, salt.utils.json.loads(load))
    return ret
1326540
def get_task_ids(tids):
    
    logging.debug('raw task ids: %s' % tids)
    task_ids = []
    for raw_arg in tids:
        for bit in raw_arg.split(','):
            if '-' in bit:
                start, stop = [int(e) for e in bit.split('-')]
                task_ids.extend(range(start, stop + 1))
            else:
                task_ids.append(int(bit))
    return [e - 1 for e in set(task_ids)]
441833
def enabled_scanner_ids(self):
        """"""
        enabled_scanners = []
        scanners = self.zap.ascan.scanners()

        for scanner in scanners:
            if scanner['enabled'] == 'true':
                enabled_scanners.append(scanner['id'])

        return enabled_scanners
586434
def _list(self):
        
        all = self.driver.instance.metadata.get(search=self.namespace)
        list = []
        for id in all:
            try:
                if not self._get(id['id']) in list:
                    list.append(self._get(id['id']))
            except Exception:
                pass

        return list
98597
def get_input_ids(query, limit=None):
    """"""
    docs = scan(_es, index=esconfig.ES_INPUT_INDEX,
                doc_type=esconfig.ES_INPUT_DOCTYPE,
                query=query, size=(limit or 1000), fields="")
    for i, a in enumerate(docs):
        if limit and i >= limit:
            return
        yield a['_id']
296707
def get_all(self, uids: Iterable[int]) -> Mapping[int, Record]:
        
        return {uid: self._records[uid] for uid in uids
                if uid in self._records}
766346
def get_id2gos_all(taxid2asscs_a2b):
        """"""
        id2gos_all = {}
        for a2b in taxid2asscs_a2b.values():
            for geneid, gos in a2b['ID2GOs'].items():
                id2gos_all[geneid] = gos
        return id2gos_all
1230371
def find_list_of_ids(self, resource, ids, client_projection=None):
        """"""
        args = self._es_args(resource)
        return self._parse_hits(self.elastic(resource).mget(body={'ids': ids}, **args), resource)
850363
def get_es_ids(self):
        
        search = self.search.source(['uri']).sort(['uri'])
        es_ids = [item.meta.id for item in search.scan()]
        return es_ids
41573
def ids(self):
        """"""
        as_list = [seq.description.split()[0] for seq in self]
        as_set = frozenset(as_list)
        assert len(as_set) == len(as_list)
        return as_set