Return the text result of table.info(verbose=True).
19779
def table_info(table_name):
    
    table = orca.get_table(table_name).to_frame()
    buf = StringIO()
    table.info(verbose=True, buf=buf)
    info = buf.getvalue()
    return info, 200, {'Content-Type': 'text/plain'}
614165
def info(self):
        
        info = {'term_type': 'term_list', 'verbose': self.verbose}
        info.update({'terms':[term.info for term in self._terms]})
        return info
1201987
def _get_table_infos(
            self,
            trimmed=False):
        
        self.log.debug('starting the ``_get_table_infos`` method')

        sqlQuery = u"""
            SELECT * FROM crossmatch_catalogues.tcs_helper_catalogue_tables_info where legacy_table = 0 and table_name not like "legacy%%" and table_name not like "%%stream"  order by number_of_rows desc;
        """ % locals()
        tableInfo = readquery(
            log=self.log,
            sqlQuery=sqlQuery,
            dbConn=self.cataloguesDbConn,
            quiet=False
        )

        if trimmed:
            cleanTable = []
            for r in tableInfo:
                orow = collections.OrderedDict(sorted({}.items()))
                for c in self.basicColumns:
                    if c in r:
                        orow[c] = r[c]
                cleanTable.append(orow)
            tableInfo = cleanTable

        self.log.debug('completed the ``_get_table_infos`` method')
        return tableInfo
660852
def _get_table_info(self):
        """"""
        self.rowid = None
        self.fields = []
        self.field_info = {}
        self.cursor.execute('DESCRIBE %s' %self.name)
        for row in self.cursor.fetchall():
            field,typ,null,key,default,extra = row
            self.fields.append(field)
            self.field_info[field] = {'type':typ,'NOT NULL':null,'key':key,
                'DEFAULT':default,'extra':extra}
            if extra == 'auto_increment':
                self.rowid = field
795668
def show_table(name, table, i, total):
    
    return '[%d/%d, %s] %s' % (i+1, total, table.__appname__, name)
1294761
def _print_results(results, stat=False, verbose=False):
    
    results.generate_pretty_output(stat=stat,
                                   verbose=verbose,
                                   output_function=click.secho)
983157
def table(self):
        """"""
        ascii_table = super(UnixTable, self).table
        optimized = ascii_table.replace('\033(B\033(0', '')
        return optimized
1123738
def verbose(enabled):
    """"""
    def _vprint(msg, **kwargs):
        print(msg, **kwargs)
    def _nprint(msg, **kwargs):
        pass
    return _vprint if enabled else _nprint
589795
def text(self):
        
        if self.out:
            self.out.close()  # pragma: nocover
        return self.fp.getvalue()
296753
def get_ok_results(self, verbose=True):
        
        if len(self.trials) == 0:
            return []

        not_ok = np.where(np.array(self.statuses()) != "ok")[0]

        if len(not_ok) > 0 and verbose:
            print("{0}/{1} trials were not ok.".format(len(not_ok), len(self.trials)))
            print("Trials: " + str(not_ok))
            print("Statuses: " + str(np.array(self.statuses())[not_ok]))

        r = [merge_dicts({"tid": t["tid"]}, t["result"].to_dict())
             for t in self.trials if t["result"]["status"] == "ok"]
        return r
843215
def get_table_info(self, tablename):
        
        conn = self.__get_conn()
        ret = a99.get_table_info(conn, tablename)

        if len(ret) == 0:
            raise RuntimeError("Cannot get info for table '{}'".format(tablename))

        more = self.gui_info.get(tablename)
        for row in ret.values():
            caption, tooltip = None, None
            if more:
                info = more.get(row["name"])
                if info:
                    caption, tooltip = info
            row["caption"] = caption
            row["tooltip"] = tooltip

        return ret
1218001
def info(self, text=None):
        
        return self.stop_and_persist(symbol=LogSymbols.INFO.value, text=text)
1362155
def get_table(self, tablename):
        
        table, (_row, _col) = self.__tables[tablename]
        return table
428546
def to_string(self, verbose=0):
        """"""
        rows = [[it + 1] + list(map(str, (self[k][it] for k in self.keys())))
                for it in range(self.num_iterations)]

        return tabulate(rows, headers=["Iter"] + list(self.keys()))
999199
def get_info(df, verbose = None,max_cols = None, memory_usage = None, null_counts = None):
    
    assert type(df) is pd.DataFrame
    buffer = io.StringIO()
    df.info(verbose, buffer, max_cols, memory_usage, null_counts)
    return buffer.getvalue()
320563
def read_table(self):
        """"""
        self.bitcount = self.bits = 0
        tlen = unpack('>I', self.input.read(4))[0]
        table_data = AMQPReader(self.input.read(tlen))
        result = {}
        while table_data.input.tell() < tlen:
            name = table_data.read_shortstr()
            val = table_data.read_item()
            result[name] = val
        return result
23591
def print_results_adj(results, indent=False, prt=sys.stdout):
        """"""
        # Print column headers if there are results to be printed
        if results:
            prt.write("{R}\n".format(R="\t".join(GOEnrichmentStudy.get_prtflds_default(results))))
        # Print the GOEA results
        for rec in results:
            prt.write("{R}\n".format(R=rec.__str__(indent=indent)))