Retrieve the IDs of all obstorys.

        :return:
            A list of obstory IDs for all obstorys
433839
def get_obstory_ids(self):
        
        self.con.execute('SELECT publicId FROM archive_observatories;')
        return map(lambda row: row['publicId'], self.con.fetchall())
334446
def get_all(self):
        
        components = []
        
        self._lock.acquire()
        try:
            for reference in self._references:
                components.append(reference.get_component())
        finally:
            self._lock.release()

        return components
271275
def fileids(self):
        
        return [os.path.join(self.path,i) for i in os.listdir(self.path)]
733782
def get_connected_devices():
        
        all_daplinks = []
        all_interfaces = _get_interfaces()
        for interface in all_interfaces:
            try:
                new_daplink = DAPAccessCMSISDAP(None, interface=interface)
                all_daplinks.append(new_daplink)
            except DAPAccessIntf.TransferError:
                logger = logging.getLogger(__name__)
                logger.error('Failed to get unique id', exc_info=session.Session.get_current().log_tracebacks)
        return all_daplinks
1206702
def get_components(self):
        
        components = []
        for app_id in self.components:
            components.append(self.components[app_id])
        return components
112209
def connections(self):
        
        if not self.__connections:
            self.__connections = Connections(
                self.__connection)
        return self.__connections
497987
def get_all_keys(self):
        
        all_keys = []
        for keys in self._index.values():
            all_keys.extend(keys)
        return all_keys
897013
def get_all_namespace_ids( self ):
        
        cur = self.db.cursor()
        namespace_ids = namedb_get_all_namespace_ids( cur )
        return namespace_ids
952946
def ancestors(self):
        
        ancestors = []
        node = self.ancestor
        while node is not None:
            ancestors.append(node)
            node = node.ancestor
        return ancestors
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
673449
def get_menus(self, id):
        
        resp = self.get_details([id])
        menus = []
        for obj in resp['objects']:
            if obj['has_menu']:
                menus += obj['menus']
        return menus
286868
def ids(self):
        
        if self._ids is None:
            if self._columns:
                if isinstance(self._columns, OrderedDict):
                    return [list(self._columns.keys())[0]]
                return [self._columns[0]]
        else:
            return self._ids
233468
def backupIds(self) -> Sequence[int]:
        
        return [id for id in self.started.keys() if id != 0]
1135527
def to_list(self):
        
        ret = []
        for instance in self.instances:
            ret.append(instance.to_dict())
        return ret
689152
def get_es_object_ids(self, objects):
        
        id_field = self.clean_id_name
        ids = [getattr(obj, id_field, obj) for obj in objects]
        return list(set(str(id_) for id_ in ids))
889507
def get_instances(self):
        
        return [c.get('instance') for c in self.runtime._nodes.values()
                if c.get('instance')]
957309
def getGroupIDs(self, groupNames,communityInfo=None):
        
        group_ids=[]
        if communityInfo is None:
            communityInfo = self.communitySelf

        if isinstance(groupNames,list):
            groupNames = map(str.upper, groupNames)
        else:
            groupNames = groupNames.upper()
        if 'groups' in communityInfo:
            for gp in communityInfo['groups']:

                if str(gp['title']).upper() in groupNames:
                    group_ids.append(gp['id'])
        del communityInfo
        return group_ids