Search is not available for this dataset
text stringlengths 75 104k |
|---|
def tags(self, where, archiver="", timeout=DEFAULT_TIMEOUT):
"""
Retrieves tags for all streams matching the given WHERE clause
Arguments:
[where]: the where clause (e.g. 'path like "keti"', 'SourceName = "TED Main"')
[archiver]: if specified, this is the archiver to use. Else, ... |
def tags_uuids(self, uuids, archiver="", timeout=DEFAULT_TIMEOUT):
"""
Retrieves tags for all streams with the provided UUIDs
Arguments:
[uuids]: list of UUIDs
[archiver]: if specified, this is the archiver to use. Else, it will run on the first archiver passed
... |
def data(self, where, start, end, archiver="", timeout=DEFAULT_TIMEOUT):
"""
With the given WHERE clause, retrieves all RAW data between the 2 given timestamps
Arguments:
[where]: the where clause (e.g. 'path like "keti"', 'SourceName = "TED Main"')
[start, end]: time references... |
def data_uuids(self, uuids, start, end, archiver="", timeout=DEFAULT_TIMEOUT):
"""
With the given list of UUIDs, retrieves all RAW data between the 2 given timestamps
Arguments:
[uuids]: list of UUIDs
[start, end]: time references:
[archiver]: if specified, this is the a... |
def stats(self, where, start, end, pw, archiver="", timeout=DEFAULT_TIMEOUT):
"""
With the given WHERE clause, retrieves all statistical data between the 2 given timestamps, using the given pointwidth
Arguments:
[where]: the where clause (e.g. 'path like "keti"', 'SourceName = "TED Main... |
def window(self, where, start, end, width, archiver="", timeout=DEFAULT_TIMEOUT):
"""
With the given WHERE clause, retrieves all statistical data between the 2 given timestamps, using the given window size
Arguments:
[where]: the where clause (e.g. 'path like "keti"', 'SourceName = "TED... |
def brightness(self):
"""Return current brightness 0-255.
For warm white return current led level. For RGB
calculate the HSV and return the 'value'.
"""
if self.mode == "ww":
return int(self.raw_state[9])
else:
_, _, v = colorsys.rgb_to_hsv(*self.... |
def decode(var, encoding):
"""
If not already unicode, decode it.
"""
if PY2:
if isinstance(var, unicode):
ret = var
elif isinstance(var, str):
if encoding:
ret = var.decode(encoding)
else:
ret = unicode(var)
els... |
def cfitsio_version(asfloat=False):
"""
Return the cfitsio version as a string.
"""
# use string version to avoid roundoffs
ver = '%0.3f' % _fitsio_wrap.cfitsio_version()
if asfloat:
return float(ver)
else:
return ver |
def is_little_endian(array):
"""
Return True if array is little endian, False otherwise.
Parameters
----------
array: numpy array
A numerical python array.
Returns
-------
Truth value:
True for little-endian
Notes
-----
Strings are neither big or little end... |
def array_to_native(array, inplace=False):
"""
Convert an array to the native byte order.
NOTE: the inplace keyword argument is not currently used.
"""
if numpy.little_endian:
machine_little = True
else:
machine_little = False
data_little = False
if array.dtype.names is... |
def mks(val):
"""
make sure the value is a string, paying mind to python3 vs 2
"""
if sys.version_info > (3, 0, 0):
if isinstance(val, bytes):
sval = str(val, 'utf-8')
else:
sval = str(val)
else:
sval = str(val)
return sval |
def _extract_vararray_max(tform):
"""
Extract number from PX(number)
"""
first = tform.find('(')
last = tform.rfind(')')
if first == -1 or last == -1:
# no max length specified
return -1
maxnum = int(tform[first+1:last])
return maxnum |
def _get_col_dimstr(tdim, is_string=False):
"""
not for variable length
"""
dimstr = ''
if tdim is None:
dimstr = 'array[bad TDIM]'
else:
if is_string:
if len(tdim) > 1:
dimstr = [str(d) for d in tdim[1:]]
else:
if len(tdim) > 1 or ... |
def _npy2fits(d, table_type='binary', write_bitcols=False):
"""
d is the full element from the descr
"""
npy_dtype = d[1][1:]
if npy_dtype[0] == 'S' or npy_dtype[0] == 'U':
name, form, dim = _npy_string2fits(d, table_type=table_type)
else:
name, form, dim = _npy_num2fits(
... |
def _npy_num2fits(d, table_type='binary', write_bitcols=False):
"""
d is the full element from the descr
For vector,array columns the form is the total counts
followed by the code.
For array columns with dimension greater than 1, the dim is set to
(dim1, dim2, ...)
So it is treated lik... |
def _npy_string2fits(d, table_type='binary'):
"""
d is the full element from the descr
form for strings is the total number of bytes followed by A. Thus
for vector or array columns it is the size of the string times the
total number of elements in the array.
Then the dim is set to
(si... |
def get_colname(self, colnum):
"""
Get the name associated with the given column number
parameters
----------
colnum: integer
The number for the column, zero offset
"""
if colnum < 0 or colnum > (len(self._colnames)-1):
raise ValueError(
... |
def write(self, data, **keys):
"""
Write data into this HDU
parameters
----------
data: ndarray or list of ndarray
A numerical python array. Should be an ordinary array for image
HDUs, should have fields for tables. To write an ordinary array to
... |
def write_column(self, column, data, **keys):
"""
Write data to a column in this HDU
This HDU must be a table HDU.
parameters
----------
column: scalar string/integer
The column in which to write. Can be the name or number (0 offset)
column: ndarray... |
def _verify_column_data(self, colnum, data):
"""
verify the input data is of the correct type and shape
"""
this_dt = data.dtype.descr[0]
if len(data.shape) > 2:
this_shape = data.shape[1:]
elif len(data.shape) == 2 and data.shape[1] > 1:
this_sha... |
def write_var_column(self, column, data, firstrow=0, **keys):
"""
Write data to a variable-length column in this HDU
This HDU must be a table HDU.
parameters
----------
column: scalar string/integer
The column in which to write. Can be the name or number (0... |
def insert_column(self, name, data, colnum=None):
"""
Insert a new column.
parameters
----------
name: string
The column name
data:
The data to write into the new column.
colnum: int, optional
The column number for the new colu... |
def append(self, data, **keys):
"""
Append new rows to a table HDU
parameters
----------
data: ndarray or list of arrays
A numerical python array with fields (recarray) or a list of
arrays. Should have the same fields as the existing table. If only
... |
def delete_rows(self, rows):
"""
Delete rows from the table
parameters
----------
rows: sequence or slice
The exact rows to delete as a sequence, or a slice.
examples
--------
# delete a range of rows
with fitsio.FITS(fname,'r... |
def resize(self, nrows, front=False):
"""
Resize the table to the given size, removing or adding rows as
necessary. Note if expanding the table at the end, it is more
efficient to use the append function than resizing and then
writing.
New added rows are zerod, except f... |
def read(self, **keys):
"""
read data from this HDU
By default, all data are read.
send columns= and rows= to select subsets of the data.
Table data are read into a recarray; use read_column() to get a single
column as an ordinary array. You can alternatively use slice... |
def _read_all(self, **keys):
"""
Read all data in the HDU.
parameters
----------
vstorage: string, optional
Over-ride the default method to store variable length columns. Can
be 'fixed' or 'object'. See docs on fitsio.FITS for details.
lower: bo... |
def read_column(self, col, **keys):
"""
Read the specified column
Alternatively, you can use slice notation
fits=fitsio.FITS(filename)
fits[ext][colname][:]
fits[ext][colname][2:5]
fits[ext][colname][200:235:2]
fits[ext][colname][rows]... |
def read_rows(self, rows, **keys):
"""
Read the specified rows.
parameters
----------
rows: list,array
A list or array of row indices.
vstorage: string, optional
Over-ride the default method to store variable length columns. Can
be 'f... |
def read_columns(self, columns, **keys):
"""
read a subset of columns from this binary table HDU
By default, all rows are read. Send rows= to select subsets of the
data. Table data are read into a recarray for multiple columns,
plain array for a single column.
paramet... |
def read_slice(self, firstrow, lastrow, step=1, **keys):
"""
Read the specified row slice from a table.
Read all rows between firstrow and lastrow (non-inclusive, as per
python slice notation). Note you must use slice notation for
images, e.g. f[ext][20:30, 40:50]
para... |
def get_rec_dtype(self, **keys):
"""
Get the dtype for the specified columns
parameters
----------
colnums: integer array
The column numbers, 0 offset
vstorage: string, optional
See docs in read_columns
"""
colnums = keys.get('coln... |
def _check_tbit(self, **keys):
"""
Check if one of the columns is a TBIT column
parameters
----------
colnums: integer array, optional
"""
colnums = keys.get('colnums', None)
if colnums is None:
colnums = self._extract_colnums()
has_... |
def _fix_tbit_dtype(self, array, colnums):
"""
If necessary, patch up the TBIT to convert to bool array
parameters
----------
array: record array
colnums: column numbers for lookup
"""
descr = array.dtype.descr
for i, colnum in enumerate(colnums):... |
def _get_simple_dtype_and_shape(self, colnum, rows=None):
"""
When reading a single column, we want the basic data
type and the shape of the array.
for scalar columns, shape is just nrows, otherwise
it is (nrows, dim1, dim2)
Note if rows= is sent and only a single row i... |
def get_rec_column_descr(self, colnum, vstorage):
"""
Get a descriptor entry for the specified column.
parameters
----------
colnum: integer
The column number, 0 offset
vstorage: string
See docs in read_columns
"""
npy_type, isvar,... |
def _read_rec_with_var(
self, colnums, rows, dtype, offsets, isvar, vstorage):
"""
Read columns from a table into a rec array, including variable length
columns. This is special because, for efficiency, it involves reading
from the main table as normal but skipping the colum... |
def _extract_rows(self, rows):
"""
Extract an array of rows from an input scalar or sequence
"""
if rows is not None:
rows = numpy.array(rows, ndmin=1, copy=False, dtype='i8')
# returns unique, sorted
rows = numpy.unique(rows)
maxrow = sel... |
def _process_slice(self, arg):
"""
process the input slice for use calling the C code
"""
start = arg.start
stop = arg.stop
step = arg.step
nrows = self._info['nrows']
if step is None:
step = 1
if start is None:
start = 0
... |
def _slice2rows(self, start, stop, step=None):
"""
Convert a slice to an explicit array of rows
"""
nrows = self._info['nrows']
if start is None:
start = 0
if stop is None:
stop = nrows
if step is None:
step = 1
tstart ... |
def _fix_range(self, num, isslice=True):
"""
Ensure the input is within range.
If el=True, then don't treat as a slice element
"""
nrows = self._info['nrows']
if isslice:
# include the end
if num < 0:
num = nrows + (1+num)
... |
def _rescale_and_convert_field_inplace(self, array, name, scale, zero):
"""
Apply fits scalings. Also, convert bool to proper
numpy boolean values
"""
self._rescale_array(array[name], scale, zero)
if array[name].dtype == numpy.bool:
array[name] = self._conver... |
def _rescale_array(self, array, scale, zero):
"""
Scale the input array
"""
if scale != 1.0:
sval = numpy.array(scale, dtype=array.dtype)
array *= sval
if zero != 0.0:
zval = numpy.array(zero, dtype=array.dtype)
array += zval |
def _maybe_trim_strings(self, array, **keys):
"""
if requested, trim trailing white space from
all string fields in the input array
"""
trim_strings = keys.get('trim_strings', False)
if self.trim_strings or trim_strings:
_trim_strings(array) |
def _convert_bool_array(self, array):
"""
cfitsio reads as characters 'T' and 'F' -- convert to real boolean
If input is a fits bool, convert to numpy boolean
"""
output = (array.view(numpy.int8) == ord('T')).astype(numpy.bool)
return output |
def _get_tbl_numpy_dtype(self, colnum, include_endianness=True):
"""
Get numpy type for the input column
"""
table_type = self._info['hdutype']
table_type_string = _hdu_type_map[table_type]
try:
ftype = self._info['colinfo'][colnum]['eqtype']
if ta... |
def _process_args_as_rows_or_columns(self, arg, unpack=False):
"""
We must be able to interpret the args as as either a column name or
row number, or sequences thereof. Numpy arrays and slices are also
fine.
Examples:
'field'
35
[35,55,86]
... |
def _extract_colnums(self, columns=None):
"""
Extract an array of columns from the input
"""
if columns is None:
return numpy.arange(self._ncol, dtype='i8')
if not isinstance(columns, (tuple, list, numpy.ndarray)):
# is a scalar
return self._e... |
def _extract_colnum(self, col):
"""
Get the column number for the input column
"""
if isinteger(col):
colnum = col
if (colnum < 0) or (colnum > (self._ncol-1)):
raise ValueError(
"column number should be in [0,%d]" % (0, self._... |
def _update_info(self):
"""
Call parent method and make sure this is in fact a
table HDU. Set some convenience data.
"""
super(TableHDU, self)._update_info()
if self._info['hdutype'] == IMAGE_HDU:
mess = "Extension %s is not a Table HDU" % self.ext
... |
def _get_next_buffered_row(self):
"""
Get the next row for iteration.
"""
if self._iter_row == self._iter_nrows:
raise StopIteration
if self._row_buffer_index >= self._iter_row_buffer:
self._buffer_iter_rows(self._iter_row)
data = self._row_buffe... |
def _buffer_iter_rows(self, start):
"""
Read in the buffer for iteration
"""
self._row_buffer = self[start:start+self._iter_row_buffer]
# start back at the front of the buffer
self._row_buffer_index = 0 |
def read(self, **keys):
"""
read a data from an ascii table HDU
By default, all rows are read. Send rows= to select subsets of the
data. Table data are read into a recarray for multiple columns,
plain array for a single column.
parameters
----------
co... |
def read(self, **keys):
"""
Read the data from disk and return as a numpy array
"""
if self.is_scalar:
data = self.fitshdu.read_column(self.columns, **keys)
else:
c = keys.get('columns', None)
if c is None:
keys['columns'] = se... |
def read(filename, ext=None, extver=None, **keys):
"""
Convenience function to read data from the specified FITS HDU
By default, all data are read. For tables, send columns= and rows= to
select subsets of the data. Table data are read into a recarray; use a
FITS object and read_column() to get a ... |
def read_header(filename, ext=0, extver=None, case_sensitive=False, **keys):
"""
Convenience function to read the header from the specified FITS HDU
The FITSHDR allows access to the values and comments by name and
number.
parameters
----------
filename: string
A filename.
ext: ... |
def read_scamp_head(fname, header=None):
"""
read a SCAMP .head file as a fits header FITSHDR object
parameters
----------
fname: string
The path to the SCAMP .head file
header: FITSHDR, optional
Optionally combine the header with the input one. The input can
be any obj... |
def write(filename, data, extname=None, extver=None, units=None,
compress=None, table_type='binary', header=None,
clobber=False, **keys):
"""
Convenience function to create a new HDU and write the data.
Under the hood, a FITS object is constructed. If you want to append rows
to an ... |
def array2tabledef(data, table_type='binary', write_bitcols=False):
"""
Similar to descr2tabledef but if there are object columns a type
and max length will be extracted and used for the tabledef
"""
is_ascii = (table_type == 'ascii')
if data.dtype.fields is None:
raise ValueError("data... |
def descr2tabledef(descr, table_type='binary', write_bitcols=False):
"""
Create a FITS table def from the input numpy descriptor.
parameters
----------
descr: list
A numpy recarray type descriptor array.dtype.descr
returns
-------
names, formats, dims: tuple of lists
T... |
def get_tile_dims(tile_dims, imshape):
"""
Just make sure the tile dims has the appropriate number of dimensions
"""
if tile_dims is None:
td = None
else:
td = numpy.array(tile_dims, dtype='i8')
nd = len(imshape)
if td.size != nd:
msg = "expected tile_dim... |
def _extract_table_type(type):
"""
Get the numerical table type
"""
if isinstance(type, str):
type = type.lower()
if type[0:7] == 'binary':
table_type = BINARY_TBL
elif type[0:6] == 'ascii':
table_type = ASCII_TBL
else:
raise ValueError... |
def close(self):
"""
Close the fits file and set relevant metadata to None
"""
if hasattr(self, '_FITS'):
if self._FITS is not None:
self._FITS.close()
self._FITS = None
self._filename = None
self.mode = None
self.charmo... |
def movnam_hdu(self, extname, hdutype=ANY_HDU, extver=0):
"""
Move to the indicated HDU by name
In general, it is not necessary to use this method explicitly.
returns the one-offset extension number
"""
extname = mks(extname)
hdu = self._FITS.movnam_hdu(hdutype,... |
def reopen(self):
"""
close and reopen the fits file with the same mode
"""
self._FITS.close()
del self._FITS
self._FITS = _fitsio_wrap.FITS(self._filename, self.intmode, 0)
self.update_hdu_list() |
def write(self, data, units=None, extname=None, extver=None,
compress=None, tile_dims=None,
header=None,
names=None,
table_type='binary', write_bitcols=False, **keys):
"""
Write the data to a new HDU.
This method is a wrapper. If this is ... |
def write_image(self, img, extname=None, extver=None,
compress=None, tile_dims=None, header=None):
"""
Create a new image extension and write the data.
parameters
----------
img: ndarray
An n-dimensional image.
extname: string, optional
... |
def create_image_hdu(self,
img=None,
dims=None,
dtype=None,
extname=None,
extver=None,
compress=None,
tile_dims=None,
he... |
def _ensure_empty_image_ok(self):
"""
If ignore_empty was not set to True, we only allow empty HDU for first
HDU and if there is no data there already
"""
if self.ignore_empty:
return
if len(self) > 1:
raise RuntimeError(
"Cannot w... |
def write_table(self, data, table_type='binary',
names=None, formats=None, units=None,
extname=None, extver=None, header=None,
write_bitcols=False):
"""
Create a new table extension and write the data.
The table definition is taken fro... |
def create_table_hdu(self, data=None, dtype=None,
header=None,
names=None, formats=None,
units=None, dims=None, extname=None, extver=None,
table_type='binary', write_bitcols=False):
"""
Create a new, empt... |
def update_hdu_list(self, rebuild=True):
"""
Force an update of the entire HDU list
Normally you don't need to call this method directly
if rebuild is false or the hdu_list is not yet set, the list is
rebuilt from scratch
"""
if not hasattr(self, 'hdu_list'):
... |
def _append_hdu_info(self, ext):
"""
internal routine
append info for indiciated extension
"""
# raised IOError if not found
hdu_type = self._FITS.movabs_hdu(ext+1)
if hdu_type == IMAGE_HDU:
hdu = ImageHDU(self._FITS, ext, **self.keys)
elif ... |
def next(self):
"""
Move to the next iteration
"""
if self._iter_index == len(self.hdu_list):
raise StopIteration
hdu = self.hdu_list[self._iter_index]
self._iter_index += 1
return hdu |
def _extract_item(self, item):
"""
utility function to extract an "item", meaning
a extension number,name plus version.
"""
ver = 0
if isinstance(item, tuple):
ver_sent = True
nitem = len(item)
if nitem == 1:
ext = item[... |
def _update_info(self):
"""
Call parent method and make sure this is in fact a
image HDU. Set dims in C order
"""
super(ImageHDU, self)._update_info()
if self._info['hdutype'] != IMAGE_HDU:
mess = "Extension %s is not a Image HDU" % self.ext
rais... |
def reshape(self, dims):
"""
reshape an existing image to the requested dimensions
parameters
----------
dims: sequence
Any sequence convertible to i8
"""
adims = numpy.array(dims, ndmin=1, dtype='i8')
self._FITS.reshape_image(self._ext+1, ad... |
def write(self, img, start=0, **keys):
"""
Write the image into this HDU
If data already exist in this HDU, they will be overwritten. If the
image to write is larger than the image on disk, or if the start
position is such that the write would extend beyond the existing
... |
def read(self, **keys):
"""
Read the image.
If the HDU is an IMAGE_HDU, read the corresponding image. Compression
and scaling are dealt with properly.
"""
if not self.has_data():
return None
dtype, shape = self._get_dtype_and_shape()
array =... |
def _get_dtype_and_shape(self):
"""
Get the numpy dtype and shape for image
"""
npy_dtype = self._get_image_numpy_dtype()
if self._info['ndims'] != 0:
shape = self._info['dims']
else:
raise IOError("no image present in HDU")
return npy_dt... |
def _get_image_numpy_dtype(self):
"""
Get the numpy dtype for the image
"""
try:
ftype = self._info['img_equiv_type']
npy_type = _image_bitpix2npy[ftype]
except KeyError:
raise KeyError("unsupported fits data type: %d" % ftype)
return ... |
def _read_image_slice(self, arg):
"""
workhorse to read a slice
"""
if 'ndims' not in self._info:
raise ValueError("Attempt to slice empty extension")
if isinstance(arg, slice):
# one-dimensional, e.g. 2:20
return self._read_image_slice((arg,)... |
def _expand_if_needed(self, dims, write_dims, start, offset):
"""
expand the on-disk image if the indended write will extend
beyond the existing dimensions
"""
from operator import mul
if numpy.isscalar(start):
start_is_scalar = True
else:
... |
def get_extname(self):
"""
Get the name for this extension, can be an empty string
"""
name = self._info['extname']
if name.strip() == '':
name = self._info['hduname']
return name.strip() |
def get_extver(self):
"""
Get the version for this extension.
Used when a name is given to multiple extensions
"""
ver = self._info['extver']
if ver == 0:
ver = self._info['hduver']
return ver |
def get_exttype(self, num=False):
"""
Get the extension type
By default the result is a string that mirrors
the enumerated type names in cfitsio
'IMAGE_HDU', 'ASCII_TBL', 'BINARY_TBL'
which have numeric values
0 1 2
send num=True to get the number... |
def get_offsets(self):
"""
returns
-------
a dictionary with these entries
header_start:
byte offset from beginning of the file to the start
of the header
data_start:
byte offset from beginning of the file to the start
of t... |
def verify_checksum(self):
"""
Verify the checksum in the header for this HDU.
"""
res = self._FITS.verify_checksum(self._ext+1)
if res['dataok'] != 1:
raise ValueError("data checksum failed")
if res['hduok'] != 1:
raise ValueError("hdu checksum fa... |
def write_comment(self, comment):
"""
Write a comment into the header
"""
self._FITS.write_comment(self._ext+1, str(comment)) |
def write_history(self, history):
"""
Write history text into the header
"""
self._FITS.write_history(self._ext+1, str(history)) |
def _write_continue(self, value):
"""
Write history text into the header
"""
self._FITS.write_continue(self._ext+1, str(value)) |
def write_key(self, name, value, comment=""):
"""
Write the input value to the header
parameters
----------
name: string
Name of keyword to write/update
value: scalar
Value to write, can be string float or integer type,
including numpy... |
def write_keys(self, records_in, clean=True):
"""
Write the keywords to the header.
parameters
----------
records: FITSHDR or list or dict
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optio... |
def _update_info(self):
"""
Update metadata for this HDU
"""
try:
self._FITS.movabs_hdu(self._ext+1)
except IOError:
raise RuntimeError("no such hdu")
self._info = self._FITS.get_hdu_info(self._ext+1) |
def _get_repr_list(self):
"""
Get some representation data common to all HDU types
"""
spacing = ' '*2
text = ['']
text.append("%sfile: %s" % (spacing, self._filename))
text.append("%sextension: %d" % (spacing, self._info['hdunum']-1))
text.append(
... |
def add_record(self, record_in):
"""
Add a new record. Strip quotes from around strings.
This will over-write if the key already exists, except
for COMMENT and HISTORY fields
parameters
-----------
record:
The record, either a dict or a header card ... |
def get_comment(self, item):
"""
Get the comment for the requested entry
"""
key = item.upper()
if key not in self._record_map:
raise KeyError("unknown record: %s" % key)
if 'comment' not in self._record_map[key]:
return None
else:
... |
def delete(self, name):
"""
Delete the specified entry if it exists.
"""
if isinstance(name, (list, tuple)):
for xx in name:
self.delete(xx)
else:
if name in self._record_map:
del self._record_map[name]
self.... |
def clean(self, is_table=False):
"""
Remove reserved keywords from the header.
These are keywords that the fits writer must write in order
to maintain consistency between header and data.
keywords
--------
is_table: bool, optional
Set True if this is... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.