The astropy.table.Table object that will contain the data result
        @rtype: Table
        @return: data table
960100
def table(self):
        
        if self._table is None:
            column_names = []
            for fileid in self.header.file_ids:
                for column_name in self.header.column_names:
                    column_names.append("{}_{}".format(column_name, fileid))
                column_names.append("ZP_{}".format(fileid))
            if len(column_names) > 0:
                self._table = Table(names=column_names)
            else:
                self._table = Table()
        return self._table
118326
def _tables(self) -> List[Tuple[str, str]]:
        
        return [(k.rsplit('.', 1)[1] if '.' in k else k, k) for k in self._ont_tables.keys()]
959515
def aggregate(args):
    

    _ok_to_clobber(args, [args.output_filename[0]], "")
    logger.debug("Aggregating to {}".format(args.output_filename[0]))

    from astropy.table import Table

    # What header keys should be passed to the final table?
    header_keys = ["RA", "DEC", "NAME", "OBJECT", "MAGNITUDE",
        "UTSTART", "UTEND", "UTDATE", "V_HELIO", "V_BARY"]

    def load_result_file(filename, debug):
        
        loader = yaml.load if filename.lower().endswith(".yaml") else pickle.load
        with open(filename, "r") as fp:
            try:
                result = loader(fp)
            
            except:
                logger.exception("Could not read results filename: {}".format(
                    filename))
                if debug: raise

            else:
                logger.debug("Successfully loaded results from {}".format(
                    filename))
        return result

    # Dows the first result actually exist, or is it a wildname mask?
    if not os.path.exists(args.result_filenames[0]):
        args.result_filenames = glob(args.result_filenames[0])

    # Load the first set of results to get the parameter names.
    first_results = load_result_file(args.result_filenames[0], True)
    parameters = set(first_results["estimated"]["theta"].keys() \
        + first_results.get("optimised", {}).get("theta", {}).keys() \
        + first_results.get("inferred", {}).get("theta", {}).keys())

    # Grab headers that exist.
    header_keys = [k for k in header_keys if k in first_results["headers"]]

    def default_values(stage):
        keys = "chi_sq dof r_chi_sq".split()
        default = dict(zip(["{0}_{1}".format(stage, key) for key in keys],
            [np.nan] * len(keys)))
        default["theta"] = dict(zip(
            ["{0}_{1}".format(stage, parameter) for parameter in parameters],
            [np.nan] * len(parameters)))
        return default

    def extract_values(result, stage, parameter_prefixes=None):
        _ = {
            "{}_chi_sq".format(stage): result.get("chi_sq", np.nan),
            "{}_dof".format(stage): result.get("dof", np.nan),
            "{}_r_chi_sq".format(stage): result.get("r_chi_sq", np.nan)
        }
        _.update(dict(zip(
            ["{0}_{1}".format(stage, parameter) for parameter in parameters],
            [result["theta"].get(param, np.nan) for param in parameters])))

        if parameter_prefixes is not None:
            for prefix in parameter_prefixes:
                _.update(dict(zip(
                    ["_".join([stage, prefix, parameter]) \
                        for parameter in parameters],
                    [result.get("{0}_{1}".format(prefix, parameter), np.nan) \
                        for parameter in parameters])))
        return _

    rows = []
    columns = [] + header_keys + ["SNR", "model", "sick_version", "results_filename"]
    for i, filename in enumerate(args.result_filenames):

        result = load_result_file(filename, debug=args.debug)
        logger.debug("Loaded results from {}".format(filename))

        # Header information.
        row = dict(zip(header_keys,
            [result["headers"].get(k, None) for k in header_keys]))
        row.update({
            "model": result["model"],
            "sick_version": result["sick_version"],
            "results_filename": filename,
            "SNR": result["SNR"]
        })
        
        # Include estimated values (which should always be present)
        estimated = extract_values(result["estimated"], "estimated")
        row.update(estimated)
        
        # Include optimised values, if they exist.
        optimised = extract_values(
            result.get("optimised", default_values("optimised")), "optimised")
        row.update(optimised)

        # Include inferred values, if they exist.
        inferred = extract_values(
            result.get("inferred", default_values("inferred")), "inferred",
            parameter_prefixes=["u_pos", "u_neg", "n_eff"])
        row.update(inferred)
        rows.append(row)

    for each in (estimated, optimised, inferred):
        columns += sorted(each.keys())

    table = Table(rows=rows, names=columns)
    try:
        table.write(args.output_filename[0], overwrite=args.clobber)
    except TypeError:
        table.write(args.output_filename[0])
        logger.info("Results from {0} files aggregated and saved to {1}".format(
            len(args.result_filenames), args.output_filename[0]))
1048370
def load_table(self, table):
        
        table = self._valid_table_name(table)
        schema, table = self.parse_table_name(table)
        if not schema:
            schema = self.schema
            tables = self.tables
        else:
            tables = self.tables_in_schema(schema)
        if table in tables:
            return Table(self, schema, table)
        else:
            return None
787652
def tables(self):
        
        datasets = DatasetManager(self.auth_client).filter(
            show_table_size_and_row_count='false',
            show_table='false',
            show_stats='false',
            show_likes='false',
            show_liked='false',
            show_permission='false',
            show_uses_builder_features='false',
            show_synchronization='false',
            load_totals='false')
        return [Table.from_dataset(d) for d in datasets]
