List all facts in the cube, returning only the specified references
        if these are specified.
547751
def facts(self, fields=None, cuts=None, order=None, page=None,
              page_size=None, page_max=None):
        

        def prep(cuts, columns=None):
            q = select(columns=columns).select_from(self.fact_table)
            bindings = []
            _, q, bindings = Cuts(self).apply(q, bindings, cuts)
            q = self.restrict_joins(q, bindings)
            return q, bindings

        # Count
        count = count_results(self, prep(cuts, [1])[0])

        # Facts
        q, bindings = prep(cuts)
        fields, q, bindings = Fields(self).apply(q, bindings, fields)
        ordering, q, bindings = Ordering(self).apply(q, bindings, order)
        page, q = Pagination(self).apply(q, page, page_size, page_max)
        q = self.restrict_joins(q, bindings)
        return {
            'total_fact_count': count,
            'data': list(generate_results(self, q)),
            'cell': cuts,
            'fields': fields,
            'order': ordering,
            'page': page['page'],
            'page_size': page['page_size']
        }
574023
def cubes():
    
    cubes = []
    for cube in get_manager().list_cubes():
        cubes.append({
            'name': cube
        })
    return jsonify({
        'status': 'ok',
        'data': cubes
    })
22725
def current_fact_index(self):
        """"""
        facts_ids = [fact.id for fact in self.facts]
        return facts_ids.index(self.current_fact.id)
369646
def info_to_list(info):
    ''''''
    items = []
    for name, item in info.items():
        items.append((name, item['snake_name'], [
            type_from_proto[v['type']]['cpp'] for v in item.get('arguments', {}).values()]))
    return items
346329
def all(self, as_dict=False, as_ordereddict=False):
        """"""

        # By calling list it calls the __iter__ method
        rows = list(self)

        if as_dict:
            return [r.as_dict() for r in rows]
        elif as_ordereddict:
            return [r.as_dict(ordered=True) for r in rows]

        return rows
994028
def _infodict(cls, name):
        """"""
        info = cls._dataset_info.get(name, None)
        if info is None:
            raise ValueError('No such dataset {0} exists, '
                             'use list_datasets() to get a list '
                             'of available datasets.'.format(name))
        return info
76416
def all_entries(self):
        
        entries = []
        for c in self._all_comp:
            for e in self._all_entries:
                if e.composition.reduced_formula == c.reduced_formula:
                    entries.append(e)
                    break
        return entries
841163
def _get_reference(self):
        
        super()._get_reference()
        self.cubeA_body_id = self.sim.model.body_name2id("cubeA")
        self.cubeB_body_id = self.sim.model.body_name2id("cubeB")
        self.l_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.left_finger_geoms
        ]
        self.r_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.right_finger_geoms
        ]
        self.cubeA_geom_id = self.sim.model.geom_name2id("cubeA")
        self.cubeB_geom_id = self.sim.model.geom_name2id("cubeB")
148874
public void findAllArtifacts() {
        binArtifacts = findAllFiles(binDir);
        gensrcArtifacts = findAllFiles(gensrcDir);
        headerArtifacts = findAllFiles(headerDir);
    }
114978
def ReadAllArtifacts(self, cursor=None):
    """"""
    cursor.execute("SELECT definition FROM artifacts")
    return [_RowToArtifact(row) for row in cursor.fetchall()]
124036
def get_all_database_accessions(chebi_ids):
    ''''''
    all_database_accessions = [get_database_accessions(chebi_id)
                               for chebi_id in chebi_ids]
    return [x for sublist in all_database_accessions for x in sublist]
1224983
def info(self):
        ''' 
        '''
        return sorted(self._checkers.values(), key=lambda x: (x.ns, x.name))
82801
def gather_facts_list(self, file):
        
        facts = []

        contents = utils.file_to_string(os.path.join(self.paths["role"],
                                        file))
        contents = re.sub(r"\s+", "", contents)
        matches = self.regex_facts.findall(contents)

        for match in matches:
            facts.append(match.split(":")[1])

        return facts
217648
def _collect_headers(self):
        
        res = []

        for prop in self.get_sorted_columns():

            main_infos = self._get_prop_infos(prop)

            if self._is_excluded(prop, main_infos):
                continue

            if isinstance(prop, RelationshipProperty):
                main_infos = self._collect_relationship(main_infos, prop, res)

                if not main_infos:
                    # If still no success, we forgot this one
                    print("Maybe there's missing some informations \
about a relationship")
                    continue
            else:
                main_infos = self._merge_many_to_one_field_from_fkey(
                    main_infos, prop, res
                )
                if not main_infos:
                    continue

            if isinstance(main_infos, (list, tuple)):
                # In case _collect_relationship returned a list
                res.extend(main_infos)
            else:
                res.append(main_infos)
        return res
263973
def get_all_sources(self):
        """"""
        result = []
        for batch in self.batches:
            result.extend(batch.sources)
        return result
1243899
def show_fact_terms(self,level):
        """"""

        fact_terms = self._DCM["FactTerm"].objects.filter(fact__infoobject__pk=self.pk). \
            distinct('term','attribute').values('term','attribute')


        #fact_terms = self._DCM["FactTerm"].objects.filter(fact__iobject_thru__iobject__pk=self.pk).\
        #    filter(fact__iobject_thru__node_id__name__startswith=level).order_by('term','attribute').\
        #    distinct('term','attribute').values_list('fact__iobject_thru__node_id__name','term','attribute')

        return list(fact_terms)
521828
Facts and(Fact... moreFacts) {
    return new Facts(Iterables.concat(facts, asList(moreFacts)));
  }