842347
def get_table(self, table):
        
        path = '/archive/{}/tables/{}'.format(self._instance, table)
        response = self._client.get_proto(path=path)
        message = archive_pb2.TableInfo()
        message.ParseFromString(response.content)
        return Table(message)
1047573
def get_main(self) -> 'table[category: str][label: str][date: date]':
        

        raw_table = self.get_raw_table("M")
        categories = raw_table[0]
        labels = raw_table[1]
        dates = self.get_dates(raw_table)

        def next_cat_col(i):
            n = 1
            while True:
                if i+n > len(categories)-1:
                    return i
                if categories[i+n]:
                    return i+n
                n += 1

        def get_category_labels(i):
            end_col = next_cat_col(i)
            return zip(range(i, end_col), labels[i:end_col])

        def get_label_cells(category, label):
            ci = categories.index(category)
            i = labels.index(label, ci)
            cells = {}
            for j, d in enumerate(dates):
                cell = raw_table[j+2][i]
                if cell and cell != "#VALUE!":
                    cells[d] = cell
            return cells

        table = {}
        for i, cat in enumerate(categories):
            if not cat:
                continue
            table[cat] = {}
            for i, label in get_category_labels(i):
                table[cat][label] = get_label_cells(cat, label)

        return table
764982
def morrison_and_stephenson_2004_table():
    """"""
    import pandas as pd
    f = load.open('http://eclipse.gsfc.nasa.gov/SEcat5/deltat.html')
    tables = pd.read_html(f.read())
    df = tables[0]
    return pd.DataFrame({'year': df[0], 'delta_t': df[1]})
946031
def tables(self):
        
        _tables = set()

        for attr in six.itervalues(self.__dict__):
            if isinstance(attr, list):
                for item in attr:
                    if isinstance(item, Node):
                        _tables |= item.tables()
            elif isinstance(attr, Node):
                _tables |= attr.tables()

        return _tables
598380
def to_table_data(self):
        

        self._validate_source_data()

        for table_key, json_records in six.iteritems(self._buffer):
            attr_name_set = set()
            for json_record in json_records:
                attr_name_set = attr_name_set.union(six.viewkeys(json_record))
            headers = sorted(attr_name_set)

            self._loader.inc_table_count()
            self._table_key = table_key

            yield TableData(
                self._make_table_name(),
                headers,
                json_records,
                dp_extractor=self._loader.dp_extractor,
                type_hints=self._extract_type_hints(headers),
            )
1360533
def get_table(self, name):
        
        response = self.layer1.describe_table(name)
        return Table(self,  response)
1168360
def table_from_data(data, column_names):
    ""

    # The agate table is generated from a list of dicts, so the column order
    # from `data` is not preserved. We can use `select` to reorder the columns
    #
    # If there is no data, create an empty table with the specified columns

    if len(data) == 0:
        return agate.Table([], column_names=column_names)
    else:
        table = agate.Table.from_object(data, column_types=DEFAULT_TYPE_TESTER)
        return table.select(column_names)
220307
def data_frame_to_astropy_table (dataframe):
    
    from astropy.utils import OrderedDict
    from astropy.table import Table, Column, MaskedColumn
    from astropy.extern import six

    out = OrderedDict()

    for name in dataframe.columns:
        column = dataframe[name]
        mask = np.array (column.isnull ())
        data = np.array (column)

        if data.dtype.kind == 'O':
            # If all elements of an object array are string-like or np.nan
            # then coerce back to a native numpy str/unicode array.
            string_types = six.string_types
            if six.PY3:
                string_types += (bytes,)
            nan = np.nan
            if all(isinstance(x, string_types) or x is nan for x in data):
                # Force any missing (null) values to b''.  Numpy will
                # upcast to str/unicode as needed.
                data[mask] = b''

                # When the numpy object array is represented as a list then
                # numpy initializes to the correct string or unicode type.
                data = np.array([x for x in data])

        if np.any(mask):
            out[name] = MaskedColumn(data=data, name=name, mask=mask)
        else:
            out[name] = Column(data=data, name=name)

    return Table(out)
193056
def tables(self):
        
        from ambry.orm import Table
        from sqlalchemy.orm import lazyload

        return (self.dataset.session.query(Table)
                .filter(Table.d_vid == self.dataset.vid)
                .options(lazyload('*'))
                .all())
622282
def _gen_property_table(self):
        
        headers = ['Property Name', 'Type', 'Value', 'Default Value']

        table = []
        for propval in sorted(self._properties.itervalues(),
                              key=lambda pval: pval.name.upper()):
            table.append([propval.name,
                np.dtype(propval.dtype).name,
                getattr(self, propval.name),
                propval.default])

        return table, headers
587013
def get_rtc_table(self):
        
        rtc_table = self._global_tables.get(RF_RTC_UC)
        # Lazy initialization of the table.
        if not rtc_table:
            rtc_table = RtcTable(self._core_service, self._signal_bus)
            self._global_tables[RF_RTC_UC] = rtc_table
            self._tables[(None, RF_RTC_UC)] = rtc_table
        return rtc_table
311235
function generateTable() {
   var data = []

   for (var i=0; i<30; i++) {
     var row = []
     row.push(commands[Math.round(Math.random()*(commands.length-1))])
     row.push(Math.round(Math.random()*5))
     row.push(Math.round(Math.random()*100))
     data.push(row)
   }

   return {headers: ['Process', 'Cpu (%)', 'Memory'], data: data};
}