repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens listlengths 20 707 | docstring stringlengths 3 17.3k | docstring_tokens listlengths 3 222 | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value | idx int64 0 252k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._extract_rows | 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 = self._info['nrows']-1
if rows[0] < 0 or rows[-1] > maxrow:
raise ValueError("rows must be in [%d,%d]" % (0, maxrow))
return rows | python | 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 = self._info['nrows']-1
if rows[0] < 0 or rows[-1] > maxrow:
raise ValueError("rows must be in [%d,%d]" % (0, maxrow))
return rows | [
"def",
"_extract_rows",
"(",
"self",
",",
"rows",
")",
":",
"if",
"rows",
"is",
"not",
"None",
":",
"rows",
"=",
"numpy",
".",
"array",
"(",
"rows",
",",
"ndmin",
"=",
"1",
",",
"copy",
"=",
"False",
",",
"dtype",
"=",
"'i8'",
")",
"# returns unique, sorted",
"rows",
"=",
"numpy",
".",
"unique",
"(",
"rows",
")",
"maxrow",
"=",
"self",
".",
"_info",
"[",
"'nrows'",
"]",
"-",
"1",
"if",
"rows",
"[",
"0",
"]",
"<",
"0",
"or",
"rows",
"[",
"-",
"1",
"]",
">",
"maxrow",
":",
"raise",
"ValueError",
"(",
"\"rows must be in [%d,%d]\"",
"%",
"(",
"0",
",",
"maxrow",
")",
")",
"return",
"rows"
] | Extract an array of rows from an input scalar or sequence | [
"Extract",
"an",
"array",
"of",
"rows",
"from",
"an",
"input",
"scalar",
"or",
"sequence"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1190-L1202 | train | 235,000 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._process_slice | 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
if stop is None:
stop = nrows
if start < 0:
start = nrows + start
if start < 0:
raise IndexError("Index out of bounds")
if stop < 0:
stop = nrows + start + 1
if stop < start:
# will return an empty struct
stop = start
if stop > nrows:
stop = nrows
return slice(start, stop, step) | python | 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
if stop is None:
stop = nrows
if start < 0:
start = nrows + start
if start < 0:
raise IndexError("Index out of bounds")
if stop < 0:
stop = nrows + start + 1
if stop < start:
# will return an empty struct
stop = start
if stop > nrows:
stop = nrows
return slice(start, stop, step) | [
"def",
"_process_slice",
"(",
"self",
",",
"arg",
")",
":",
"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",
"if",
"stop",
"is",
"None",
":",
"stop",
"=",
"nrows",
"if",
"start",
"<",
"0",
":",
"start",
"=",
"nrows",
"+",
"start",
"if",
"start",
"<",
"0",
":",
"raise",
"IndexError",
"(",
"\"Index out of bounds\"",
")",
"if",
"stop",
"<",
"0",
":",
"stop",
"=",
"nrows",
"+",
"start",
"+",
"1",
"if",
"stop",
"<",
"start",
":",
"# will return an empty struct",
"stop",
"=",
"start",
"if",
"stop",
">",
"nrows",
":",
"stop",
"=",
"nrows",
"return",
"slice",
"(",
"start",
",",
"stop",
",",
"step",
")"
] | process the input slice for use calling the C code | [
"process",
"the",
"input",
"slice",
"for",
"use",
"calling",
"the",
"C",
"code"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1204-L1234 | train | 235,001 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._slice2rows | 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 = self._fix_range(start)
tstop = self._fix_range(stop)
if tstart == 0 and tstop == nrows:
# this is faster: if all fields are also requested, then a
# single fread will be done
return None
if stop < start:
raise ValueError("start is greater than stop in slice")
return numpy.arange(tstart, tstop, step, dtype='i8') | python | 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 = self._fix_range(start)
tstop = self._fix_range(stop)
if tstart == 0 and tstop == nrows:
# this is faster: if all fields are also requested, then a
# single fread will be done
return None
if stop < start:
raise ValueError("start is greater than stop in slice")
return numpy.arange(tstart, tstop, step, dtype='i8') | [
"def",
"_slice2rows",
"(",
"self",
",",
"start",
",",
"stop",
",",
"step",
"=",
"None",
")",
":",
"nrows",
"=",
"self",
".",
"_info",
"[",
"'nrows'",
"]",
"if",
"start",
"is",
"None",
":",
"start",
"=",
"0",
"if",
"stop",
"is",
"None",
":",
"stop",
"=",
"nrows",
"if",
"step",
"is",
"None",
":",
"step",
"=",
"1",
"tstart",
"=",
"self",
".",
"_fix_range",
"(",
"start",
")",
"tstop",
"=",
"self",
".",
"_fix_range",
"(",
"stop",
")",
"if",
"tstart",
"==",
"0",
"and",
"tstop",
"==",
"nrows",
":",
"# this is faster: if all fields are also requested, then a",
"# single fread will be done",
"return",
"None",
"if",
"stop",
"<",
"start",
":",
"raise",
"ValueError",
"(",
"\"start is greater than stop in slice\"",
")",
"return",
"numpy",
".",
"arange",
"(",
"tstart",
",",
"tstop",
",",
"step",
",",
"dtype",
"=",
"'i8'",
")"
] | Convert a slice to an explicit array of rows | [
"Convert",
"a",
"slice",
"to",
"an",
"explicit",
"array",
"of",
"rows"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1236-L1256 | train | 235,002 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._fix_range | 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)
elif num > nrows:
num = nrows
else:
# single element
if num < 0:
num = nrows + num
elif num > (nrows-1):
num = nrows-1
return num | python | 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)
elif num > nrows:
num = nrows
else:
# single element
if num < 0:
num = nrows + num
elif num > (nrows-1):
num = nrows-1
return num | [
"def",
"_fix_range",
"(",
"self",
",",
"num",
",",
"isslice",
"=",
"True",
")",
":",
"nrows",
"=",
"self",
".",
"_info",
"[",
"'nrows'",
"]",
"if",
"isslice",
":",
"# include the end",
"if",
"num",
"<",
"0",
":",
"num",
"=",
"nrows",
"+",
"(",
"1",
"+",
"num",
")",
"elif",
"num",
">",
"nrows",
":",
"num",
"=",
"nrows",
"else",
":",
"# single element",
"if",
"num",
"<",
"0",
":",
"num",
"=",
"nrows",
"+",
"num",
"elif",
"num",
">",
"(",
"nrows",
"-",
"1",
")",
":",
"num",
"=",
"nrows",
"-",
"1",
"return",
"num"
] | Ensure the input is within range.
If el=True, then don't treat as a slice element | [
"Ensure",
"the",
"input",
"is",
"within",
"range",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1258-L1279 | train | 235,003 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._rescale_and_convert_field_inplace | 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._convert_bool_array(array[name])
return array | python | 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._convert_bool_array(array[name])
return array | [
"def",
"_rescale_and_convert_field_inplace",
"(",
"self",
",",
"array",
",",
"name",
",",
"scale",
",",
"zero",
")",
":",
"self",
".",
"_rescale_array",
"(",
"array",
"[",
"name",
"]",
",",
"scale",
",",
"zero",
")",
"if",
"array",
"[",
"name",
"]",
".",
"dtype",
"==",
"numpy",
".",
"bool",
":",
"array",
"[",
"name",
"]",
"=",
"self",
".",
"_convert_bool_array",
"(",
"array",
"[",
"name",
"]",
")",
"return",
"array"
] | Apply fits scalings. Also, convert bool to proper
numpy boolean values | [
"Apply",
"fits",
"scalings",
".",
"Also",
"convert",
"bool",
"to",
"proper",
"numpy",
"boolean",
"values"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1281-L1289 | train | 235,004 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._rescale_array | 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 | python | 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",
"_rescale_array",
"(",
"self",
",",
"array",
",",
"scale",
",",
"zero",
")",
":",
"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"
] | Scale the input array | [
"Scale",
"the",
"input",
"array"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1302-L1311 | train | 235,005 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._maybe_trim_strings | 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) | python | 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",
"_maybe_trim_strings",
"(",
"self",
",",
"array",
",",
"*",
"*",
"keys",
")",
":",
"trim_strings",
"=",
"keys",
".",
"get",
"(",
"'trim_strings'",
",",
"False",
")",
"if",
"self",
".",
"trim_strings",
"or",
"trim_strings",
":",
"_trim_strings",
"(",
"array",
")"
] | if requested, trim trailing white space from
all string fields in the input array | [
"if",
"requested",
"trim",
"trailing",
"white",
"space",
"from",
"all",
"string",
"fields",
"in",
"the",
"input",
"array"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1313-L1320 | train | 235,006 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._get_tbl_numpy_dtype | 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 table_type == ASCII_TBL:
npy_type = _table_fits2npy_ascii[abs(ftype)]
else:
npy_type = _table_fits2npy[abs(ftype)]
except KeyError:
raise KeyError("unsupported %s fits data "
"type: %d" % (table_type_string, ftype))
istbit = False
if (ftype == 1):
istbit = True
isvar = False
if ftype < 0:
isvar = True
if include_endianness:
# if binary we will read the big endian bytes directly,
# if ascii we read into native byte order
if table_type == ASCII_TBL:
addstr = ''
else:
addstr = '>'
if npy_type not in ['u1', 'i1', 'S', 'U']:
npy_type = addstr+npy_type
if npy_type == 'S':
width = self._info['colinfo'][colnum]['width']
npy_type = 'S%d' % width
elif npy_type == 'U':
width = self._info['colinfo'][colnum]['width']
npy_type = 'U%d' % width
return npy_type, isvar, istbit | python | 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 table_type == ASCII_TBL:
npy_type = _table_fits2npy_ascii[abs(ftype)]
else:
npy_type = _table_fits2npy[abs(ftype)]
except KeyError:
raise KeyError("unsupported %s fits data "
"type: %d" % (table_type_string, ftype))
istbit = False
if (ftype == 1):
istbit = True
isvar = False
if ftype < 0:
isvar = True
if include_endianness:
# if binary we will read the big endian bytes directly,
# if ascii we read into native byte order
if table_type == ASCII_TBL:
addstr = ''
else:
addstr = '>'
if npy_type not in ['u1', 'i1', 'S', 'U']:
npy_type = addstr+npy_type
if npy_type == 'S':
width = self._info['colinfo'][colnum]['width']
npy_type = 'S%d' % width
elif npy_type == 'U':
width = self._info['colinfo'][colnum]['width']
npy_type = 'U%d' % width
return npy_type, isvar, istbit | [
"def",
"_get_tbl_numpy_dtype",
"(",
"self",
",",
"colnum",
",",
"include_endianness",
"=",
"True",
")",
":",
"table_type",
"=",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"table_type_string",
"=",
"_hdu_type_map",
"[",
"table_type",
"]",
"try",
":",
"ftype",
"=",
"self",
".",
"_info",
"[",
"'colinfo'",
"]",
"[",
"colnum",
"]",
"[",
"'eqtype'",
"]",
"if",
"table_type",
"==",
"ASCII_TBL",
":",
"npy_type",
"=",
"_table_fits2npy_ascii",
"[",
"abs",
"(",
"ftype",
")",
"]",
"else",
":",
"npy_type",
"=",
"_table_fits2npy",
"[",
"abs",
"(",
"ftype",
")",
"]",
"except",
"KeyError",
":",
"raise",
"KeyError",
"(",
"\"unsupported %s fits data \"",
"\"type: %d\"",
"%",
"(",
"table_type_string",
",",
"ftype",
")",
")",
"istbit",
"=",
"False",
"if",
"(",
"ftype",
"==",
"1",
")",
":",
"istbit",
"=",
"True",
"isvar",
"=",
"False",
"if",
"ftype",
"<",
"0",
":",
"isvar",
"=",
"True",
"if",
"include_endianness",
":",
"# if binary we will read the big endian bytes directly,",
"# if ascii we read into native byte order",
"if",
"table_type",
"==",
"ASCII_TBL",
":",
"addstr",
"=",
"''",
"else",
":",
"addstr",
"=",
"'>'",
"if",
"npy_type",
"not",
"in",
"[",
"'u1'",
",",
"'i1'",
",",
"'S'",
",",
"'U'",
"]",
":",
"npy_type",
"=",
"addstr",
"+",
"npy_type",
"if",
"npy_type",
"==",
"'S'",
":",
"width",
"=",
"self",
".",
"_info",
"[",
"'colinfo'",
"]",
"[",
"colnum",
"]",
"[",
"'width'",
"]",
"npy_type",
"=",
"'S%d'",
"%",
"width",
"elif",
"npy_type",
"==",
"'U'",
":",
"width",
"=",
"self",
".",
"_info",
"[",
"'colinfo'",
"]",
"[",
"colnum",
"]",
"[",
"'width'",
"]",
"npy_type",
"=",
"'U%d'",
"%",
"width",
"return",
"npy_type",
",",
"isvar",
",",
"istbit"
] | Get numpy type for the input column | [
"Get",
"numpy",
"type",
"for",
"the",
"input",
"column"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1353-L1393 | train | 235,007 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._process_args_as_rows_or_columns | 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]
['f1',f2',...]
Can also be tuples or arrays.
"""
flags = set()
#
if isinstance(arg, (tuple, list, numpy.ndarray)):
# a sequence was entered
if isstring(arg[0]):
result = arg
else:
result = arg
flags.add('isrows')
elif isstring(arg):
# a single string was entered
result = arg
elif isinstance(arg, slice):
if unpack:
flags.add('isrows')
result = self._slice2rows(arg.start, arg.stop, arg.step)
else:
flags.add('isrows')
flags.add('isslice')
result = self._process_slice(arg)
else:
# a single object was entered.
# Probably should apply some more checking on this
result = arg
flags.add('isrows')
if numpy.ndim(arg) == 0:
flags.add('isscalar')
return result, flags | python | 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]
['f1',f2',...]
Can also be tuples or arrays.
"""
flags = set()
#
if isinstance(arg, (tuple, list, numpy.ndarray)):
# a sequence was entered
if isstring(arg[0]):
result = arg
else:
result = arg
flags.add('isrows')
elif isstring(arg):
# a single string was entered
result = arg
elif isinstance(arg, slice):
if unpack:
flags.add('isrows')
result = self._slice2rows(arg.start, arg.stop, arg.step)
else:
flags.add('isrows')
flags.add('isslice')
result = self._process_slice(arg)
else:
# a single object was entered.
# Probably should apply some more checking on this
result = arg
flags.add('isrows')
if numpy.ndim(arg) == 0:
flags.add('isscalar')
return result, flags | [
"def",
"_process_args_as_rows_or_columns",
"(",
"self",
",",
"arg",
",",
"unpack",
"=",
"False",
")",
":",
"flags",
"=",
"set",
"(",
")",
"#",
"if",
"isinstance",
"(",
"arg",
",",
"(",
"tuple",
",",
"list",
",",
"numpy",
".",
"ndarray",
")",
")",
":",
"# a sequence was entered",
"if",
"isstring",
"(",
"arg",
"[",
"0",
"]",
")",
":",
"result",
"=",
"arg",
"else",
":",
"result",
"=",
"arg",
"flags",
".",
"add",
"(",
"'isrows'",
")",
"elif",
"isstring",
"(",
"arg",
")",
":",
"# a single string was entered",
"result",
"=",
"arg",
"elif",
"isinstance",
"(",
"arg",
",",
"slice",
")",
":",
"if",
"unpack",
":",
"flags",
".",
"add",
"(",
"'isrows'",
")",
"result",
"=",
"self",
".",
"_slice2rows",
"(",
"arg",
".",
"start",
",",
"arg",
".",
"stop",
",",
"arg",
".",
"step",
")",
"else",
":",
"flags",
".",
"add",
"(",
"'isrows'",
")",
"flags",
".",
"add",
"(",
"'isslice'",
")",
"result",
"=",
"self",
".",
"_process_slice",
"(",
"arg",
")",
"else",
":",
"# a single object was entered.",
"# Probably should apply some more checking on this",
"result",
"=",
"arg",
"flags",
".",
"add",
"(",
"'isrows'",
")",
"if",
"numpy",
".",
"ndim",
"(",
"arg",
")",
"==",
"0",
":",
"flags",
".",
"add",
"(",
"'isscalar'",
")",
"return",
"result",
",",
"flags"
] | 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]
['f1',f2',...]
Can also be tuples or arrays. | [
"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",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1395-L1437 | train | 235,008 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._extract_colnums | 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._extract_colnum(columns)
colnums = numpy.zeros(len(columns), dtype='i8')
for i in xrange(colnums.size):
colnums[i] = self._extract_colnum(columns[i])
# returns unique sorted
colnums = numpy.unique(colnums)
return colnums | python | 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._extract_colnum(columns)
colnums = numpy.zeros(len(columns), dtype='i8')
for i in xrange(colnums.size):
colnums[i] = self._extract_colnum(columns[i])
# returns unique sorted
colnums = numpy.unique(colnums)
return colnums | [
"def",
"_extract_colnums",
"(",
"self",
",",
"columns",
"=",
"None",
")",
":",
"if",
"columns",
"is",
"None",
":",
"return",
"numpy",
".",
"arange",
"(",
"self",
".",
"_ncol",
",",
"dtype",
"=",
"'i8'",
")",
"if",
"not",
"isinstance",
"(",
"columns",
",",
"(",
"tuple",
",",
"list",
",",
"numpy",
".",
"ndarray",
")",
")",
":",
"# is a scalar",
"return",
"self",
".",
"_extract_colnum",
"(",
"columns",
")",
"colnums",
"=",
"numpy",
".",
"zeros",
"(",
"len",
"(",
"columns",
")",
",",
"dtype",
"=",
"'i8'",
")",
"for",
"i",
"in",
"xrange",
"(",
"colnums",
".",
"size",
")",
":",
"colnums",
"[",
"i",
"]",
"=",
"self",
".",
"_extract_colnum",
"(",
"columns",
"[",
"i",
"]",
")",
"# returns unique sorted",
"colnums",
"=",
"numpy",
".",
"unique",
"(",
"colnums",
")",
"return",
"colnums"
] | Extract an array of columns from the input | [
"Extract",
"an",
"array",
"of",
"columns",
"from",
"the",
"input"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1494-L1511 | train | 235,009 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._extract_colnum | 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._ncol-1))
else:
colstr = mks(col)
try:
if self.case_sensitive:
mess = "column name '%s' not found (case sensitive)" % col
colnum = self._colnames.index(colstr)
else:
mess \
= "column name '%s' not found (case insensitive)" % col
colnum = self._colnames_lower.index(colstr.lower())
except ValueError:
raise ValueError(mess)
return int(colnum) | python | 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._ncol-1))
else:
colstr = mks(col)
try:
if self.case_sensitive:
mess = "column name '%s' not found (case sensitive)" % col
colnum = self._colnames.index(colstr)
else:
mess \
= "column name '%s' not found (case insensitive)" % col
colnum = self._colnames_lower.index(colstr.lower())
except ValueError:
raise ValueError(mess)
return int(colnum) | [
"def",
"_extract_colnum",
"(",
"self",
",",
"col",
")",
":",
"if",
"isinteger",
"(",
"col",
")",
":",
"colnum",
"=",
"col",
"if",
"(",
"colnum",
"<",
"0",
")",
"or",
"(",
"colnum",
">",
"(",
"self",
".",
"_ncol",
"-",
"1",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"column number should be in [0,%d]\"",
"%",
"(",
"0",
",",
"self",
".",
"_ncol",
"-",
"1",
")",
")",
"else",
":",
"colstr",
"=",
"mks",
"(",
"col",
")",
"try",
":",
"if",
"self",
".",
"case_sensitive",
":",
"mess",
"=",
"\"column name '%s' not found (case sensitive)\"",
"%",
"col",
"colnum",
"=",
"self",
".",
"_colnames",
".",
"index",
"(",
"colstr",
")",
"else",
":",
"mess",
"=",
"\"column name '%s' not found (case insensitive)\"",
"%",
"col",
"colnum",
"=",
"self",
".",
"_colnames_lower",
".",
"index",
"(",
"colstr",
".",
"lower",
"(",
")",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"mess",
")",
"return",
"int",
"(",
"colnum",
")"
] | Get the column number for the input column | [
"Get",
"the",
"column",
"number",
"for",
"the",
"input",
"column"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1513-L1535 | train | 235,010 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._update_info | 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
raise ValueError(mess)
if 'colinfo' in self._info:
self._colnames = [i['name'] for i in self._info['colinfo']]
self._colnames_lower = [
i['name'].lower() for i in self._info['colinfo']]
self._ncol = len(self._colnames) | python | 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
raise ValueError(mess)
if 'colinfo' in self._info:
self._colnames = [i['name'] for i in self._info['colinfo']]
self._colnames_lower = [
i['name'].lower() for i in self._info['colinfo']]
self._ncol = len(self._colnames) | [
"def",
"_update_info",
"(",
"self",
")",
":",
"super",
"(",
"TableHDU",
",",
"self",
")",
".",
"_update_info",
"(",
")",
"if",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"==",
"IMAGE_HDU",
":",
"mess",
"=",
"\"Extension %s is not a Table HDU\"",
"%",
"self",
".",
"ext",
"raise",
"ValueError",
"(",
"mess",
")",
"if",
"'colinfo'",
"in",
"self",
".",
"_info",
":",
"self",
".",
"_colnames",
"=",
"[",
"i",
"[",
"'name'",
"]",
"for",
"i",
"in",
"self",
".",
"_info",
"[",
"'colinfo'",
"]",
"]",
"self",
".",
"_colnames_lower",
"=",
"[",
"i",
"[",
"'name'",
"]",
".",
"lower",
"(",
")",
"for",
"i",
"in",
"self",
".",
"_info",
"[",
"'colinfo'",
"]",
"]",
"self",
".",
"_ncol",
"=",
"len",
"(",
"self",
".",
"_colnames",
")"
] | Call parent method and make sure this is in fact a
table HDU. Set some convenience data. | [
"Call",
"parent",
"method",
"and",
"make",
"sure",
"this",
"is",
"in",
"fact",
"a",
"table",
"HDU",
".",
"Set",
"some",
"convenience",
"data",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1537-L1550 | train | 235,011 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._get_next_buffered_row | 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_buffer[self._row_buffer_index]
self._iter_row += 1
self._row_buffer_index += 1
return data | python | 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_buffer[self._row_buffer_index]
self._iter_row += 1
self._row_buffer_index += 1
return data | [
"def",
"_get_next_buffered_row",
"(",
"self",
")",
":",
"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_buffer",
"[",
"self",
".",
"_row_buffer_index",
"]",
"self",
".",
"_iter_row",
"+=",
"1",
"self",
".",
"_row_buffer_index",
"+=",
"1",
"return",
"data"
] | Get the next row for iteration. | [
"Get",
"the",
"next",
"row",
"for",
"iteration",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1640-L1653 | train | 235,012 |
esheldon/fitsio | fitsio/hdu/table.py | TableHDU._buffer_iter_rows | 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 | python | 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",
"_buffer_iter_rows",
"(",
"self",
",",
"start",
")",
":",
"self",
".",
"_row_buffer",
"=",
"self",
"[",
"start",
":",
"start",
"+",
"self",
".",
"_iter_row_buffer",
"]",
"# start back at the front of the buffer",
"self",
".",
"_row_buffer_index",
"=",
"0"
] | Read in the buffer for iteration | [
"Read",
"in",
"the",
"buffer",
"for",
"iteration"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1655-L1662 | train | 235,013 |
esheldon/fitsio | fitsio/hdu/table.py | AsciiTableHDU.read | 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
----------
columns: list/array
An optional set of columns to read from table HDUs. Can be string
or number. If a sequence, a recarray is always returned. If a
scalar, an ordinary array is returned.
rows: list/array, optional
An optional list of rows to read from table HDUS. Default is to
read all.
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: bool, optional
If True, force all columns names to lower case in output. Will over
ride the lower= keyword from construction.
upper: bool, optional
If True, force all columns names to upper case in output. Will over
ride the lower= keyword from construction.
"""
rows = keys.get('rows', None)
columns = keys.get('columns', None)
# if columns is None, returns all. Guaranteed to be unique and sorted
colnums = self._extract_colnums(columns)
if isinstance(colnums, int):
# scalar sent, don't read as a recarray
return self.read_column(columns, **keys)
rows = self._extract_rows(rows)
if rows is None:
nrows = self._info['nrows']
else:
nrows = rows.size
# if rows is None still returns None, and is correctly interpreted
# by the reader to mean all
rows = self._extract_rows(rows)
# this is the full dtype for all columns
dtype, offsets, isvar = self.get_rec_dtype(colnums=colnums, **keys)
array = numpy.zeros(nrows, dtype=dtype)
# note reading into existing data
wnotvar, = numpy.where(isvar == False) # noqa
if wnotvar.size > 0:
for i in wnotvar:
colnum = colnums[i]
name = array.dtype.names[i]
a = array[name].copy()
self._FITS.read_column(self._ext+1, colnum+1, a, rows)
array[name] = a
del a
array = self._maybe_decode_fits_ascii_strings_to_unicode_py3(array)
wvar, = numpy.where(isvar == True) # noqa
if wvar.size > 0:
for i in wvar:
colnum = colnums[i]
name = array.dtype.names[i]
dlist = self._FITS.read_var_column_as_list(
self._ext+1, colnum+1, rows)
if (isinstance(dlist[0], str) or
(IS_PY3 and isinstance(dlist[0], bytes))):
is_string = True
else:
is_string = False
if array[name].dtype.descr[0][1][1] == 'O':
# storing in object array
# get references to each, no copy made
for irow, item in enumerate(dlist):
if IS_PY3 and isinstance(item, bytes):
item = item.decode('ascii')
array[name][irow] = item
else:
for irow, item in enumerate(dlist):
if IS_PY3 and isinstance(item, bytes):
item = item.decode('ascii')
if is_string:
array[name][irow] = item
else:
ncopy = len(item)
array[name][irow][0:ncopy] = item[:]
lower = keys.get('lower', False)
upper = keys.get('upper', False)
if self.lower or lower:
_names_to_lower_if_recarray(array)
elif self.upper or upper:
_names_to_upper_if_recarray(array)
self._maybe_trim_strings(array, **keys)
return array | python | 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
----------
columns: list/array
An optional set of columns to read from table HDUs. Can be string
or number. If a sequence, a recarray is always returned. If a
scalar, an ordinary array is returned.
rows: list/array, optional
An optional list of rows to read from table HDUS. Default is to
read all.
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: bool, optional
If True, force all columns names to lower case in output. Will over
ride the lower= keyword from construction.
upper: bool, optional
If True, force all columns names to upper case in output. Will over
ride the lower= keyword from construction.
"""
rows = keys.get('rows', None)
columns = keys.get('columns', None)
# if columns is None, returns all. Guaranteed to be unique and sorted
colnums = self._extract_colnums(columns)
if isinstance(colnums, int):
# scalar sent, don't read as a recarray
return self.read_column(columns, **keys)
rows = self._extract_rows(rows)
if rows is None:
nrows = self._info['nrows']
else:
nrows = rows.size
# if rows is None still returns None, and is correctly interpreted
# by the reader to mean all
rows = self._extract_rows(rows)
# this is the full dtype for all columns
dtype, offsets, isvar = self.get_rec_dtype(colnums=colnums, **keys)
array = numpy.zeros(nrows, dtype=dtype)
# note reading into existing data
wnotvar, = numpy.where(isvar == False) # noqa
if wnotvar.size > 0:
for i in wnotvar:
colnum = colnums[i]
name = array.dtype.names[i]
a = array[name].copy()
self._FITS.read_column(self._ext+1, colnum+1, a, rows)
array[name] = a
del a
array = self._maybe_decode_fits_ascii_strings_to_unicode_py3(array)
wvar, = numpy.where(isvar == True) # noqa
if wvar.size > 0:
for i in wvar:
colnum = colnums[i]
name = array.dtype.names[i]
dlist = self._FITS.read_var_column_as_list(
self._ext+1, colnum+1, rows)
if (isinstance(dlist[0], str) or
(IS_PY3 and isinstance(dlist[0], bytes))):
is_string = True
else:
is_string = False
if array[name].dtype.descr[0][1][1] == 'O':
# storing in object array
# get references to each, no copy made
for irow, item in enumerate(dlist):
if IS_PY3 and isinstance(item, bytes):
item = item.decode('ascii')
array[name][irow] = item
else:
for irow, item in enumerate(dlist):
if IS_PY3 and isinstance(item, bytes):
item = item.decode('ascii')
if is_string:
array[name][irow] = item
else:
ncopy = len(item)
array[name][irow][0:ncopy] = item[:]
lower = keys.get('lower', False)
upper = keys.get('upper', False)
if self.lower or lower:
_names_to_lower_if_recarray(array)
elif self.upper or upper:
_names_to_upper_if_recarray(array)
self._maybe_trim_strings(array, **keys)
return array | [
"def",
"read",
"(",
"self",
",",
"*",
"*",
"keys",
")",
":",
"rows",
"=",
"keys",
".",
"get",
"(",
"'rows'",
",",
"None",
")",
"columns",
"=",
"keys",
".",
"get",
"(",
"'columns'",
",",
"None",
")",
"# if columns is None, returns all. Guaranteed to be unique and sorted",
"colnums",
"=",
"self",
".",
"_extract_colnums",
"(",
"columns",
")",
"if",
"isinstance",
"(",
"colnums",
",",
"int",
")",
":",
"# scalar sent, don't read as a recarray",
"return",
"self",
".",
"read_column",
"(",
"columns",
",",
"*",
"*",
"keys",
")",
"rows",
"=",
"self",
".",
"_extract_rows",
"(",
"rows",
")",
"if",
"rows",
"is",
"None",
":",
"nrows",
"=",
"self",
".",
"_info",
"[",
"'nrows'",
"]",
"else",
":",
"nrows",
"=",
"rows",
".",
"size",
"# if rows is None still returns None, and is correctly interpreted",
"# by the reader to mean all",
"rows",
"=",
"self",
".",
"_extract_rows",
"(",
"rows",
")",
"# this is the full dtype for all columns",
"dtype",
",",
"offsets",
",",
"isvar",
"=",
"self",
".",
"get_rec_dtype",
"(",
"colnums",
"=",
"colnums",
",",
"*",
"*",
"keys",
")",
"array",
"=",
"numpy",
".",
"zeros",
"(",
"nrows",
",",
"dtype",
"=",
"dtype",
")",
"# note reading into existing data",
"wnotvar",
",",
"=",
"numpy",
".",
"where",
"(",
"isvar",
"==",
"False",
")",
"# noqa",
"if",
"wnotvar",
".",
"size",
">",
"0",
":",
"for",
"i",
"in",
"wnotvar",
":",
"colnum",
"=",
"colnums",
"[",
"i",
"]",
"name",
"=",
"array",
".",
"dtype",
".",
"names",
"[",
"i",
"]",
"a",
"=",
"array",
"[",
"name",
"]",
".",
"copy",
"(",
")",
"self",
".",
"_FITS",
".",
"read_column",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"colnum",
"+",
"1",
",",
"a",
",",
"rows",
")",
"array",
"[",
"name",
"]",
"=",
"a",
"del",
"a",
"array",
"=",
"self",
".",
"_maybe_decode_fits_ascii_strings_to_unicode_py3",
"(",
"array",
")",
"wvar",
",",
"=",
"numpy",
".",
"where",
"(",
"isvar",
"==",
"True",
")",
"# noqa",
"if",
"wvar",
".",
"size",
">",
"0",
":",
"for",
"i",
"in",
"wvar",
":",
"colnum",
"=",
"colnums",
"[",
"i",
"]",
"name",
"=",
"array",
".",
"dtype",
".",
"names",
"[",
"i",
"]",
"dlist",
"=",
"self",
".",
"_FITS",
".",
"read_var_column_as_list",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"colnum",
"+",
"1",
",",
"rows",
")",
"if",
"(",
"isinstance",
"(",
"dlist",
"[",
"0",
"]",
",",
"str",
")",
"or",
"(",
"IS_PY3",
"and",
"isinstance",
"(",
"dlist",
"[",
"0",
"]",
",",
"bytes",
")",
")",
")",
":",
"is_string",
"=",
"True",
"else",
":",
"is_string",
"=",
"False",
"if",
"array",
"[",
"name",
"]",
".",
"dtype",
".",
"descr",
"[",
"0",
"]",
"[",
"1",
"]",
"[",
"1",
"]",
"==",
"'O'",
":",
"# storing in object array",
"# get references to each, no copy made",
"for",
"irow",
",",
"item",
"in",
"enumerate",
"(",
"dlist",
")",
":",
"if",
"IS_PY3",
"and",
"isinstance",
"(",
"item",
",",
"bytes",
")",
":",
"item",
"=",
"item",
".",
"decode",
"(",
"'ascii'",
")",
"array",
"[",
"name",
"]",
"[",
"irow",
"]",
"=",
"item",
"else",
":",
"for",
"irow",
",",
"item",
"in",
"enumerate",
"(",
"dlist",
")",
":",
"if",
"IS_PY3",
"and",
"isinstance",
"(",
"item",
",",
"bytes",
")",
":",
"item",
"=",
"item",
".",
"decode",
"(",
"'ascii'",
")",
"if",
"is_string",
":",
"array",
"[",
"name",
"]",
"[",
"irow",
"]",
"=",
"item",
"else",
":",
"ncopy",
"=",
"len",
"(",
"item",
")",
"array",
"[",
"name",
"]",
"[",
"irow",
"]",
"[",
"0",
":",
"ncopy",
"]",
"=",
"item",
"[",
":",
"]",
"lower",
"=",
"keys",
".",
"get",
"(",
"'lower'",
",",
"False",
")",
"upper",
"=",
"keys",
".",
"get",
"(",
"'upper'",
",",
"False",
")",
"if",
"self",
".",
"lower",
"or",
"lower",
":",
"_names_to_lower_if_recarray",
"(",
"array",
")",
"elif",
"self",
".",
"upper",
"or",
"upper",
":",
"_names_to_upper_if_recarray",
"(",
"array",
")",
"self",
".",
"_maybe_trim_strings",
"(",
"array",
",",
"*",
"*",
"keys",
")",
"return",
"array"
] | 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
----------
columns: list/array
An optional set of columns to read from table HDUs. Can be string
or number. If a sequence, a recarray is always returned. If a
scalar, an ordinary array is returned.
rows: list/array, optional
An optional list of rows to read from table HDUS. Default is to
read all.
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: bool, optional
If True, force all columns names to lower case in output. Will over
ride the lower= keyword from construction.
upper: bool, optional
If True, force all columns names to upper case in output. Will over
ride the lower= keyword from construction. | [
"read",
"a",
"data",
"from",
"an",
"ascii",
"table",
"HDU"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1713-L1816 | train | 235,014 |
esheldon/fitsio | fitsio/hdu/table.py | TableColumnSubset.read | 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'] = self.columns
data = self.fitshdu.read(**keys)
return data | python | 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'] = self.columns
data = self.fitshdu.read(**keys)
return data | [
"def",
"read",
"(",
"self",
",",
"*",
"*",
"keys",
")",
":",
"if",
"self",
".",
"is_scalar",
":",
"data",
"=",
"self",
".",
"fitshdu",
".",
"read_column",
"(",
"self",
".",
"columns",
",",
"*",
"*",
"keys",
")",
"else",
":",
"c",
"=",
"keys",
".",
"get",
"(",
"'columns'",
",",
"None",
")",
"if",
"c",
"is",
"None",
":",
"keys",
"[",
"'columns'",
"]",
"=",
"self",
".",
"columns",
"data",
"=",
"self",
".",
"fitshdu",
".",
"read",
"(",
"*",
"*",
"keys",
")",
"return",
"data"
] | Read the data from disk and return as a numpy array | [
"Read",
"the",
"data",
"from",
"disk",
"and",
"return",
"as",
"a",
"numpy",
"array"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/table.py#L1868-L1881 | train | 235,015 |
esheldon/fitsio | fitsio/fitslib.py | read | 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 single column as an ordinary array.
For images, create a FITS object and use slice notation to read subsets.
Under the hood, a FITS object is constructed and data are read using
an associated FITSHDU object.
parameters
----------
filename: string
A filename.
ext: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. If not sent, data is read from
the first HDU that has data.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
columns: list or array, optional
An optional set of columns to read from table HDUs. Default is to
read all. Can be string or number.
rows: optional
An optional list of rows to read from table HDUS. Default is to
read all.
header: bool, optional
If True, read the FITS header and return a tuple (data,header)
Default is False.
case_sensitive: bool, optional
Match column names and extension names with case-sensitivity. Default
is False.
lower: bool, optional
If True, force all columns names to lower case in output
upper: bool, optional
If True, force all columns names to upper case in output
vstorage: string, optional
Set the default method to store variable length columns. Can be
'fixed' or 'object'. See docs on fitsio.FITS for details.
"""
with FITS(filename, **keys) as fits:
header = keys.pop('header', False)
if ext is None:
for i in xrange(len(fits)):
if fits[i].has_data():
ext = i
break
if ext is None:
raise IOError("No extensions have data")
item = _make_item(ext, extver=extver)
data = fits[item].read(**keys)
if header:
h = fits[item].read_header()
return data, h
else:
return data | python | 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 single column as an ordinary array.
For images, create a FITS object and use slice notation to read subsets.
Under the hood, a FITS object is constructed and data are read using
an associated FITSHDU object.
parameters
----------
filename: string
A filename.
ext: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. If not sent, data is read from
the first HDU that has data.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
columns: list or array, optional
An optional set of columns to read from table HDUs. Default is to
read all. Can be string or number.
rows: optional
An optional list of rows to read from table HDUS. Default is to
read all.
header: bool, optional
If True, read the FITS header and return a tuple (data,header)
Default is False.
case_sensitive: bool, optional
Match column names and extension names with case-sensitivity. Default
is False.
lower: bool, optional
If True, force all columns names to lower case in output
upper: bool, optional
If True, force all columns names to upper case in output
vstorage: string, optional
Set the default method to store variable length columns. Can be
'fixed' or 'object'. See docs on fitsio.FITS for details.
"""
with FITS(filename, **keys) as fits:
header = keys.pop('header', False)
if ext is None:
for i in xrange(len(fits)):
if fits[i].has_data():
ext = i
break
if ext is None:
raise IOError("No extensions have data")
item = _make_item(ext, extver=extver)
data = fits[item].read(**keys)
if header:
h = fits[item].read_header()
return data, h
else:
return data | [
"def",
"read",
"(",
"filename",
",",
"ext",
"=",
"None",
",",
"extver",
"=",
"None",
",",
"*",
"*",
"keys",
")",
":",
"with",
"FITS",
"(",
"filename",
",",
"*",
"*",
"keys",
")",
"as",
"fits",
":",
"header",
"=",
"keys",
".",
"pop",
"(",
"'header'",
",",
"False",
")",
"if",
"ext",
"is",
"None",
":",
"for",
"i",
"in",
"xrange",
"(",
"len",
"(",
"fits",
")",
")",
":",
"if",
"fits",
"[",
"i",
"]",
".",
"has_data",
"(",
")",
":",
"ext",
"=",
"i",
"break",
"if",
"ext",
"is",
"None",
":",
"raise",
"IOError",
"(",
"\"No extensions have data\"",
")",
"item",
"=",
"_make_item",
"(",
"ext",
",",
"extver",
"=",
"extver",
")",
"data",
"=",
"fits",
"[",
"item",
"]",
".",
"read",
"(",
"*",
"*",
"keys",
")",
"if",
"header",
":",
"h",
"=",
"fits",
"[",
"item",
"]",
".",
"read_header",
"(",
")",
"return",
"data",
",",
"h",
"else",
":",
"return",
"data"
] | 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 single column as an ordinary array.
For images, create a FITS object and use slice notation to read subsets.
Under the hood, a FITS object is constructed and data are read using
an associated FITSHDU object.
parameters
----------
filename: string
A filename.
ext: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. If not sent, data is read from
the first HDU that has data.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
columns: list or array, optional
An optional set of columns to read from table HDUs. Default is to
read all. Can be string or number.
rows: optional
An optional list of rows to read from table HDUS. Default is to
read all.
header: bool, optional
If True, read the FITS header and return a tuple (data,header)
Default is False.
case_sensitive: bool, optional
Match column names and extension names with case-sensitivity. Default
is False.
lower: bool, optional
If True, force all columns names to lower case in output
upper: bool, optional
If True, force all columns names to upper case in output
vstorage: string, optional
Set the default method to store variable length columns. Can be
'fixed' or 'object'. See docs on fitsio.FITS for details. | [
"Convenience",
"function",
"to",
"read",
"data",
"from",
"the",
"specified",
"FITS",
"HDU"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L51-L117 | train | 235,016 |
esheldon/fitsio | fitsio/fitslib.py | read_header | 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: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. Default read primary header.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
case_sensitive: bool, optional
Match extension names with case-sensitivity. Default is False.
"""
dont_create = 0
try:
hdunum = ext+1
except TypeError:
hdunum = None
_fits = _fitsio_wrap.FITS(filename, READONLY, dont_create)
if hdunum is None:
extname = mks(ext)
if extver is None:
extver_num = 0
else:
extver_num = extver
if not case_sensitive:
# the builtin movnam_hdu is not case sensitive
hdunum = _fits.movnam_hdu(ANY_HDU, extname, extver_num)
else:
# for case sensitivity we'll need to run through
# all the hdus
found = False
current_ext = 0
while True:
hdunum = current_ext+1
try:
hdu_type = _fits.movabs_hdu(hdunum) # noqa - not used
name, vers = _fits.get_hdu_name_version(hdunum)
if name == extname:
if extver is None:
# take the first match
found = True
break
else:
if extver_num == vers:
found = True
break
except OSError:
break
current_ext += 1
if not found:
raise IOError(
'hdu not found: %s (extver %s)' % (extname, extver))
return FITSHDR(_fits.read_header(hdunum)) | python | 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: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. Default read primary header.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
case_sensitive: bool, optional
Match extension names with case-sensitivity. Default is False.
"""
dont_create = 0
try:
hdunum = ext+1
except TypeError:
hdunum = None
_fits = _fitsio_wrap.FITS(filename, READONLY, dont_create)
if hdunum is None:
extname = mks(ext)
if extver is None:
extver_num = 0
else:
extver_num = extver
if not case_sensitive:
# the builtin movnam_hdu is not case sensitive
hdunum = _fits.movnam_hdu(ANY_HDU, extname, extver_num)
else:
# for case sensitivity we'll need to run through
# all the hdus
found = False
current_ext = 0
while True:
hdunum = current_ext+1
try:
hdu_type = _fits.movabs_hdu(hdunum) # noqa - not used
name, vers = _fits.get_hdu_name_version(hdunum)
if name == extname:
if extver is None:
# take the first match
found = True
break
else:
if extver_num == vers:
found = True
break
except OSError:
break
current_ext += 1
if not found:
raise IOError(
'hdu not found: %s (extver %s)' % (extname, extver))
return FITSHDR(_fits.read_header(hdunum)) | [
"def",
"read_header",
"(",
"filename",
",",
"ext",
"=",
"0",
",",
"extver",
"=",
"None",
",",
"case_sensitive",
"=",
"False",
",",
"*",
"*",
"keys",
")",
":",
"dont_create",
"=",
"0",
"try",
":",
"hdunum",
"=",
"ext",
"+",
"1",
"except",
"TypeError",
":",
"hdunum",
"=",
"None",
"_fits",
"=",
"_fitsio_wrap",
".",
"FITS",
"(",
"filename",
",",
"READONLY",
",",
"dont_create",
")",
"if",
"hdunum",
"is",
"None",
":",
"extname",
"=",
"mks",
"(",
"ext",
")",
"if",
"extver",
"is",
"None",
":",
"extver_num",
"=",
"0",
"else",
":",
"extver_num",
"=",
"extver",
"if",
"not",
"case_sensitive",
":",
"# the builtin movnam_hdu is not case sensitive",
"hdunum",
"=",
"_fits",
".",
"movnam_hdu",
"(",
"ANY_HDU",
",",
"extname",
",",
"extver_num",
")",
"else",
":",
"# for case sensitivity we'll need to run through",
"# all the hdus",
"found",
"=",
"False",
"current_ext",
"=",
"0",
"while",
"True",
":",
"hdunum",
"=",
"current_ext",
"+",
"1",
"try",
":",
"hdu_type",
"=",
"_fits",
".",
"movabs_hdu",
"(",
"hdunum",
")",
"# noqa - not used",
"name",
",",
"vers",
"=",
"_fits",
".",
"get_hdu_name_version",
"(",
"hdunum",
")",
"if",
"name",
"==",
"extname",
":",
"if",
"extver",
"is",
"None",
":",
"# take the first match",
"found",
"=",
"True",
"break",
"else",
":",
"if",
"extver_num",
"==",
"vers",
":",
"found",
"=",
"True",
"break",
"except",
"OSError",
":",
"break",
"current_ext",
"+=",
"1",
"if",
"not",
"found",
":",
"raise",
"IOError",
"(",
"'hdu not found: %s (extver %s)'",
"%",
"(",
"extname",
",",
"extver",
")",
")",
"return",
"FITSHDR",
"(",
"_fits",
".",
"read_header",
"(",
"hdunum",
")",
")"
] | 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: number or string, optional
The extension. Either the numerical extension from zero
or a string extension name. Default read primary header.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname). These
extensions can optionally specify an EXTVER version number in the
header. Send extver= to select a particular version. If extver is not
sent, the first one will be selected. If ext is an integer, the extver
is ignored.
case_sensitive: bool, optional
Match extension names with case-sensitivity. Default is False. | [
"Convenience",
"function",
"to",
"read",
"the",
"header",
"from",
"the",
"specified",
"FITS",
"HDU"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L120-L190 | train | 235,017 |
esheldon/fitsio | fitsio/fitslib.py | read_scamp_head | 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 object convertable to a FITSHDR object
returns
-------
header: FITSHDR
A fits header object of type FITSHDR
"""
with open(fname) as fobj:
lines = fobj.readlines()
lines = [l.strip() for l in lines if l[0:3] != 'END']
# if header is None an empty FITSHDR is created
hdr = FITSHDR(header)
for l in lines:
hdr.add_record(l)
return hdr | python | 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 object convertable to a FITSHDR object
returns
-------
header: FITSHDR
A fits header object of type FITSHDR
"""
with open(fname) as fobj:
lines = fobj.readlines()
lines = [l.strip() for l in lines if l[0:3] != 'END']
# if header is None an empty FITSHDR is created
hdr = FITSHDR(header)
for l in lines:
hdr.add_record(l)
return hdr | [
"def",
"read_scamp_head",
"(",
"fname",
",",
"header",
"=",
"None",
")",
":",
"with",
"open",
"(",
"fname",
")",
"as",
"fobj",
":",
"lines",
"=",
"fobj",
".",
"readlines",
"(",
")",
"lines",
"=",
"[",
"l",
".",
"strip",
"(",
")",
"for",
"l",
"in",
"lines",
"if",
"l",
"[",
"0",
":",
"3",
"]",
"!=",
"'END'",
"]",
"# if header is None an empty FITSHDR is created",
"hdr",
"=",
"FITSHDR",
"(",
"header",
")",
"for",
"l",
"in",
"lines",
":",
"hdr",
".",
"add_record",
"(",
"l",
")",
"return",
"hdr"
] | 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 object convertable to a FITSHDR object
returns
-------
header: FITSHDR
A fits header object of type FITSHDR | [
"read",
"a",
"SCAMP",
".",
"head",
"file",
"as",
"a",
"fits",
"header",
"FITSHDR",
"object"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L193-L223 | train | 235,018 |
esheldon/fitsio | fitsio/fitslib.py | write | 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 existing HDU, or modify data in an HDU, please construct a FITS
object.
parameters
----------
filename: string
A filename.
data:
Either a normal n-dimensional array or a recarray. Images are written
to a new IMAGE_HDU and recarrays are written to BINARY_TBl or
ASCII_TBL hdus.
extname: string, optional
An optional name for the new header unit.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
clobber: bool, optional
If True, overwrite any existing file. Default is to append
a new extension on existing files.
ignore_empty: bool, optional
Default False. Unless set to True, only allow
empty HDUs in the zero extension.
table keywords
--------------
These keywords are only active when writing tables.
units: list
A list of strings representing units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
"""
with FITS(filename, 'rw', clobber=clobber, **keys) as fits:
fits.write(data,
table_type=table_type,
units=units,
extname=extname,
extver=extver,
compress=compress,
header=header,
**keys) | python | 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 existing HDU, or modify data in an HDU, please construct a FITS
object.
parameters
----------
filename: string
A filename.
data:
Either a normal n-dimensional array or a recarray. Images are written
to a new IMAGE_HDU and recarrays are written to BINARY_TBl or
ASCII_TBL hdus.
extname: string, optional
An optional name for the new header unit.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
clobber: bool, optional
If True, overwrite any existing file. Default is to append
a new extension on existing files.
ignore_empty: bool, optional
Default False. Unless set to True, only allow
empty HDUs in the zero extension.
table keywords
--------------
These keywords are only active when writing tables.
units: list
A list of strings representing units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
"""
with FITS(filename, 'rw', clobber=clobber, **keys) as fits:
fits.write(data,
table_type=table_type,
units=units,
extname=extname,
extver=extver,
compress=compress,
header=header,
**keys) | [
"def",
"write",
"(",
"filename",
",",
"data",
",",
"extname",
"=",
"None",
",",
"extver",
"=",
"None",
",",
"units",
"=",
"None",
",",
"compress",
"=",
"None",
",",
"table_type",
"=",
"'binary'",
",",
"header",
"=",
"None",
",",
"clobber",
"=",
"False",
",",
"*",
"*",
"keys",
")",
":",
"with",
"FITS",
"(",
"filename",
",",
"'rw'",
",",
"clobber",
"=",
"clobber",
",",
"*",
"*",
"keys",
")",
"as",
"fits",
":",
"fits",
".",
"write",
"(",
"data",
",",
"table_type",
"=",
"table_type",
",",
"units",
"=",
"units",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
",",
"compress",
"=",
"compress",
",",
"header",
"=",
"header",
",",
"*",
"*",
"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 existing HDU, or modify data in an HDU, please construct a FITS
object.
parameters
----------
filename: string
A filename.
data:
Either a normal n-dimensional array or a recarray. Images are written
to a new IMAGE_HDU and recarrays are written to BINARY_TBl or
ASCII_TBL hdus.
extname: string, optional
An optional name for the new header unit.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
clobber: bool, optional
If True, overwrite any existing file. Default is to append
a new extension on existing files.
ignore_empty: bool, optional
Default False. Unless set to True, only allow
empty HDUs in the zero extension.
table keywords
--------------
These keywords are only active when writing tables.
units: list
A list of strings representing units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False | [
"Convenience",
"function",
"to",
"create",
"a",
"new",
"HDU",
"and",
"write",
"the",
"data",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L236-L317 | train | 235,019 |
esheldon/fitsio | fitsio/fitslib.py | array2tabledef | 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 must have fields")
names = []
names_nocase = {}
formats = []
dims = []
descr = data.dtype.descr
for d in descr:
# these have the form '<f4' or '|S25', etc. Extract the pure type
npy_dtype = d[1][1:]
if is_ascii:
if npy_dtype in ['u1', 'i1']:
raise ValueError(
"1-byte integers are not supported for "
"ascii tables: '%s'" % npy_dtype)
if npy_dtype in ['u2']:
raise ValueError(
"unsigned 2-byte integers are not supported for "
"ascii tables: '%s'" % npy_dtype)
if npy_dtype[0] == 'O':
# this will be a variable length column 1Pt(len) where t is the
# type and len is max length. Each element must be convertible to
# the same type as the first
name = d[0]
form, dim = npy_obj2fits(data, name)
elif npy_dtype[0] == "V":
continue
else:
name, form, dim = _npy2fits(
d, table_type=table_type, write_bitcols=write_bitcols)
if name == '':
raise ValueError("field name is an empty string")
"""
if is_ascii:
if dim is not None:
raise ValueError("array columns are not supported for "
"ascii tables")
"""
name_nocase = name.upper()
if name_nocase in names_nocase:
raise ValueError(
"duplicate column name found: '%s'. Note "
"FITS column names are not case sensitive" % name_nocase)
names.append(name)
names_nocase[name_nocase] = name_nocase
formats.append(form)
dims.append(dim)
return names, formats, dims | python | 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 must have fields")
names = []
names_nocase = {}
formats = []
dims = []
descr = data.dtype.descr
for d in descr:
# these have the form '<f4' or '|S25', etc. Extract the pure type
npy_dtype = d[1][1:]
if is_ascii:
if npy_dtype in ['u1', 'i1']:
raise ValueError(
"1-byte integers are not supported for "
"ascii tables: '%s'" % npy_dtype)
if npy_dtype in ['u2']:
raise ValueError(
"unsigned 2-byte integers are not supported for "
"ascii tables: '%s'" % npy_dtype)
if npy_dtype[0] == 'O':
# this will be a variable length column 1Pt(len) where t is the
# type and len is max length. Each element must be convertible to
# the same type as the first
name = d[0]
form, dim = npy_obj2fits(data, name)
elif npy_dtype[0] == "V":
continue
else:
name, form, dim = _npy2fits(
d, table_type=table_type, write_bitcols=write_bitcols)
if name == '':
raise ValueError("field name is an empty string")
"""
if is_ascii:
if dim is not None:
raise ValueError("array columns are not supported for "
"ascii tables")
"""
name_nocase = name.upper()
if name_nocase in names_nocase:
raise ValueError(
"duplicate column name found: '%s'. Note "
"FITS column names are not case sensitive" % name_nocase)
names.append(name)
names_nocase[name_nocase] = name_nocase
formats.append(form)
dims.append(dim)
return names, formats, dims | [
"def",
"array2tabledef",
"(",
"data",
",",
"table_type",
"=",
"'binary'",
",",
"write_bitcols",
"=",
"False",
")",
":",
"is_ascii",
"=",
"(",
"table_type",
"==",
"'ascii'",
")",
"if",
"data",
".",
"dtype",
".",
"fields",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"data must have fields\"",
")",
"names",
"=",
"[",
"]",
"names_nocase",
"=",
"{",
"}",
"formats",
"=",
"[",
"]",
"dims",
"=",
"[",
"]",
"descr",
"=",
"data",
".",
"dtype",
".",
"descr",
"for",
"d",
"in",
"descr",
":",
"# these have the form '<f4' or '|S25', etc. Extract the pure type",
"npy_dtype",
"=",
"d",
"[",
"1",
"]",
"[",
"1",
":",
"]",
"if",
"is_ascii",
":",
"if",
"npy_dtype",
"in",
"[",
"'u1'",
",",
"'i1'",
"]",
":",
"raise",
"ValueError",
"(",
"\"1-byte integers are not supported for \"",
"\"ascii tables: '%s'\"",
"%",
"npy_dtype",
")",
"if",
"npy_dtype",
"in",
"[",
"'u2'",
"]",
":",
"raise",
"ValueError",
"(",
"\"unsigned 2-byte integers are not supported for \"",
"\"ascii tables: '%s'\"",
"%",
"npy_dtype",
")",
"if",
"npy_dtype",
"[",
"0",
"]",
"==",
"'O'",
":",
"# this will be a variable length column 1Pt(len) where t is the",
"# type and len is max length. Each element must be convertible to",
"# the same type as the first",
"name",
"=",
"d",
"[",
"0",
"]",
"form",
",",
"dim",
"=",
"npy_obj2fits",
"(",
"data",
",",
"name",
")",
"elif",
"npy_dtype",
"[",
"0",
"]",
"==",
"\"V\"",
":",
"continue",
"else",
":",
"name",
",",
"form",
",",
"dim",
"=",
"_npy2fits",
"(",
"d",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")",
"if",
"name",
"==",
"''",
":",
"raise",
"ValueError",
"(",
"\"field name is an empty string\"",
")",
"\"\"\"\n if is_ascii:\n if dim is not None:\n raise ValueError(\"array columns are not supported for \"\n \"ascii tables\")\n \"\"\"",
"name_nocase",
"=",
"name",
".",
"upper",
"(",
")",
"if",
"name_nocase",
"in",
"names_nocase",
":",
"raise",
"ValueError",
"(",
"\"duplicate column name found: '%s'. Note \"",
"\"FITS column names are not case sensitive\"",
"%",
"name_nocase",
")",
"names",
".",
"append",
"(",
"name",
")",
"names_nocase",
"[",
"name_nocase",
"]",
"=",
"name_nocase",
"formats",
".",
"append",
"(",
"form",
")",
"dims",
".",
"append",
"(",
"dim",
")",
"return",
"names",
",",
"formats",
",",
"dims"
] | Similar to descr2tabledef but if there are object columns a type
and max length will be extracted and used for the tabledef | [
"Similar",
"to",
"descr2tabledef",
"but",
"if",
"there",
"are",
"object",
"columns",
"a",
"type",
"and",
"max",
"length",
"will",
"be",
"extracted",
"and",
"used",
"for",
"the",
"tabledef"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1237-L1298 | train | 235,020 |
esheldon/fitsio | fitsio/fitslib.py | descr2tabledef | 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
These are the ttyp, tform and tdim header entries
for each field. dim entries may be None
"""
names = []
formats = []
dims = []
for d in descr:
"""
npy_dtype = d[1][1:]
if is_ascii and npy_dtype in ['u1','i1']:
raise ValueError("1-byte integers are not supported for "
"ascii tables")
"""
if d[1][1] == 'O':
raise ValueError(
'cannot automatically declare a var column without '
'some data to determine max len')
name, form, dim = _npy2fits(
d, table_type=table_type, write_bitcols=write_bitcols)
if name == '':
raise ValueError("field name is an empty string")
"""
if is_ascii:
if dim is not None:
raise ValueError("array columns are not supported "
"for ascii tables")
"""
names.append(name)
formats.append(form)
dims.append(dim)
return names, formats, dims | python | 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
These are the ttyp, tform and tdim header entries
for each field. dim entries may be None
"""
names = []
formats = []
dims = []
for d in descr:
"""
npy_dtype = d[1][1:]
if is_ascii and npy_dtype in ['u1','i1']:
raise ValueError("1-byte integers are not supported for "
"ascii tables")
"""
if d[1][1] == 'O':
raise ValueError(
'cannot automatically declare a var column without '
'some data to determine max len')
name, form, dim = _npy2fits(
d, table_type=table_type, write_bitcols=write_bitcols)
if name == '':
raise ValueError("field name is an empty string")
"""
if is_ascii:
if dim is not None:
raise ValueError("array columns are not supported "
"for ascii tables")
"""
names.append(name)
formats.append(form)
dims.append(dim)
return names, formats, dims | [
"def",
"descr2tabledef",
"(",
"descr",
",",
"table_type",
"=",
"'binary'",
",",
"write_bitcols",
"=",
"False",
")",
":",
"names",
"=",
"[",
"]",
"formats",
"=",
"[",
"]",
"dims",
"=",
"[",
"]",
"for",
"d",
"in",
"descr",
":",
"\"\"\"\n npy_dtype = d[1][1:]\n if is_ascii and npy_dtype in ['u1','i1']:\n raise ValueError(\"1-byte integers are not supported for \"\n \"ascii tables\")\n \"\"\"",
"if",
"d",
"[",
"1",
"]",
"[",
"1",
"]",
"==",
"'O'",
":",
"raise",
"ValueError",
"(",
"'cannot automatically declare a var column without '",
"'some data to determine max len'",
")",
"name",
",",
"form",
",",
"dim",
"=",
"_npy2fits",
"(",
"d",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")",
"if",
"name",
"==",
"''",
":",
"raise",
"ValueError",
"(",
"\"field name is an empty string\"",
")",
"\"\"\"\n if is_ascii:\n if dim is not None:\n raise ValueError(\"array columns are not supported \"\n \"for ascii tables\")\n \"\"\"",
"names",
".",
"append",
"(",
"name",
")",
"formats",
".",
"append",
"(",
"form",
")",
"dims",
".",
"append",
"(",
"dim",
")",
"return",
"names",
",",
"formats",
",",
"dims"
] | 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
These are the ttyp, tform and tdim header entries
for each field. dim entries may be None | [
"Create",
"a",
"FITS",
"table",
"def",
"from",
"the",
"input",
"numpy",
"descriptor",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1356-L1406 | train | 235,021 |
esheldon/fitsio | fitsio/fitslib.py | get_tile_dims | 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_dims to have %d dims, got %d" % (td.size, nd)
raise ValueError(msg)
return td | python | 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_dims to have %d dims, got %d" % (td.size, nd)
raise ValueError(msg)
return td | [
"def",
"get_tile_dims",
"(",
"tile_dims",
",",
"imshape",
")",
":",
"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_dims to have %d dims, got %d\"",
"%",
"(",
"td",
".",
"size",
",",
"nd",
")",
"raise",
"ValueError",
"(",
"msg",
")",
"return",
"td"
] | Just make sure the tile dims has the appropriate number of dimensions | [
"Just",
"make",
"sure",
"the",
"tile",
"dims",
"has",
"the",
"appropriate",
"number",
"of",
"dimensions"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1452-L1466 | train | 235,022 |
esheldon/fitsio | fitsio/fitslib.py | _extract_table_type | 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(
"table type string should begin with 'binary' or 'ascii' "
"(case insensitive)")
else:
type = int(type)
if type not in [BINARY_TBL, ASCII_TBL]:
raise ValueError(
"table type num should be BINARY_TBL (%d) or "
"ASCII_TBL (%d)" % (BINARY_TBL, ASCII_TBL))
table_type = type
return table_type | python | 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(
"table type string should begin with 'binary' or 'ascii' "
"(case insensitive)")
else:
type = int(type)
if type not in [BINARY_TBL, ASCII_TBL]:
raise ValueError(
"table type num should be BINARY_TBL (%d) or "
"ASCII_TBL (%d)" % (BINARY_TBL, ASCII_TBL))
table_type = type
return table_type | [
"def",
"_extract_table_type",
"(",
"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",
"(",
"\"table type string should begin with 'binary' or 'ascii' \"",
"\"(case insensitive)\"",
")",
"else",
":",
"type",
"=",
"int",
"(",
"type",
")",
"if",
"type",
"not",
"in",
"[",
"BINARY_TBL",
",",
"ASCII_TBL",
"]",
":",
"raise",
"ValueError",
"(",
"\"table type num should be BINARY_TBL (%d) or \"",
"\"ASCII_TBL (%d)\"",
"%",
"(",
"BINARY_TBL",
",",
"ASCII_TBL",
")",
")",
"table_type",
"=",
"type",
"return",
"table_type"
] | Get the numerical table type | [
"Get",
"the",
"numerical",
"table",
"type"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1496-L1518 | train | 235,023 |
esheldon/fitsio | fitsio/fitslib.py | FITS.close | 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.charmode = None
self.intmode = None
self.hdu_list = None
self.hdu_map = None | python | 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.charmode = None
self.intmode = None
self.hdu_list = None
self.hdu_map = None | [
"def",
"close",
"(",
"self",
")",
":",
"if",
"hasattr",
"(",
"self",
",",
"'_FITS'",
")",
":",
"if",
"self",
".",
"_FITS",
"is",
"not",
"None",
":",
"self",
".",
"_FITS",
".",
"close",
"(",
")",
"self",
".",
"_FITS",
"=",
"None",
"self",
".",
"_filename",
"=",
"None",
"self",
".",
"mode",
"=",
"None",
"self",
".",
"charmode",
"=",
"None",
"self",
".",
"intmode",
"=",
"None",
"self",
".",
"hdu_list",
"=",
"None",
"self",
".",
"hdu_map",
"=",
"None"
] | Close the fits file and set relevant metadata to None | [
"Close",
"the",
"fits",
"file",
"and",
"set",
"relevant",
"metadata",
"to",
"None"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L409-L422 | train | 235,024 |
esheldon/fitsio | fitsio/fitslib.py | FITS.movnam_hdu | 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, extname, extver)
return hdu | python | 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, extname, extver)
return hdu | [
"def",
"movnam_hdu",
"(",
"self",
",",
"extname",
",",
"hdutype",
"=",
"ANY_HDU",
",",
"extver",
"=",
"0",
")",
":",
"extname",
"=",
"mks",
"(",
"extname",
")",
"hdu",
"=",
"self",
".",
"_FITS",
".",
"movnam_hdu",
"(",
"hdutype",
",",
"extname",
",",
"extver",
")",
"return",
"hdu"
] | Move to the indicated HDU by name
In general, it is not necessary to use this method explicitly.
returns the one-offset extension number | [
"Move",
"to",
"the",
"indicated",
"HDU",
"by",
"name"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L452-L462 | train | 235,025 |
esheldon/fitsio | fitsio/fitslib.py | FITS.reopen | 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() | python | 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",
"reopen",
"(",
"self",
")",
":",
"self",
".",
"_FITS",
".",
"close",
"(",
")",
"del",
"self",
".",
"_FITS",
"self",
".",
"_FITS",
"=",
"_fitsio_wrap",
".",
"FITS",
"(",
"self",
".",
"_filename",
",",
"self",
".",
"intmode",
",",
"0",
")",
"self",
".",
"update_hdu_list",
"(",
")"
] | close and reopen the fits file with the same mode | [
"close",
"and",
"reopen",
"the",
"fits",
"file",
"with",
"the",
"same",
"mode"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L464-L471 | train | 235,026 |
esheldon/fitsio | fitsio/fitslib.py | FITS.write | 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 an IMAGE_HDU, write_image is
called, otherwise write_table is called.
parameters
----------
data: ndarray
An n-dimensional image or an array with fields.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
Image-only keywords:
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
Table-only keywords:
units: list/dec, optional:
A list of strings with units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE
"""
isimage = False
if data is None:
isimage = True
elif isinstance(data, numpy.ndarray):
if data.dtype.fields == None: # noqa - probably should be is None
isimage = True
if isimage:
self.write_image(data, extname=extname, extver=extver,
compress=compress, tile_dims=tile_dims,
header=header)
else:
self.write_table(data, units=units,
extname=extname, extver=extver, header=header,
names=names,
table_type=table_type,
write_bitcols=write_bitcols) | python | 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 an IMAGE_HDU, write_image is
called, otherwise write_table is called.
parameters
----------
data: ndarray
An n-dimensional image or an array with fields.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
Image-only keywords:
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
Table-only keywords:
units: list/dec, optional:
A list of strings with units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE
"""
isimage = False
if data is None:
isimage = True
elif isinstance(data, numpy.ndarray):
if data.dtype.fields == None: # noqa - probably should be is None
isimage = True
if isimage:
self.write_image(data, extname=extname, extver=extver,
compress=compress, tile_dims=tile_dims,
header=header)
else:
self.write_table(data, units=units,
extname=extname, extver=extver, header=header,
names=names,
table_type=table_type,
write_bitcols=write_bitcols) | [
"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",
")",
":",
"isimage",
"=",
"False",
"if",
"data",
"is",
"None",
":",
"isimage",
"=",
"True",
"elif",
"isinstance",
"(",
"data",
",",
"numpy",
".",
"ndarray",
")",
":",
"if",
"data",
".",
"dtype",
".",
"fields",
"==",
"None",
":",
"# noqa - probably should be is None",
"isimage",
"=",
"True",
"if",
"isimage",
":",
"self",
".",
"write_image",
"(",
"data",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
",",
"compress",
"=",
"compress",
",",
"tile_dims",
"=",
"tile_dims",
",",
"header",
"=",
"header",
")",
"else",
":",
"self",
".",
"write_table",
"(",
"data",
",",
"units",
"=",
"units",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
",",
"header",
"=",
"header",
",",
"names",
"=",
"names",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")"
] | Write the data to a new HDU.
This method is a wrapper. If this is an IMAGE_HDU, write_image is
called, otherwise write_table is called.
parameters
----------
data: ndarray
An n-dimensional image or an array with fields.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
Image-only keywords:
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
Table-only keywords:
units: list/dec, optional:
A list of strings with units for each column.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE | [
"Write",
"the",
"data",
"to",
"a",
"new",
"HDU",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L473-L549 | train | 235,027 |
esheldon/fitsio | fitsio/fitslib.py | FITS.write_image | 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
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
restrictions
------------
The File must be opened READWRITE
"""
self.create_image_hdu(img,
header=header,
extname=extname, extver=extver,
compress=compress, tile_dims=tile_dims)
if header is not None:
self[-1].write_keys(header)
self[-1]._update_info() | python | 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
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
restrictions
------------
The File must be opened READWRITE
"""
self.create_image_hdu(img,
header=header,
extname=extname, extver=extver,
compress=compress, tile_dims=tile_dims)
if header is not None:
self[-1].write_keys(header)
self[-1]._update_info() | [
"def",
"write_image",
"(",
"self",
",",
"img",
",",
"extname",
"=",
"None",
",",
"extver",
"=",
"None",
",",
"compress",
"=",
"None",
",",
"tile_dims",
"=",
"None",
",",
"header",
"=",
"None",
")",
":",
"self",
".",
"create_image_hdu",
"(",
"img",
",",
"header",
"=",
"header",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
",",
"compress",
"=",
"compress",
",",
"tile_dims",
"=",
"tile_dims",
")",
"if",
"header",
"is",
"not",
"None",
":",
"self",
"[",
"-",
"1",
"]",
".",
"write_keys",
"(",
"header",
")",
"self",
"[",
"-",
"1",
"]",
".",
"_update_info",
"(",
")"
] | Create a new image extension and write the data.
parameters
----------
img: ndarray
An n-dimensional image.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
A set of header keys to write. Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
restrictions
------------
The File must be opened READWRITE | [
"Create",
"a",
"new",
"image",
"extension",
"and",
"write",
"the",
"data",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L551-L601 | train | 235,028 |
esheldon/fitsio | fitsio/fitslib.py | FITS.create_image_hdu | def create_image_hdu(self,
img=None,
dims=None,
dtype=None,
extname=None,
extver=None,
compress=None,
tile_dims=None,
header=None):
"""
Create a new, empty image HDU and reload the hdu list. Either
create from an input image or from input dims and dtype
fits.create_image_hdu(image, ...)
fits.create_image_hdu(dims=dims, dtype=dtype)
If an image is sent, the data are also written.
You can write data into the new extension using
fits[extension].write(image)
Alternatively you can skip calling this function and instead just use
fits.write(image)
or
fits.write_image(image)
which will create the new image extension for you with the appropriate
structure, and write the data.
parameters
----------
img: ndarray, optional
An image with which to determine the properties of the HDU. The
data will be written.
dims: sequence, optional
A sequence describing the dimensions of the image to be created
on disk. You must also send a dtype=
dtype: numpy data type
When sending dims= also send the data type. Can be of the
various numpy data type declaration styles, e.g. 'f8',
numpy.float64.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE
"""
if (img is not None) or (img is None and dims is None):
from_image = True
elif dims is not None:
from_image = False
if from_image:
img2send = img
if img is not None:
dims = img.shape
dtstr = img.dtype.descr[0][1][1:]
if img.size == 0:
raise ValueError("data must have at least 1 row")
# data must be c-contiguous and native byte order
if not img.flags['C_CONTIGUOUS']:
# this always makes a copy
img2send = numpy.ascontiguousarray(img)
array_to_native(img2send, inplace=True)
else:
img2send = array_to_native(img, inplace=False)
if IS_PY3 and img2send.dtype.char == 'U':
# for python3, we convert unicode to ascii
# this will error if the character is not in ascii
img2send = img2send.astype('S', copy=False)
else:
self._ensure_empty_image_ok()
compress = None
tile_dims = None
# we get dims from the input image
dims2send = None
else:
# img was None and dims was sent
if dtype is None:
raise ValueError("send dtype= with dims=")
# this must work!
dtype = numpy.dtype(dtype)
dtstr = dtype.descr[0][1][1:]
# use the example image to build the type in C
img2send = numpy.zeros(1, dtype=dtype)
# sending an array simplifies access
dims2send = numpy.array(dims, dtype='i8', ndmin=1)
if img2send is not None:
if img2send.dtype.fields is not None:
raise ValueError(
"got record data type, expected regular ndarray")
if extname is None:
# will be ignored
extname = ""
else:
if not isstring(extname):
raise ValueError("extension name must be a string")
extname = mks(extname)
if extname is not None and extver is not None:
extver = check_extver(extver)
if extver is None:
# will be ignored
extver = 0
comptype = get_compress_type(compress)
tile_dims = get_tile_dims(tile_dims, dims)
if img2send is not None:
check_comptype_img(comptype, dtstr)
if header is not None:
nkeys = len(header)
else:
nkeys = 0
self._FITS.create_image_hdu(img2send,
nkeys,
dims=dims2send,
comptype=comptype,
tile_dims=tile_dims,
extname=extname,
extver=extver)
# don't rebuild the whole list unless this is the first hdu
# to be created
self.update_hdu_list(rebuild=False) | python | def create_image_hdu(self,
img=None,
dims=None,
dtype=None,
extname=None,
extver=None,
compress=None,
tile_dims=None,
header=None):
"""
Create a new, empty image HDU and reload the hdu list. Either
create from an input image or from input dims and dtype
fits.create_image_hdu(image, ...)
fits.create_image_hdu(dims=dims, dtype=dtype)
If an image is sent, the data are also written.
You can write data into the new extension using
fits[extension].write(image)
Alternatively you can skip calling this function and instead just use
fits.write(image)
or
fits.write_image(image)
which will create the new image extension for you with the appropriate
structure, and write the data.
parameters
----------
img: ndarray, optional
An image with which to determine the properties of the HDU. The
data will be written.
dims: sequence, optional
A sequence describing the dimensions of the image to be created
on disk. You must also send a dtype=
dtype: numpy data type
When sending dims= also send the data type. Can be of the
various numpy data type declaration styles, e.g. 'f8',
numpy.float64.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE
"""
if (img is not None) or (img is None and dims is None):
from_image = True
elif dims is not None:
from_image = False
if from_image:
img2send = img
if img is not None:
dims = img.shape
dtstr = img.dtype.descr[0][1][1:]
if img.size == 0:
raise ValueError("data must have at least 1 row")
# data must be c-contiguous and native byte order
if not img.flags['C_CONTIGUOUS']:
# this always makes a copy
img2send = numpy.ascontiguousarray(img)
array_to_native(img2send, inplace=True)
else:
img2send = array_to_native(img, inplace=False)
if IS_PY3 and img2send.dtype.char == 'U':
# for python3, we convert unicode to ascii
# this will error if the character is not in ascii
img2send = img2send.astype('S', copy=False)
else:
self._ensure_empty_image_ok()
compress = None
tile_dims = None
# we get dims from the input image
dims2send = None
else:
# img was None and dims was sent
if dtype is None:
raise ValueError("send dtype= with dims=")
# this must work!
dtype = numpy.dtype(dtype)
dtstr = dtype.descr[0][1][1:]
# use the example image to build the type in C
img2send = numpy.zeros(1, dtype=dtype)
# sending an array simplifies access
dims2send = numpy.array(dims, dtype='i8', ndmin=1)
if img2send is not None:
if img2send.dtype.fields is not None:
raise ValueError(
"got record data type, expected regular ndarray")
if extname is None:
# will be ignored
extname = ""
else:
if not isstring(extname):
raise ValueError("extension name must be a string")
extname = mks(extname)
if extname is not None and extver is not None:
extver = check_extver(extver)
if extver is None:
# will be ignored
extver = 0
comptype = get_compress_type(compress)
tile_dims = get_tile_dims(tile_dims, dims)
if img2send is not None:
check_comptype_img(comptype, dtstr)
if header is not None:
nkeys = len(header)
else:
nkeys = 0
self._FITS.create_image_hdu(img2send,
nkeys,
dims=dims2send,
comptype=comptype,
tile_dims=tile_dims,
extname=extname,
extver=extver)
# don't rebuild the whole list unless this is the first hdu
# to be created
self.update_hdu_list(rebuild=False) | [
"def",
"create_image_hdu",
"(",
"self",
",",
"img",
"=",
"None",
",",
"dims",
"=",
"None",
",",
"dtype",
"=",
"None",
",",
"extname",
"=",
"None",
",",
"extver",
"=",
"None",
",",
"compress",
"=",
"None",
",",
"tile_dims",
"=",
"None",
",",
"header",
"=",
"None",
")",
":",
"if",
"(",
"img",
"is",
"not",
"None",
")",
"or",
"(",
"img",
"is",
"None",
"and",
"dims",
"is",
"None",
")",
":",
"from_image",
"=",
"True",
"elif",
"dims",
"is",
"not",
"None",
":",
"from_image",
"=",
"False",
"if",
"from_image",
":",
"img2send",
"=",
"img",
"if",
"img",
"is",
"not",
"None",
":",
"dims",
"=",
"img",
".",
"shape",
"dtstr",
"=",
"img",
".",
"dtype",
".",
"descr",
"[",
"0",
"]",
"[",
"1",
"]",
"[",
"1",
":",
"]",
"if",
"img",
".",
"size",
"==",
"0",
":",
"raise",
"ValueError",
"(",
"\"data must have at least 1 row\"",
")",
"# data must be c-contiguous and native byte order",
"if",
"not",
"img",
".",
"flags",
"[",
"'C_CONTIGUOUS'",
"]",
":",
"# this always makes a copy",
"img2send",
"=",
"numpy",
".",
"ascontiguousarray",
"(",
"img",
")",
"array_to_native",
"(",
"img2send",
",",
"inplace",
"=",
"True",
")",
"else",
":",
"img2send",
"=",
"array_to_native",
"(",
"img",
",",
"inplace",
"=",
"False",
")",
"if",
"IS_PY3",
"and",
"img2send",
".",
"dtype",
".",
"char",
"==",
"'U'",
":",
"# for python3, we convert unicode to ascii",
"# this will error if the character is not in ascii",
"img2send",
"=",
"img2send",
".",
"astype",
"(",
"'S'",
",",
"copy",
"=",
"False",
")",
"else",
":",
"self",
".",
"_ensure_empty_image_ok",
"(",
")",
"compress",
"=",
"None",
"tile_dims",
"=",
"None",
"# we get dims from the input image",
"dims2send",
"=",
"None",
"else",
":",
"# img was None and dims was sent",
"if",
"dtype",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"send dtype= with dims=\"",
")",
"# this must work!",
"dtype",
"=",
"numpy",
".",
"dtype",
"(",
"dtype",
")",
"dtstr",
"=",
"dtype",
".",
"descr",
"[",
"0",
"]",
"[",
"1",
"]",
"[",
"1",
":",
"]",
"# use the example image to build the type in C",
"img2send",
"=",
"numpy",
".",
"zeros",
"(",
"1",
",",
"dtype",
"=",
"dtype",
")",
"# sending an array simplifies access",
"dims2send",
"=",
"numpy",
".",
"array",
"(",
"dims",
",",
"dtype",
"=",
"'i8'",
",",
"ndmin",
"=",
"1",
")",
"if",
"img2send",
"is",
"not",
"None",
":",
"if",
"img2send",
".",
"dtype",
".",
"fields",
"is",
"not",
"None",
":",
"raise",
"ValueError",
"(",
"\"got record data type, expected regular ndarray\"",
")",
"if",
"extname",
"is",
"None",
":",
"# will be ignored",
"extname",
"=",
"\"\"",
"else",
":",
"if",
"not",
"isstring",
"(",
"extname",
")",
":",
"raise",
"ValueError",
"(",
"\"extension name must be a string\"",
")",
"extname",
"=",
"mks",
"(",
"extname",
")",
"if",
"extname",
"is",
"not",
"None",
"and",
"extver",
"is",
"not",
"None",
":",
"extver",
"=",
"check_extver",
"(",
"extver",
")",
"if",
"extver",
"is",
"None",
":",
"# will be ignored",
"extver",
"=",
"0",
"comptype",
"=",
"get_compress_type",
"(",
"compress",
")",
"tile_dims",
"=",
"get_tile_dims",
"(",
"tile_dims",
",",
"dims",
")",
"if",
"img2send",
"is",
"not",
"None",
":",
"check_comptype_img",
"(",
"comptype",
",",
"dtstr",
")",
"if",
"header",
"is",
"not",
"None",
":",
"nkeys",
"=",
"len",
"(",
"header",
")",
"else",
":",
"nkeys",
"=",
"0",
"self",
".",
"_FITS",
".",
"create_image_hdu",
"(",
"img2send",
",",
"nkeys",
",",
"dims",
"=",
"dims2send",
",",
"comptype",
"=",
"comptype",
",",
"tile_dims",
"=",
"tile_dims",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
")",
"# don't rebuild the whole list unless this is the first hdu",
"# to be created",
"self",
".",
"update_hdu_list",
"(",
"rebuild",
"=",
"False",
")"
] | Create a new, empty image HDU and reload the hdu list. Either
create from an input image or from input dims and dtype
fits.create_image_hdu(image, ...)
fits.create_image_hdu(dims=dims, dtype=dtype)
If an image is sent, the data are also written.
You can write data into the new extension using
fits[extension].write(image)
Alternatively you can skip calling this function and instead just use
fits.write(image)
or
fits.write_image(image)
which will create the new image extension for you with the appropriate
structure, and write the data.
parameters
----------
img: ndarray, optional
An image with which to determine the properties of the HDU. The
data will be written.
dims: sequence, optional
A sequence describing the dimensions of the image to be created
on disk. You must also send a dtype=
dtype: numpy data type
When sending dims= also send the data type. Can be of the
various numpy data type declaration styles, e.g. 'f8',
numpy.float64.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
compress: string, optional
A string representing the compression algorithm for images,
default None.
Can be one of
'RICE'
'GZIP'
'GZIP_2'
'PLIO' (no unsigned or negative integers)
'HCOMPRESS'
(case-insensitive) See the cfitsio manual for details.
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE | [
"Create",
"a",
"new",
"empty",
"image",
"HDU",
"and",
"reload",
"the",
"hdu",
"list",
".",
"Either",
"create",
"from",
"an",
"input",
"image",
"or",
"from",
"input",
"dims",
"and",
"dtype"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L606-L765 | train | 235,029 |
esheldon/fitsio | fitsio/fitslib.py | FITS._ensure_empty_image_ok | 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 write None image at extension %d" % len(self))
if 'ndims' in self[0]._info:
raise RuntimeError("Can only write None images to extension zero, "
"which already exists") | python | 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 write None image at extension %d" % len(self))
if 'ndims' in self[0]._info:
raise RuntimeError("Can only write None images to extension zero, "
"which already exists") | [
"def",
"_ensure_empty_image_ok",
"(",
"self",
")",
":",
"if",
"self",
".",
"ignore_empty",
":",
"return",
"if",
"len",
"(",
"self",
")",
">",
"1",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot write None image at extension %d\"",
"%",
"len",
"(",
"self",
")",
")",
"if",
"'ndims'",
"in",
"self",
"[",
"0",
"]",
".",
"_info",
":",
"raise",
"RuntimeError",
"(",
"\"Can only write None images to extension zero, \"",
"\"which already exists\"",
")"
] | 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",
"ignore_empty",
"was",
"not",
"set",
"to",
"True",
"we",
"only",
"allow",
"empty",
"HDU",
"for",
"first",
"HDU",
"and",
"if",
"there",
"is",
"no",
"data",
"there",
"already"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L767-L780 | train | 235,030 |
esheldon/fitsio | fitsio/fitslib.py | FITS.write_table | 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 from the fields in the input array. If
you want to append new rows to the table, access the HDU directly and
use the write() function, e.g.
fits[extension].append(data)
parameters
----------
data: recarray
A numpy array with fields. The table definition will be
determined from this array.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
extname: string, optional
An optional string for the extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
units: list/dec, optional:
A list of strings with units for each column.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
write_bitcols: boolean, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE
"""
"""
if data.dtype.fields == None:
raise ValueError("data must have fields")
if data.size == 0:
raise ValueError("data must have at least 1 row")
"""
self.create_table_hdu(data=data,
header=header,
names=names,
units=units,
extname=extname,
extver=extver,
table_type=table_type,
write_bitcols=write_bitcols)
if header is not None:
self[-1].write_keys(header)
self[-1]._update_info()
self[-1].write(data, names=names) | python | 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 from the fields in the input array. If
you want to append new rows to the table, access the HDU directly and
use the write() function, e.g.
fits[extension].append(data)
parameters
----------
data: recarray
A numpy array with fields. The table definition will be
determined from this array.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
extname: string, optional
An optional string for the extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
units: list/dec, optional:
A list of strings with units for each column.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
write_bitcols: boolean, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE
"""
"""
if data.dtype.fields == None:
raise ValueError("data must have fields")
if data.size == 0:
raise ValueError("data must have at least 1 row")
"""
self.create_table_hdu(data=data,
header=header,
names=names,
units=units,
extname=extname,
extver=extver,
table_type=table_type,
write_bitcols=write_bitcols)
if header is not None:
self[-1].write_keys(header)
self[-1]._update_info()
self[-1].write(data, names=names) | [
"def",
"write_table",
"(",
"self",
",",
"data",
",",
"table_type",
"=",
"'binary'",
",",
"names",
"=",
"None",
",",
"formats",
"=",
"None",
",",
"units",
"=",
"None",
",",
"extname",
"=",
"None",
",",
"extver",
"=",
"None",
",",
"header",
"=",
"None",
",",
"write_bitcols",
"=",
"False",
")",
":",
"\"\"\"\n if data.dtype.fields == None:\n raise ValueError(\"data must have fields\")\n if data.size == 0:\n raise ValueError(\"data must have at least 1 row\")\n \"\"\"",
"self",
".",
"create_table_hdu",
"(",
"data",
"=",
"data",
",",
"header",
"=",
"header",
",",
"names",
"=",
"names",
",",
"units",
"=",
"units",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")",
"if",
"header",
"is",
"not",
"None",
":",
"self",
"[",
"-",
"1",
"]",
".",
"write_keys",
"(",
"header",
")",
"self",
"[",
"-",
"1",
"]",
".",
"_update_info",
"(",
")",
"self",
"[",
"-",
"1",
"]",
".",
"write",
"(",
"data",
",",
"names",
"=",
"names",
")"
] | Create a new table extension and write the data.
The table definition is taken from the fields in the input array. If
you want to append new rows to the table, access the HDU directly and
use the write() function, e.g.
fits[extension].append(data)
parameters
----------
data: recarray
A numpy array with fields. The table definition will be
determined from this array.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
extname: string, optional
An optional string for the extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
units: list/dec, optional:
A list of strings with units for each column.
header: FITSHDR, list, dict, optional
A set of header keys to write. The keys are written before the data
is written to the table, preventing a resizing of the table area.
Can be one of these:
- FITSHDR object
- list of dictionaries containing 'name','value' and optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
Note required keywords such as NAXIS, XTENSION, etc are cleaed out.
write_bitcols: boolean, optional
Write boolean arrays in the FITS bitcols format, default False
restrictions
------------
The File must be opened READWRITE | [
"Create",
"a",
"new",
"table",
"extension",
"and",
"write",
"the",
"data",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L782-L853 | train | 235,031 |
esheldon/fitsio | fitsio/fitslib.py | FITS.create_table_hdu | 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, empty table extension and reload the hdu list.
There are three ways to do it:
1) send a numpy dtype, from which the formats in the fits file will
be determined.
2) Send an array in data= keyword. this is required if you have
object fields for writing to variable length columns.
3) send the names,formats and dims yourself
You can then write data into the new extension using
fits[extension].write(array)
If you want to write to a single column
fits[extension].write_column(array)
But be careful as the other columns will be left zeroed.
Often you will instead just use write_table to do this all
atomically.
fits.write_table(recarray)
write_table will create the new table extension for you with the
appropriate fields.
parameters
----------
dtype: numpy dtype or descriptor, optional
If you have an array with fields, you can just send arr.dtype. You
can also use a list of tuples, e.g. [('x','f8'),('index','i4')] or
a dictionary representation.
data: a numpy array with fields, optional
or a dictionary
An array or dict from which to determine the table definition. You
must use this instead of sending a descriptor if you have object
array fields, as this is the only way to determine the type and max
size.
names: list of strings, optional
The list of field names
formats: list of strings, optional
The TFORM format strings for each field.
dims: list of strings, optional
An optional list of dimension strings for each field. Should
match the repeat count for the formats fields. Be careful of
the order since FITS is more like fortran. See the descr2tabledef
function.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
units: list of strings, optional
An optional list of unit strings for each field.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE
"""
# record this for the TableHDU object
self.keys['write_bitcols'] = write_bitcols
# can leave as turn
table_type_int = _extract_table_type(table_type)
if data is not None:
if isinstance(data, numpy.ndarray):
names, formats, dims = array2tabledef(
data, table_type=table_type, write_bitcols=write_bitcols)
elif isinstance(data, (list, dict)):
names, formats, dims = collection2tabledef(
data, names=names, table_type=table_type,
write_bitcols=write_bitcols)
else:
raise ValueError(
"data must be an ndarray with fields or a dict")
elif dtype is not None:
dtype = numpy.dtype(dtype)
names, formats, dims = descr2tabledef(
dtype.
descr,
write_bitcols=write_bitcols,
table_type=table_type,
)
else:
if names is None or formats is None:
raise ValueError(
"send either dtype=, data=, or names= and formats=")
if not isinstance(names, list) or not isinstance(formats, list):
raise ValueError("names and formats should be lists")
if len(names) != len(formats):
raise ValueError("names and formats must be same length")
if dims is not None:
if not isinstance(dims, list):
raise ValueError("dims should be a list")
if len(dims) != len(names):
raise ValueError("names and dims must be same length")
if units is not None:
if not isinstance(units, list):
raise ValueError("units should be a list")
if len(units) != len(names):
raise ValueError("names and units must be same length")
if extname is None:
# will be ignored
extname = ""
else:
if not isstring(extname):
raise ValueError("extension name must be a string")
extname = mks(extname)
if extname is not None and extver is not None:
extver = check_extver(extver)
if extver is None:
# will be ignored
extver = 0
if extname is None:
# will be ignored
extname = ""
if header is not None:
nkeys = len(header)
else:
nkeys = 0
# note we can create extname in the c code for tables, but not images
self._FITS.create_table_hdu(table_type_int, nkeys,
names, formats, tunit=units, tdim=dims,
extname=extname, extver=extver)
# don't rebuild the whole list unless this is the first hdu
# to be created
self.update_hdu_list(rebuild=False) | python | 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, empty table extension and reload the hdu list.
There are three ways to do it:
1) send a numpy dtype, from which the formats in the fits file will
be determined.
2) Send an array in data= keyword. this is required if you have
object fields for writing to variable length columns.
3) send the names,formats and dims yourself
You can then write data into the new extension using
fits[extension].write(array)
If you want to write to a single column
fits[extension].write_column(array)
But be careful as the other columns will be left zeroed.
Often you will instead just use write_table to do this all
atomically.
fits.write_table(recarray)
write_table will create the new table extension for you with the
appropriate fields.
parameters
----------
dtype: numpy dtype or descriptor, optional
If you have an array with fields, you can just send arr.dtype. You
can also use a list of tuples, e.g. [('x','f8'),('index','i4')] or
a dictionary representation.
data: a numpy array with fields, optional
or a dictionary
An array or dict from which to determine the table definition. You
must use this instead of sending a descriptor if you have object
array fields, as this is the only way to determine the type and max
size.
names: list of strings, optional
The list of field names
formats: list of strings, optional
The TFORM format strings for each field.
dims: list of strings, optional
An optional list of dimension strings for each field. Should
match the repeat count for the formats fields. Be careful of
the order since FITS is more like fortran. See the descr2tabledef
function.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
units: list of strings, optional
An optional list of unit strings for each field.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE
"""
# record this for the TableHDU object
self.keys['write_bitcols'] = write_bitcols
# can leave as turn
table_type_int = _extract_table_type(table_type)
if data is not None:
if isinstance(data, numpy.ndarray):
names, formats, dims = array2tabledef(
data, table_type=table_type, write_bitcols=write_bitcols)
elif isinstance(data, (list, dict)):
names, formats, dims = collection2tabledef(
data, names=names, table_type=table_type,
write_bitcols=write_bitcols)
else:
raise ValueError(
"data must be an ndarray with fields or a dict")
elif dtype is not None:
dtype = numpy.dtype(dtype)
names, formats, dims = descr2tabledef(
dtype.
descr,
write_bitcols=write_bitcols,
table_type=table_type,
)
else:
if names is None or formats is None:
raise ValueError(
"send either dtype=, data=, or names= and formats=")
if not isinstance(names, list) or not isinstance(formats, list):
raise ValueError("names and formats should be lists")
if len(names) != len(formats):
raise ValueError("names and formats must be same length")
if dims is not None:
if not isinstance(dims, list):
raise ValueError("dims should be a list")
if len(dims) != len(names):
raise ValueError("names and dims must be same length")
if units is not None:
if not isinstance(units, list):
raise ValueError("units should be a list")
if len(units) != len(names):
raise ValueError("names and units must be same length")
if extname is None:
# will be ignored
extname = ""
else:
if not isstring(extname):
raise ValueError("extension name must be a string")
extname = mks(extname)
if extname is not None and extver is not None:
extver = check_extver(extver)
if extver is None:
# will be ignored
extver = 0
if extname is None:
# will be ignored
extname = ""
if header is not None:
nkeys = len(header)
else:
nkeys = 0
# note we can create extname in the c code for tables, but not images
self._FITS.create_table_hdu(table_type_int, nkeys,
names, formats, tunit=units, tdim=dims,
extname=extname, extver=extver)
# don't rebuild the whole list unless this is the first hdu
# to be created
self.update_hdu_list(rebuild=False) | [
"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",
")",
":",
"# record this for the TableHDU object",
"self",
".",
"keys",
"[",
"'write_bitcols'",
"]",
"=",
"write_bitcols",
"# can leave as turn",
"table_type_int",
"=",
"_extract_table_type",
"(",
"table_type",
")",
"if",
"data",
"is",
"not",
"None",
":",
"if",
"isinstance",
"(",
"data",
",",
"numpy",
".",
"ndarray",
")",
":",
"names",
",",
"formats",
",",
"dims",
"=",
"array2tabledef",
"(",
"data",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")",
"elif",
"isinstance",
"(",
"data",
",",
"(",
"list",
",",
"dict",
")",
")",
":",
"names",
",",
"formats",
",",
"dims",
"=",
"collection2tabledef",
"(",
"data",
",",
"names",
"=",
"names",
",",
"table_type",
"=",
"table_type",
",",
"write_bitcols",
"=",
"write_bitcols",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"data must be an ndarray with fields or a dict\"",
")",
"elif",
"dtype",
"is",
"not",
"None",
":",
"dtype",
"=",
"numpy",
".",
"dtype",
"(",
"dtype",
")",
"names",
",",
"formats",
",",
"dims",
"=",
"descr2tabledef",
"(",
"dtype",
".",
"descr",
",",
"write_bitcols",
"=",
"write_bitcols",
",",
"table_type",
"=",
"table_type",
",",
")",
"else",
":",
"if",
"names",
"is",
"None",
"or",
"formats",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"send either dtype=, data=, or names= and formats=\"",
")",
"if",
"not",
"isinstance",
"(",
"names",
",",
"list",
")",
"or",
"not",
"isinstance",
"(",
"formats",
",",
"list",
")",
":",
"raise",
"ValueError",
"(",
"\"names and formats should be lists\"",
")",
"if",
"len",
"(",
"names",
")",
"!=",
"len",
"(",
"formats",
")",
":",
"raise",
"ValueError",
"(",
"\"names and formats must be same length\"",
")",
"if",
"dims",
"is",
"not",
"None",
":",
"if",
"not",
"isinstance",
"(",
"dims",
",",
"list",
")",
":",
"raise",
"ValueError",
"(",
"\"dims should be a list\"",
")",
"if",
"len",
"(",
"dims",
")",
"!=",
"len",
"(",
"names",
")",
":",
"raise",
"ValueError",
"(",
"\"names and dims must be same length\"",
")",
"if",
"units",
"is",
"not",
"None",
":",
"if",
"not",
"isinstance",
"(",
"units",
",",
"list",
")",
":",
"raise",
"ValueError",
"(",
"\"units should be a list\"",
")",
"if",
"len",
"(",
"units",
")",
"!=",
"len",
"(",
"names",
")",
":",
"raise",
"ValueError",
"(",
"\"names and units must be same length\"",
")",
"if",
"extname",
"is",
"None",
":",
"# will be ignored",
"extname",
"=",
"\"\"",
"else",
":",
"if",
"not",
"isstring",
"(",
"extname",
")",
":",
"raise",
"ValueError",
"(",
"\"extension name must be a string\"",
")",
"extname",
"=",
"mks",
"(",
"extname",
")",
"if",
"extname",
"is",
"not",
"None",
"and",
"extver",
"is",
"not",
"None",
":",
"extver",
"=",
"check_extver",
"(",
"extver",
")",
"if",
"extver",
"is",
"None",
":",
"# will be ignored",
"extver",
"=",
"0",
"if",
"extname",
"is",
"None",
":",
"# will be ignored",
"extname",
"=",
"\"\"",
"if",
"header",
"is",
"not",
"None",
":",
"nkeys",
"=",
"len",
"(",
"header",
")",
"else",
":",
"nkeys",
"=",
"0",
"# note we can create extname in the c code for tables, but not images",
"self",
".",
"_FITS",
".",
"create_table_hdu",
"(",
"table_type_int",
",",
"nkeys",
",",
"names",
",",
"formats",
",",
"tunit",
"=",
"units",
",",
"tdim",
"=",
"dims",
",",
"extname",
"=",
"extname",
",",
"extver",
"=",
"extver",
")",
"# don't rebuild the whole list unless this is the first hdu",
"# to be created",
"self",
".",
"update_hdu_list",
"(",
"rebuild",
"=",
"False",
")"
] | Create a new, empty table extension and reload the hdu list.
There are three ways to do it:
1) send a numpy dtype, from which the formats in the fits file will
be determined.
2) Send an array in data= keyword. this is required if you have
object fields for writing to variable length columns.
3) send the names,formats and dims yourself
You can then write data into the new extension using
fits[extension].write(array)
If you want to write to a single column
fits[extension].write_column(array)
But be careful as the other columns will be left zeroed.
Often you will instead just use write_table to do this all
atomically.
fits.write_table(recarray)
write_table will create the new table extension for you with the
appropriate fields.
parameters
----------
dtype: numpy dtype or descriptor, optional
If you have an array with fields, you can just send arr.dtype. You
can also use a list of tuples, e.g. [('x','f8'),('index','i4')] or
a dictionary representation.
data: a numpy array with fields, optional
or a dictionary
An array or dict from which to determine the table definition. You
must use this instead of sending a descriptor if you have object
array fields, as this is the only way to determine the type and max
size.
names: list of strings, optional
The list of field names
formats: list of strings, optional
The TFORM format strings for each field.
dims: list of strings, optional
An optional list of dimension strings for each field. Should
match the repeat count for the formats fields. Be careful of
the order since FITS is more like fortran. See the descr2tabledef
function.
table_type: string, optional
Either 'binary' or 'ascii', default 'binary'
Matching is case-insensitive
units: list of strings, optional
An optional list of unit strings for each field.
extname: string, optional
An optional extension name.
extver: integer, optional
FITS allows multiple extensions to have the same name (extname).
These extensions can optionally specify an EXTVER version number in
the header. Send extver= to set a particular version, which will
be represented in the header with keyname EXTVER. The extver must
be an integer > 0. If extver is not sent, the first one will be
selected. If ext is an integer, the extver is ignored.
write_bitcols: bool, optional
Write boolean arrays in the FITS bitcols format, default False
header: FITSHDR, list, dict, optional
This is only used to determine how many slots to reserve for
header keywords
restrictions
------------
The File must be opened READWRITE | [
"Create",
"a",
"new",
"empty",
"table",
"extension",
"and",
"reload",
"the",
"hdu",
"list",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L861-L1017 | train | 235,032 |
esheldon/fitsio | fitsio/fitslib.py | FITS.update_hdu_list | 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'):
rebuild = True
if rebuild:
self.hdu_list = []
self.hdu_map = {}
# we don't know how many hdus there are, so iterate
# until we can't open any more
ext_start = 0
else:
# start from last
ext_start = len(self)
ext = ext_start
while True:
try:
self._append_hdu_info(ext)
except IOError:
break
except RuntimeError:
break
ext = ext + 1 | python | 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'):
rebuild = True
if rebuild:
self.hdu_list = []
self.hdu_map = {}
# we don't know how many hdus there are, so iterate
# until we can't open any more
ext_start = 0
else:
# start from last
ext_start = len(self)
ext = ext_start
while True:
try:
self._append_hdu_info(ext)
except IOError:
break
except RuntimeError:
break
ext = ext + 1 | [
"def",
"update_hdu_list",
"(",
"self",
",",
"rebuild",
"=",
"True",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'hdu_list'",
")",
":",
"rebuild",
"=",
"True",
"if",
"rebuild",
":",
"self",
".",
"hdu_list",
"=",
"[",
"]",
"self",
".",
"hdu_map",
"=",
"{",
"}",
"# we don't know how many hdus there are, so iterate",
"# until we can't open any more",
"ext_start",
"=",
"0",
"else",
":",
"# start from last",
"ext_start",
"=",
"len",
"(",
"self",
")",
"ext",
"=",
"ext_start",
"while",
"True",
":",
"try",
":",
"self",
".",
"_append_hdu_info",
"(",
"ext",
")",
"except",
"IOError",
":",
"break",
"except",
"RuntimeError",
":",
"break",
"ext",
"=",
"ext",
"+",
"1"
] | 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 | [
"Force",
"an",
"update",
"of",
"the",
"entire",
"HDU",
"list"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1019-L1051 | train | 235,033 |
esheldon/fitsio | fitsio/fitslib.py | FITS.next | 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 | python | 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",
"next",
"(",
"self",
")",
":",
"if",
"self",
".",
"_iter_index",
"==",
"len",
"(",
"self",
".",
"hdu_list",
")",
":",
"raise",
"StopIteration",
"hdu",
"=",
"self",
".",
"hdu_list",
"[",
"self",
".",
"_iter_index",
"]",
"self",
".",
"_iter_index",
"+=",
"1",
"return",
"hdu"
] | Move to the next iteration | [
"Move",
"to",
"the",
"next",
"iteration"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1101-L1109 | train | 235,034 |
esheldon/fitsio | fitsio/fitslib.py | FITS._extract_item | 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[0]
elif nitem == 2:
ext, ver = item
else:
ver_sent = False
ext = item
return ext, ver, ver_sent | python | 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[0]
elif nitem == 2:
ext, ver = item
else:
ver_sent = False
ext = item
return ext, ver, ver_sent | [
"def",
"_extract_item",
"(",
"self",
",",
"item",
")",
":",
"ver",
"=",
"0",
"if",
"isinstance",
"(",
"item",
",",
"tuple",
")",
":",
"ver_sent",
"=",
"True",
"nitem",
"=",
"len",
"(",
"item",
")",
"if",
"nitem",
"==",
"1",
":",
"ext",
"=",
"item",
"[",
"0",
"]",
"elif",
"nitem",
"==",
"2",
":",
"ext",
",",
"ver",
"=",
"item",
"else",
":",
"ver_sent",
"=",
"False",
"ext",
"=",
"item",
"return",
"ext",
",",
"ver",
",",
"ver_sent"
] | utility function to extract an "item", meaning
a extension number,name plus version. | [
"utility",
"function",
"to",
"extract",
"an",
"item",
"meaning",
"a",
"extension",
"number",
"name",
"plus",
"version",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/fitslib.py#L1121-L1137 | train | 235,035 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU._update_info | 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
raise ValueError(mess)
# convert to c order
if 'dims' in self._info:
self._info['dims'] = list(reversed(self._info['dims'])) | python | 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
raise ValueError(mess)
# convert to c order
if 'dims' in self._info:
self._info['dims'] = list(reversed(self._info['dims'])) | [
"def",
"_update_info",
"(",
"self",
")",
":",
"super",
"(",
"ImageHDU",
",",
"self",
")",
".",
"_update_info",
"(",
")",
"if",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"!=",
"IMAGE_HDU",
":",
"mess",
"=",
"\"Extension %s is not a Image HDU\"",
"%",
"self",
".",
"ext",
"raise",
"ValueError",
"(",
"mess",
")",
"# convert to c order",
"if",
"'dims'",
"in",
"self",
".",
"_info",
":",
"self",
".",
"_info",
"[",
"'dims'",
"]",
"=",
"list",
"(",
"reversed",
"(",
"self",
".",
"_info",
"[",
"'dims'",
"]",
")",
")"
] | Call parent method and make sure this is in fact a
image HDU. Set dims in C order | [
"Call",
"parent",
"method",
"and",
"make",
"sure",
"this",
"is",
"in",
"fact",
"a",
"image",
"HDU",
".",
"Set",
"dims",
"in",
"C",
"order"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L37-L50 | train | 235,036 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU.reshape | 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, adims) | python | 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, adims) | [
"def",
"reshape",
"(",
"self",
",",
"dims",
")",
":",
"adims",
"=",
"numpy",
".",
"array",
"(",
"dims",
",",
"ndmin",
"=",
"1",
",",
"dtype",
"=",
"'i8'",
")",
"self",
".",
"_FITS",
".",
"reshape_image",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"adims",
")"
] | reshape an existing image to the requested dimensions
parameters
----------
dims: sequence
Any sequence convertible to i8 | [
"reshape",
"an",
"existing",
"image",
"to",
"the",
"requested",
"dimensions"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L91-L102 | train | 235,037 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU.write | 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
dimensions, the on-disk image is expanded.
parameters
----------
img: ndarray
A simple numpy ndarray
start: integer or sequence
Where to start writing data. Can be an integer offset
into the entire array, or a sequence determining where
in N-dimensional space to start.
"""
dims = self.get_dims()
if img.dtype.fields is not None:
raise ValueError("got recarray, expected regular ndarray")
if img.size == 0:
raise ValueError("data must have at least 1 row")
# data must be c-contiguous and native byte order
if not img.flags['C_CONTIGUOUS']:
# this always makes a copy
img_send = numpy.ascontiguousarray(img)
array_to_native(img_send, inplace=True)
else:
img_send = array_to_native(img, inplace=False)
if IS_PY3 and img_send.dtype.char == 'U':
# for python3, we convert unicode to ascii
# this will error if the character is not in ascii
img_send = img_send.astype('S', copy=False)
if not numpy.isscalar(start):
# convert to scalar offset
# note we use the on-disk data type to get itemsize
offset = _convert_full_start_to_offset(dims, start)
else:
offset = start
# see if we need to resize the image
if self.has_data():
self._expand_if_needed(dims, img.shape, start, offset)
self._FITS.write_image(self._ext+1, img_send, offset+1)
self._update_info() | python | 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
dimensions, the on-disk image is expanded.
parameters
----------
img: ndarray
A simple numpy ndarray
start: integer or sequence
Where to start writing data. Can be an integer offset
into the entire array, or a sequence determining where
in N-dimensional space to start.
"""
dims = self.get_dims()
if img.dtype.fields is not None:
raise ValueError("got recarray, expected regular ndarray")
if img.size == 0:
raise ValueError("data must have at least 1 row")
# data must be c-contiguous and native byte order
if not img.flags['C_CONTIGUOUS']:
# this always makes a copy
img_send = numpy.ascontiguousarray(img)
array_to_native(img_send, inplace=True)
else:
img_send = array_to_native(img, inplace=False)
if IS_PY3 and img_send.dtype.char == 'U':
# for python3, we convert unicode to ascii
# this will error if the character is not in ascii
img_send = img_send.astype('S', copy=False)
if not numpy.isscalar(start):
# convert to scalar offset
# note we use the on-disk data type to get itemsize
offset = _convert_full_start_to_offset(dims, start)
else:
offset = start
# see if we need to resize the image
if self.has_data():
self._expand_if_needed(dims, img.shape, start, offset)
self._FITS.write_image(self._ext+1, img_send, offset+1)
self._update_info() | [
"def",
"write",
"(",
"self",
",",
"img",
",",
"start",
"=",
"0",
",",
"*",
"*",
"keys",
")",
":",
"dims",
"=",
"self",
".",
"get_dims",
"(",
")",
"if",
"img",
".",
"dtype",
".",
"fields",
"is",
"not",
"None",
":",
"raise",
"ValueError",
"(",
"\"got recarray, expected regular ndarray\"",
")",
"if",
"img",
".",
"size",
"==",
"0",
":",
"raise",
"ValueError",
"(",
"\"data must have at least 1 row\"",
")",
"# data must be c-contiguous and native byte order",
"if",
"not",
"img",
".",
"flags",
"[",
"'C_CONTIGUOUS'",
"]",
":",
"# this always makes a copy",
"img_send",
"=",
"numpy",
".",
"ascontiguousarray",
"(",
"img",
")",
"array_to_native",
"(",
"img_send",
",",
"inplace",
"=",
"True",
")",
"else",
":",
"img_send",
"=",
"array_to_native",
"(",
"img",
",",
"inplace",
"=",
"False",
")",
"if",
"IS_PY3",
"and",
"img_send",
".",
"dtype",
".",
"char",
"==",
"'U'",
":",
"# for python3, we convert unicode to ascii",
"# this will error if the character is not in ascii",
"img_send",
"=",
"img_send",
".",
"astype",
"(",
"'S'",
",",
"copy",
"=",
"False",
")",
"if",
"not",
"numpy",
".",
"isscalar",
"(",
"start",
")",
":",
"# convert to scalar offset",
"# note we use the on-disk data type to get itemsize",
"offset",
"=",
"_convert_full_start_to_offset",
"(",
"dims",
",",
"start",
")",
"else",
":",
"offset",
"=",
"start",
"# see if we need to resize the image",
"if",
"self",
".",
"has_data",
"(",
")",
":",
"self",
".",
"_expand_if_needed",
"(",
"dims",
",",
"img",
".",
"shape",
",",
"start",
",",
"offset",
")",
"self",
".",
"_FITS",
".",
"write_image",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"img_send",
",",
"offset",
"+",
"1",
")",
"self",
".",
"_update_info",
"(",
")"
] | 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
dimensions, the on-disk image is expanded.
parameters
----------
img: ndarray
A simple numpy ndarray
start: integer or sequence
Where to start writing data. Can be an integer offset
into the entire array, or a sequence determining where
in N-dimensional space to start. | [
"Write",
"the",
"image",
"into",
"this",
"HDU"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L104-L156 | train | 235,038 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU.read | 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 = numpy.zeros(shape, dtype=dtype)
self._FITS.read_image(self._ext+1, array)
return array | python | 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 = numpy.zeros(shape, dtype=dtype)
self._FITS.read_image(self._ext+1, array)
return array | [
"def",
"read",
"(",
"self",
",",
"*",
"*",
"keys",
")",
":",
"if",
"not",
"self",
".",
"has_data",
"(",
")",
":",
"return",
"None",
"dtype",
",",
"shape",
"=",
"self",
".",
"_get_dtype_and_shape",
"(",
")",
"array",
"=",
"numpy",
".",
"zeros",
"(",
"shape",
",",
"dtype",
"=",
"dtype",
")",
"self",
".",
"_FITS",
".",
"read_image",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"array",
")",
"return",
"array"
] | Read the image.
If the HDU is an IMAGE_HDU, read the corresponding image. Compression
and scaling are dealt with properly. | [
"Read",
"the",
"image",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L158-L171 | train | 235,039 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU._get_dtype_and_shape | 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_dtype, shape | python | 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_dtype, shape | [
"def",
"_get_dtype_and_shape",
"(",
"self",
")",
":",
"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_dtype",
",",
"shape"
] | Get the numpy dtype and shape for image | [
"Get",
"the",
"numpy",
"dtype",
"and",
"shape",
"for",
"image"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L173-L184 | train | 235,040 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU._get_image_numpy_dtype | 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 npy_type | python | 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 npy_type | [
"def",
"_get_image_numpy_dtype",
"(",
"self",
")",
":",
"try",
":",
"ftype",
"=",
"self",
".",
"_info",
"[",
"'img_equiv_type'",
"]",
"npy_type",
"=",
"_image_bitpix2npy",
"[",
"ftype",
"]",
"except",
"KeyError",
":",
"raise",
"KeyError",
"(",
"\"unsupported fits data type: %d\"",
"%",
"ftype",
")",
"return",
"npy_type"
] | Get the numpy dtype for the image | [
"Get",
"the",
"numpy",
"dtype",
"for",
"the",
"image"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L186-L196 | train | 235,041 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU._read_image_slice | 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,))
if not isinstance(arg, tuple):
raise ValueError("arguments must be slices, one for each "
"dimension, e.g. [2:5] or [2:5,8:25] etc.")
# should be a tuple of slices, one for each dimension
# e.g. [2:3, 8:100]
nd = len(arg)
if nd != self._info['ndims']:
raise ValueError("Got slice dimensions %d, "
"expected %d" % (nd, self._info['ndims']))
targ = arg
arg = []
for a in targ:
if isinstance(a, slice):
arg.append(a)
elif isinstance(a, int):
arg.append(slice(a, a+1, 1))
else:
raise ValueError("arguments must be slices, e.g. 2:12")
dims = self._info['dims']
arrdims = []
first = []
last = []
steps = []
# check the args and reverse dimensions since
# fits is backwards from numpy
dim = 0
for slc in arg:
start = slc.start
stop = slc.stop
step = slc.step
if start is None:
start = 0
if stop is None:
stop = dims[dim]
if step is None:
step = 1
if step < 1:
raise ValueError("slice steps must be >= 1")
if start < 0:
start = dims[dim] + start
if start < 0:
raise IndexError("Index out of bounds")
if stop < 0:
stop = dims[dim] + start + 1
# move to 1-offset
start = start + 1
if stop < start:
raise ValueError("python slices but include at least one "
"element, got %s" % slc)
if stop > dims[dim]:
stop = dims[dim]
first.append(start)
last.append(stop)
steps.append(step)
arrdims.append(stop-start+1)
dim += 1
first.reverse()
last.reverse()
steps.reverse()
first = numpy.array(first, dtype='i8')
last = numpy.array(last, dtype='i8')
steps = numpy.array(steps, dtype='i8')
npy_dtype = self._get_image_numpy_dtype()
array = numpy.zeros(arrdims, dtype=npy_dtype)
self._FITS.read_image_slice(self._ext+1, first, last, steps, array)
return array | python | 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,))
if not isinstance(arg, tuple):
raise ValueError("arguments must be slices, one for each "
"dimension, e.g. [2:5] or [2:5,8:25] etc.")
# should be a tuple of slices, one for each dimension
# e.g. [2:3, 8:100]
nd = len(arg)
if nd != self._info['ndims']:
raise ValueError("Got slice dimensions %d, "
"expected %d" % (nd, self._info['ndims']))
targ = arg
arg = []
for a in targ:
if isinstance(a, slice):
arg.append(a)
elif isinstance(a, int):
arg.append(slice(a, a+1, 1))
else:
raise ValueError("arguments must be slices, e.g. 2:12")
dims = self._info['dims']
arrdims = []
first = []
last = []
steps = []
# check the args and reverse dimensions since
# fits is backwards from numpy
dim = 0
for slc in arg:
start = slc.start
stop = slc.stop
step = slc.step
if start is None:
start = 0
if stop is None:
stop = dims[dim]
if step is None:
step = 1
if step < 1:
raise ValueError("slice steps must be >= 1")
if start < 0:
start = dims[dim] + start
if start < 0:
raise IndexError("Index out of bounds")
if stop < 0:
stop = dims[dim] + start + 1
# move to 1-offset
start = start + 1
if stop < start:
raise ValueError("python slices but include at least one "
"element, got %s" % slc)
if stop > dims[dim]:
stop = dims[dim]
first.append(start)
last.append(stop)
steps.append(step)
arrdims.append(stop-start+1)
dim += 1
first.reverse()
last.reverse()
steps.reverse()
first = numpy.array(first, dtype='i8')
last = numpy.array(last, dtype='i8')
steps = numpy.array(steps, dtype='i8')
npy_dtype = self._get_image_numpy_dtype()
array = numpy.zeros(arrdims, dtype=npy_dtype)
self._FITS.read_image_slice(self._ext+1, first, last, steps, array)
return array | [
"def",
"_read_image_slice",
"(",
"self",
",",
"arg",
")",
":",
"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",
",",
")",
")",
"if",
"not",
"isinstance",
"(",
"arg",
",",
"tuple",
")",
":",
"raise",
"ValueError",
"(",
"\"arguments must be slices, one for each \"",
"\"dimension, e.g. [2:5] or [2:5,8:25] etc.\"",
")",
"# should be a tuple of slices, one for each dimension",
"# e.g. [2:3, 8:100]",
"nd",
"=",
"len",
"(",
"arg",
")",
"if",
"nd",
"!=",
"self",
".",
"_info",
"[",
"'ndims'",
"]",
":",
"raise",
"ValueError",
"(",
"\"Got slice dimensions %d, \"",
"\"expected %d\"",
"%",
"(",
"nd",
",",
"self",
".",
"_info",
"[",
"'ndims'",
"]",
")",
")",
"targ",
"=",
"arg",
"arg",
"=",
"[",
"]",
"for",
"a",
"in",
"targ",
":",
"if",
"isinstance",
"(",
"a",
",",
"slice",
")",
":",
"arg",
".",
"append",
"(",
"a",
")",
"elif",
"isinstance",
"(",
"a",
",",
"int",
")",
":",
"arg",
".",
"append",
"(",
"slice",
"(",
"a",
",",
"a",
"+",
"1",
",",
"1",
")",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"arguments must be slices, e.g. 2:12\"",
")",
"dims",
"=",
"self",
".",
"_info",
"[",
"'dims'",
"]",
"arrdims",
"=",
"[",
"]",
"first",
"=",
"[",
"]",
"last",
"=",
"[",
"]",
"steps",
"=",
"[",
"]",
"# check the args and reverse dimensions since",
"# fits is backwards from numpy",
"dim",
"=",
"0",
"for",
"slc",
"in",
"arg",
":",
"start",
"=",
"slc",
".",
"start",
"stop",
"=",
"slc",
".",
"stop",
"step",
"=",
"slc",
".",
"step",
"if",
"start",
"is",
"None",
":",
"start",
"=",
"0",
"if",
"stop",
"is",
"None",
":",
"stop",
"=",
"dims",
"[",
"dim",
"]",
"if",
"step",
"is",
"None",
":",
"step",
"=",
"1",
"if",
"step",
"<",
"1",
":",
"raise",
"ValueError",
"(",
"\"slice steps must be >= 1\"",
")",
"if",
"start",
"<",
"0",
":",
"start",
"=",
"dims",
"[",
"dim",
"]",
"+",
"start",
"if",
"start",
"<",
"0",
":",
"raise",
"IndexError",
"(",
"\"Index out of bounds\"",
")",
"if",
"stop",
"<",
"0",
":",
"stop",
"=",
"dims",
"[",
"dim",
"]",
"+",
"start",
"+",
"1",
"# move to 1-offset",
"start",
"=",
"start",
"+",
"1",
"if",
"stop",
"<",
"start",
":",
"raise",
"ValueError",
"(",
"\"python slices but include at least one \"",
"\"element, got %s\"",
"%",
"slc",
")",
"if",
"stop",
">",
"dims",
"[",
"dim",
"]",
":",
"stop",
"=",
"dims",
"[",
"dim",
"]",
"first",
".",
"append",
"(",
"start",
")",
"last",
".",
"append",
"(",
"stop",
")",
"steps",
".",
"append",
"(",
"step",
")",
"arrdims",
".",
"append",
"(",
"stop",
"-",
"start",
"+",
"1",
")",
"dim",
"+=",
"1",
"first",
".",
"reverse",
"(",
")",
"last",
".",
"reverse",
"(",
")",
"steps",
".",
"reverse",
"(",
")",
"first",
"=",
"numpy",
".",
"array",
"(",
"first",
",",
"dtype",
"=",
"'i8'",
")",
"last",
"=",
"numpy",
".",
"array",
"(",
"last",
",",
"dtype",
"=",
"'i8'",
")",
"steps",
"=",
"numpy",
".",
"array",
"(",
"steps",
",",
"dtype",
"=",
"'i8'",
")",
"npy_dtype",
"=",
"self",
".",
"_get_image_numpy_dtype",
"(",
")",
"array",
"=",
"numpy",
".",
"zeros",
"(",
"arrdims",
",",
"dtype",
"=",
"npy_dtype",
")",
"self",
".",
"_FITS",
".",
"read_image_slice",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"first",
",",
"last",
",",
"steps",
",",
"array",
")",
"return",
"array"
] | workhorse to read a slice | [
"workhorse",
"to",
"read",
"a",
"slice"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L206-L295 | train | 235,042 |
esheldon/fitsio | fitsio/hdu/image.py | ImageHDU._expand_if_needed | 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:
start_is_scalar = False
existing_size = reduce(mul, dims, 1)
required_size = offset + reduce(mul, write_dims, 1)
if required_size > existing_size:
print(
" required size:", required_size,
"existing size:", existing_size)
# we need to expand the image
ndim = len(dims)
idim = len(write_dims)
if start_is_scalar:
if start == 0:
start = [0]*ndim
else:
raise ValueError(
"When expanding "
"an existing image while writing, the start keyword "
"must have the same number of dimensions "
"as the image or be exactly 0, got %s " % start)
if idim != ndim:
raise ValueError(
"When expanding "
"an existing image while writing, the input image "
"must have the same number of dimensions "
"as the original. "
"Got %d instead of %d" % (idim, ndim))
new_dims = []
for i in xrange(ndim):
required_dim = start[i] + write_dims[i]
if required_dim < dims[i]:
# careful not to shrink the image!
dimsize = dims[i]
else:
dimsize = required_dim
new_dims.append(dimsize)
print(" reshaping image to:", new_dims)
self.reshape(new_dims) | python | 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:
start_is_scalar = False
existing_size = reduce(mul, dims, 1)
required_size = offset + reduce(mul, write_dims, 1)
if required_size > existing_size:
print(
" required size:", required_size,
"existing size:", existing_size)
# we need to expand the image
ndim = len(dims)
idim = len(write_dims)
if start_is_scalar:
if start == 0:
start = [0]*ndim
else:
raise ValueError(
"When expanding "
"an existing image while writing, the start keyword "
"must have the same number of dimensions "
"as the image or be exactly 0, got %s " % start)
if idim != ndim:
raise ValueError(
"When expanding "
"an existing image while writing, the input image "
"must have the same number of dimensions "
"as the original. "
"Got %d instead of %d" % (idim, ndim))
new_dims = []
for i in xrange(ndim):
required_dim = start[i] + write_dims[i]
if required_dim < dims[i]:
# careful not to shrink the image!
dimsize = dims[i]
else:
dimsize = required_dim
new_dims.append(dimsize)
print(" reshaping image to:", new_dims)
self.reshape(new_dims) | [
"def",
"_expand_if_needed",
"(",
"self",
",",
"dims",
",",
"write_dims",
",",
"start",
",",
"offset",
")",
":",
"from",
"operator",
"import",
"mul",
"if",
"numpy",
".",
"isscalar",
"(",
"start",
")",
":",
"start_is_scalar",
"=",
"True",
"else",
":",
"start_is_scalar",
"=",
"False",
"existing_size",
"=",
"reduce",
"(",
"mul",
",",
"dims",
",",
"1",
")",
"required_size",
"=",
"offset",
"+",
"reduce",
"(",
"mul",
",",
"write_dims",
",",
"1",
")",
"if",
"required_size",
">",
"existing_size",
":",
"print",
"(",
"\" required size:\"",
",",
"required_size",
",",
"\"existing size:\"",
",",
"existing_size",
")",
"# we need to expand the image",
"ndim",
"=",
"len",
"(",
"dims",
")",
"idim",
"=",
"len",
"(",
"write_dims",
")",
"if",
"start_is_scalar",
":",
"if",
"start",
"==",
"0",
":",
"start",
"=",
"[",
"0",
"]",
"*",
"ndim",
"else",
":",
"raise",
"ValueError",
"(",
"\"When expanding \"",
"\"an existing image while writing, the start keyword \"",
"\"must have the same number of dimensions \"",
"\"as the image or be exactly 0, got %s \"",
"%",
"start",
")",
"if",
"idim",
"!=",
"ndim",
":",
"raise",
"ValueError",
"(",
"\"When expanding \"",
"\"an existing image while writing, the input image \"",
"\"must have the same number of dimensions \"",
"\"as the original. \"",
"\"Got %d instead of %d\"",
"%",
"(",
"idim",
",",
"ndim",
")",
")",
"new_dims",
"=",
"[",
"]",
"for",
"i",
"in",
"xrange",
"(",
"ndim",
")",
":",
"required_dim",
"=",
"start",
"[",
"i",
"]",
"+",
"write_dims",
"[",
"i",
"]",
"if",
"required_dim",
"<",
"dims",
"[",
"i",
"]",
":",
"# careful not to shrink the image!",
"dimsize",
"=",
"dims",
"[",
"i",
"]",
"else",
":",
"dimsize",
"=",
"required_dim",
"new_dims",
".",
"append",
"(",
"dimsize",
")",
"print",
"(",
"\" reshaping image to:\"",
",",
"new_dims",
")",
"self",
".",
"reshape",
"(",
"new_dims",
")"
] | expand the on-disk image if the indended write will extend
beyond the existing dimensions | [
"expand",
"the",
"on",
"-",
"disk",
"image",
"if",
"the",
"indended",
"write",
"will",
"extend",
"beyond",
"the",
"existing",
"dimensions"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/image.py#L297-L350 | train | 235,043 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.get_extname | 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() | python | 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_extname",
"(",
"self",
")",
":",
"name",
"=",
"self",
".",
"_info",
"[",
"'extname'",
"]",
"if",
"name",
".",
"strip",
"(",
")",
"==",
"''",
":",
"name",
"=",
"self",
".",
"_info",
"[",
"'hduname'",
"]",
"return",
"name",
".",
"strip",
"(",
")"
] | Get the name for this extension, can be an empty string | [
"Get",
"the",
"name",
"for",
"this",
"extension",
"can",
"be",
"an",
"empty",
"string"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L59-L66 | train | 235,044 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.get_extver | 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 | python | 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_extver",
"(",
"self",
")",
":",
"ver",
"=",
"self",
".",
"_info",
"[",
"'extver'",
"]",
"if",
"ver",
"==",
"0",
":",
"ver",
"=",
"self",
".",
"_info",
"[",
"'hduver'",
"]",
"return",
"ver"
] | Get the version for this extension.
Used when a name is given to multiple extensions | [
"Get",
"the",
"version",
"for",
"this",
"extension",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L68-L77 | train | 235,045 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.get_exttype | 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 numbers. The values
fitsio.IMAGE_HDU .ASCII_TBL, and .BINARY_TBL
are available for comparison
parameters
----------
num: bool, optional
Return the numeric values.
"""
if num:
return self._info['hdutype']
else:
name = _hdu_type_map[self._info['hdutype']]
return name | python | 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 numbers. The values
fitsio.IMAGE_HDU .ASCII_TBL, and .BINARY_TBL
are available for comparison
parameters
----------
num: bool, optional
Return the numeric values.
"""
if num:
return self._info['hdutype']
else:
name = _hdu_type_map[self._info['hdutype']]
return name | [
"def",
"get_exttype",
"(",
"self",
",",
"num",
"=",
"False",
")",
":",
"if",
"num",
":",
"return",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"else",
":",
"name",
"=",
"_hdu_type_map",
"[",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"]",
"return",
"name"
] | 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 numbers. The values
fitsio.IMAGE_HDU .ASCII_TBL, and .BINARY_TBL
are available for comparison
parameters
----------
num: bool, optional
Return the numeric values. | [
"Get",
"the",
"extension",
"type"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L79-L101 | train | 235,046 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.verify_checksum | 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 failed") | python | 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 failed") | [
"def",
"verify_checksum",
"(",
"self",
")",
":",
"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 failed\"",
")"
] | Verify the checksum in the header for this HDU. | [
"Verify",
"the",
"checksum",
"in",
"the",
"header",
"for",
"this",
"HDU",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L153-L161 | train | 235,047 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.write_comment | def write_comment(self, comment):
"""
Write a comment into the header
"""
self._FITS.write_comment(self._ext+1, str(comment)) | python | def write_comment(self, comment):
"""
Write a comment into the header
"""
self._FITS.write_comment(self._ext+1, str(comment)) | [
"def",
"write_comment",
"(",
"self",
",",
"comment",
")",
":",
"self",
".",
"_FITS",
".",
"write_comment",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"comment",
")",
")"
] | Write a comment into the header | [
"Write",
"a",
"comment",
"into",
"the",
"header"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L163-L167 | train | 235,048 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.write_key | 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 scalar types.
comment: string, optional
An optional comment to write for this key
Notes
-----
Write COMMENT and HISTORY using the write_comment and write_history
methods
"""
if value is None:
self._FITS.write_undefined_key(self._ext+1,
str(name),
str(comment))
elif isinstance(value, bool):
if value:
v = 1
else:
v = 0
self._FITS.write_logical_key(self._ext+1,
str(name),
v,
str(comment))
elif isinstance(value, _stypes):
self._FITS.write_string_key(self._ext+1,
str(name),
str(value),
str(comment))
elif isinstance(value, _ftypes):
self._FITS.write_double_key(self._ext+1,
str(name),
float(value),
str(comment))
elif isinstance(value, _itypes):
self._FITS.write_long_key(self._ext+1,
str(name),
int(value),
str(comment))
elif isinstance(value, (tuple, list)):
vl = [str(el) for el in value]
sval = ','.join(vl)
self._FITS.write_string_key(self._ext+1,
str(name),
sval,
str(comment))
else:
sval = str(value)
mess = (
"warning, keyword '%s' has non-standard "
"value type %s, "
"Converting to string: '%s'")
warnings.warn(mess % (name, type(value), sval), FITSRuntimeWarning)
self._FITS.write_string_key(self._ext+1,
str(name),
sval,
str(comment)) | python | 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 scalar types.
comment: string, optional
An optional comment to write for this key
Notes
-----
Write COMMENT and HISTORY using the write_comment and write_history
methods
"""
if value is None:
self._FITS.write_undefined_key(self._ext+1,
str(name),
str(comment))
elif isinstance(value, bool):
if value:
v = 1
else:
v = 0
self._FITS.write_logical_key(self._ext+1,
str(name),
v,
str(comment))
elif isinstance(value, _stypes):
self._FITS.write_string_key(self._ext+1,
str(name),
str(value),
str(comment))
elif isinstance(value, _ftypes):
self._FITS.write_double_key(self._ext+1,
str(name),
float(value),
str(comment))
elif isinstance(value, _itypes):
self._FITS.write_long_key(self._ext+1,
str(name),
int(value),
str(comment))
elif isinstance(value, (tuple, list)):
vl = [str(el) for el in value]
sval = ','.join(vl)
self._FITS.write_string_key(self._ext+1,
str(name),
sval,
str(comment))
else:
sval = str(value)
mess = (
"warning, keyword '%s' has non-standard "
"value type %s, "
"Converting to string: '%s'")
warnings.warn(mess % (name, type(value), sval), FITSRuntimeWarning)
self._FITS.write_string_key(self._ext+1,
str(name),
sval,
str(comment)) | [
"def",
"write_key",
"(",
"self",
",",
"name",
",",
"value",
",",
"comment",
"=",
"\"\"",
")",
":",
"if",
"value",
"is",
"None",
":",
"self",
".",
"_FITS",
".",
"write_undefined_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"str",
"(",
"comment",
")",
")",
"elif",
"isinstance",
"(",
"value",
",",
"bool",
")",
":",
"if",
"value",
":",
"v",
"=",
"1",
"else",
":",
"v",
"=",
"0",
"self",
".",
"_FITS",
".",
"write_logical_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"v",
",",
"str",
"(",
"comment",
")",
")",
"elif",
"isinstance",
"(",
"value",
",",
"_stypes",
")",
":",
"self",
".",
"_FITS",
".",
"write_string_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"str",
"(",
"value",
")",
",",
"str",
"(",
"comment",
")",
")",
"elif",
"isinstance",
"(",
"value",
",",
"_ftypes",
")",
":",
"self",
".",
"_FITS",
".",
"write_double_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"float",
"(",
"value",
")",
",",
"str",
"(",
"comment",
")",
")",
"elif",
"isinstance",
"(",
"value",
",",
"_itypes",
")",
":",
"self",
".",
"_FITS",
".",
"write_long_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"int",
"(",
"value",
")",
",",
"str",
"(",
"comment",
")",
")",
"elif",
"isinstance",
"(",
"value",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"vl",
"=",
"[",
"str",
"(",
"el",
")",
"for",
"el",
"in",
"value",
"]",
"sval",
"=",
"','",
".",
"join",
"(",
"vl",
")",
"self",
".",
"_FITS",
".",
"write_string_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"sval",
",",
"str",
"(",
"comment",
")",
")",
"else",
":",
"sval",
"=",
"str",
"(",
"value",
")",
"mess",
"=",
"(",
"\"warning, keyword '%s' has non-standard \"",
"\"value type %s, \"",
"\"Converting to string: '%s'\"",
")",
"warnings",
".",
"warn",
"(",
"mess",
"%",
"(",
"name",
",",
"type",
"(",
"value",
")",
",",
"sval",
")",
",",
"FITSRuntimeWarning",
")",
"self",
".",
"_FITS",
".",
"write_string_key",
"(",
"self",
".",
"_ext",
"+",
"1",
",",
"str",
"(",
"name",
")",
",",
"sval",
",",
"str",
"(",
"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 scalar types.
comment: string, optional
An optional comment to write for this key
Notes
-----
Write COMMENT and HISTORY using the write_comment and write_history
methods | [
"Write",
"the",
"input",
"value",
"to",
"the",
"header"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L181-L247 | train | 235,049 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase.write_keys | 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 optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
clean: boolean
If True, trim out the standard fits header keywords that are
created on HDU creation, such as EXTEND, SIMPLE, STTYPE, TFORM,
TDIM, XTENSION, BITPIX, NAXIS, etc.
Notes
-----
Input keys named COMMENT and HISTORY are written using the
write_comment and write_history methods.
"""
if isinstance(records_in, FITSHDR):
hdr = records_in
else:
hdr = FITSHDR(records_in)
if clean:
is_table = hasattr(self, '_table_type_str')
# is_table = isinstance(self, TableHDU)
hdr.clean(is_table=is_table)
for r in hdr.records():
name = r['name'].upper()
value = r['value']
if name == 'COMMENT':
self.write_comment(value)
elif name == 'HISTORY':
self.write_history(value)
elif name == 'CONTINUE':
self._write_continue(value)
else:
comment = r.get('comment', '')
self.write_key(name, value, comment=comment) | python | 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 optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
clean: boolean
If True, trim out the standard fits header keywords that are
created on HDU creation, such as EXTEND, SIMPLE, STTYPE, TFORM,
TDIM, XTENSION, BITPIX, NAXIS, etc.
Notes
-----
Input keys named COMMENT and HISTORY are written using the
write_comment and write_history methods.
"""
if isinstance(records_in, FITSHDR):
hdr = records_in
else:
hdr = FITSHDR(records_in)
if clean:
is_table = hasattr(self, '_table_type_str')
# is_table = isinstance(self, TableHDU)
hdr.clean(is_table=is_table)
for r in hdr.records():
name = r['name'].upper()
value = r['value']
if name == 'COMMENT':
self.write_comment(value)
elif name == 'HISTORY':
self.write_history(value)
elif name == 'CONTINUE':
self._write_continue(value)
else:
comment = r.get('comment', '')
self.write_key(name, value, comment=comment) | [
"def",
"write_keys",
"(",
"self",
",",
"records_in",
",",
"clean",
"=",
"True",
")",
":",
"if",
"isinstance",
"(",
"records_in",
",",
"FITSHDR",
")",
":",
"hdr",
"=",
"records_in",
"else",
":",
"hdr",
"=",
"FITSHDR",
"(",
"records_in",
")",
"if",
"clean",
":",
"is_table",
"=",
"hasattr",
"(",
"self",
",",
"'_table_type_str'",
")",
"# is_table = isinstance(self, TableHDU)",
"hdr",
".",
"clean",
"(",
"is_table",
"=",
"is_table",
")",
"for",
"r",
"in",
"hdr",
".",
"records",
"(",
")",
":",
"name",
"=",
"r",
"[",
"'name'",
"]",
".",
"upper",
"(",
")",
"value",
"=",
"r",
"[",
"'value'",
"]",
"if",
"name",
"==",
"'COMMENT'",
":",
"self",
".",
"write_comment",
"(",
"value",
")",
"elif",
"name",
"==",
"'HISTORY'",
":",
"self",
".",
"write_history",
"(",
"value",
")",
"elif",
"name",
"==",
"'CONTINUE'",
":",
"self",
".",
"_write_continue",
"(",
"value",
")",
"else",
":",
"comment",
"=",
"r",
".",
"get",
"(",
"'comment'",
",",
"''",
")",
"self",
".",
"write_key",
"(",
"name",
",",
"value",
",",
"comment",
"=",
"comment",
")"
] | 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 optionally
a 'comment' field; the order is preserved.
- a dictionary of keyword-value pairs; no comments are written
in this case, and the order is arbitrary.
clean: boolean
If True, trim out the standard fits header keywords that are
created on HDU creation, such as EXTEND, SIMPLE, STTYPE, TFORM,
TDIM, XTENSION, BITPIX, NAXIS, etc.
Notes
-----
Input keys named COMMENT and HISTORY are written using the
write_comment and write_history methods. | [
"Write",
"the",
"keywords",
"to",
"the",
"header",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L249-L295 | train | 235,050 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase._update_info | 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) | python | 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",
"_update_info",
"(",
"self",
")",
":",
"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",
")"
] | Update metadata for this HDU | [
"Update",
"metadata",
"for",
"this",
"HDU"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L322-L331 | train | 235,051 |
esheldon/fitsio | fitsio/hdu/base.py | HDUBase._get_repr_list | 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(
"%stype: %s" % (spacing, _hdu_type_map[self._info['hdutype']]))
extname = self.get_extname()
if extname != "":
text.append("%sextname: %s" % (spacing, extname))
extver = self.get_extver()
if extver != 0:
text.append("%sextver: %s" % (spacing, extver))
return text, spacing | python | 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(
"%stype: %s" % (spacing, _hdu_type_map[self._info['hdutype']]))
extname = self.get_extname()
if extname != "":
text.append("%sextname: %s" % (spacing, extname))
extver = self.get_extver()
if extver != 0:
text.append("%sextver: %s" % (spacing, extver))
return text, spacing | [
"def",
"_get_repr_list",
"(",
"self",
")",
":",
"spacing",
"=",
"' '",
"*",
"2",
"text",
"=",
"[",
"''",
"]",
"text",
".",
"append",
"(",
"\"%sfile: %s\"",
"%",
"(",
"spacing",
",",
"self",
".",
"_filename",
")",
")",
"text",
".",
"append",
"(",
"\"%sextension: %d\"",
"%",
"(",
"spacing",
",",
"self",
".",
"_info",
"[",
"'hdunum'",
"]",
"-",
"1",
")",
")",
"text",
".",
"append",
"(",
"\"%stype: %s\"",
"%",
"(",
"spacing",
",",
"_hdu_type_map",
"[",
"self",
".",
"_info",
"[",
"'hdutype'",
"]",
"]",
")",
")",
"extname",
"=",
"self",
".",
"get_extname",
"(",
")",
"if",
"extname",
"!=",
"\"\"",
":",
"text",
".",
"append",
"(",
"\"%sextname: %s\"",
"%",
"(",
"spacing",
",",
"extname",
")",
")",
"extver",
"=",
"self",
".",
"get_extver",
"(",
")",
"if",
"extver",
"!=",
"0",
":",
"text",
".",
"append",
"(",
"\"%sextver: %s\"",
"%",
"(",
"spacing",
",",
"extver",
")",
")",
"return",
"text",
",",
"spacing"
] | Get some representation data common to all HDU types | [
"Get",
"some",
"representation",
"data",
"common",
"to",
"all",
"HDU",
"types"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/hdu/base.py#L333-L351 | train | 235,052 |
esheldon/fitsio | fitsio/header.py | FITSHDR.add_record | 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 string
or a FITSRecord or FITSCard
convert: bool, optional
If True, convert strings. E.g. '3' gets
converted to 3 and "'hello'" gets converted
to 'hello' and 'T'/'F' to True/False. Default
is False.
"""
if (isinstance(record_in, dict) and
'name' in record_in and 'value' in record_in):
record = {}
record.update(record_in)
else:
record = FITSRecord(record_in)
# only append when this name already exists if it is
# a comment or history field, otherwise simply over-write
key = record['name'].upper()
key_exists = key in self._record_map
if not key_exists or key in ('COMMENT', 'HISTORY', 'CONTINUE'):
# append new record
self._record_list.append(record)
index = len(self._record_list)-1
self._index_map[key] = index
else:
# over-write existing
index = self._index_map[key]
self._record_list[index] = record
self._record_map[key] = record | python | 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 string
or a FITSRecord or FITSCard
convert: bool, optional
If True, convert strings. E.g. '3' gets
converted to 3 and "'hello'" gets converted
to 'hello' and 'T'/'F' to True/False. Default
is False.
"""
if (isinstance(record_in, dict) and
'name' in record_in and 'value' in record_in):
record = {}
record.update(record_in)
else:
record = FITSRecord(record_in)
# only append when this name already exists if it is
# a comment or history field, otherwise simply over-write
key = record['name'].upper()
key_exists = key in self._record_map
if not key_exists or key in ('COMMENT', 'HISTORY', 'CONTINUE'):
# append new record
self._record_list.append(record)
index = len(self._record_list)-1
self._index_map[key] = index
else:
# over-write existing
index = self._index_map[key]
self._record_list[index] = record
self._record_map[key] = record | [
"def",
"add_record",
"(",
"self",
",",
"record_in",
")",
":",
"if",
"(",
"isinstance",
"(",
"record_in",
",",
"dict",
")",
"and",
"'name'",
"in",
"record_in",
"and",
"'value'",
"in",
"record_in",
")",
":",
"record",
"=",
"{",
"}",
"record",
".",
"update",
"(",
"record_in",
")",
"else",
":",
"record",
"=",
"FITSRecord",
"(",
"record_in",
")",
"# only append when this name already exists if it is",
"# a comment or history field, otherwise simply over-write",
"key",
"=",
"record",
"[",
"'name'",
"]",
".",
"upper",
"(",
")",
"key_exists",
"=",
"key",
"in",
"self",
".",
"_record_map",
"if",
"not",
"key_exists",
"or",
"key",
"in",
"(",
"'COMMENT'",
",",
"'HISTORY'",
",",
"'CONTINUE'",
")",
":",
"# append new record",
"self",
".",
"_record_list",
".",
"append",
"(",
"record",
")",
"index",
"=",
"len",
"(",
"self",
".",
"_record_list",
")",
"-",
"1",
"self",
".",
"_index_map",
"[",
"key",
"]",
"=",
"index",
"else",
":",
"# over-write existing",
"index",
"=",
"self",
".",
"_index_map",
"[",
"key",
"]",
"self",
".",
"_record_list",
"[",
"index",
"]",
"=",
"record",
"self",
".",
"_record_map",
"[",
"key",
"]",
"=",
"record"
] | 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 string
or a FITSRecord or FITSCard
convert: bool, optional
If True, convert strings. E.g. '3' gets
converted to 3 and "'hello'" gets converted
to 'hello' and 'T'/'F' to True/False. Default
is False. | [
"Add",
"a",
"new",
"record",
".",
"Strip",
"quotes",
"from",
"around",
"strings",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L133-L174 | train | 235,053 |
esheldon/fitsio | fitsio/header.py | FITSHDR.get_comment | 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:
return self._record_map[key]['comment'] | python | 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:
return self._record_map[key]['comment'] | [
"def",
"get_comment",
"(",
"self",
",",
"item",
")",
":",
"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",
":",
"return",
"self",
".",
"_record_map",
"[",
"key",
"]",
"[",
"'comment'",
"]"
] | Get the comment for the requested entry | [
"Get",
"the",
"comment",
"for",
"the",
"requested",
"entry"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L180-L191 | train | 235,054 |
esheldon/fitsio | fitsio/header.py | FITSHDR.delete | 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._record_list = [
r for r in self._record_list if r['name'] != name] | python | 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._record_list = [
r for r in self._record_list if r['name'] != name] | [
"def",
"delete",
"(",
"self",
",",
"name",
")",
":",
"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",
".",
"_record_list",
"=",
"[",
"r",
"for",
"r",
"in",
"self",
".",
"_record_list",
"if",
"r",
"[",
"'name'",
"]",
"!=",
"name",
"]"
] | Delete the specified entry if it exists. | [
"Delete",
"the",
"specified",
"entry",
"if",
"it",
"exists",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L205-L216 | train | 235,055 |
esheldon/fitsio | fitsio/header.py | FITSHDR.clean | 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 a table, so extra keywords will be cleaned
"""
rmnames = [
'SIMPLE', 'EXTEND', 'XTENSION', 'BITPIX', 'PCOUNT', 'GCOUNT',
'THEAP',
'EXTNAME',
'BLANK',
'ZQUANTIZ', 'ZDITHER0', 'ZIMAGE', 'ZCMPTYPE',
'ZSIMPLE', 'ZTENSION', 'ZPCOUNT', 'ZGCOUNT',
'ZBITPIX', 'ZEXTEND',
# 'FZTILELN','FZALGOR',
'CHECKSUM', 'DATASUM']
if is_table:
# these are not allowed in tables
rmnames += [
'BUNIT', 'BSCALE', 'BZERO',
]
self.delete(rmnames)
r = self._record_map.get('NAXIS', None)
if r is not None:
naxis = int(r['value'])
self.delete('NAXIS')
rmnames = ['NAXIS%d' % i for i in xrange(1, naxis+1)]
self.delete(rmnames)
r = self._record_map.get('ZNAXIS', None)
self.delete('ZNAXIS')
if r is not None:
znaxis = int(r['value'])
rmnames = ['ZNAXIS%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZTILE%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZNAME%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZVAL%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
r = self._record_map.get('TFIELDS', None)
if r is not None:
tfields = int(r['value'])
self.delete('TFIELDS')
if tfields > 0:
nbase = [
'TFORM', 'TTYPE', 'TDIM', 'TUNIT', 'TSCAL', 'TZERO',
'TNULL', 'TDISP', 'TDMIN', 'TDMAX', 'TDESC', 'TROTA',
'TRPIX', 'TRVAL', 'TDELT', 'TCUNI',
# 'FZALG'
]
for i in xrange(1, tfields+1):
names = ['%s%d' % (n, i) for n in nbase]
self.delete(names) | python | 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 a table, so extra keywords will be cleaned
"""
rmnames = [
'SIMPLE', 'EXTEND', 'XTENSION', 'BITPIX', 'PCOUNT', 'GCOUNT',
'THEAP',
'EXTNAME',
'BLANK',
'ZQUANTIZ', 'ZDITHER0', 'ZIMAGE', 'ZCMPTYPE',
'ZSIMPLE', 'ZTENSION', 'ZPCOUNT', 'ZGCOUNT',
'ZBITPIX', 'ZEXTEND',
# 'FZTILELN','FZALGOR',
'CHECKSUM', 'DATASUM']
if is_table:
# these are not allowed in tables
rmnames += [
'BUNIT', 'BSCALE', 'BZERO',
]
self.delete(rmnames)
r = self._record_map.get('NAXIS', None)
if r is not None:
naxis = int(r['value'])
self.delete('NAXIS')
rmnames = ['NAXIS%d' % i for i in xrange(1, naxis+1)]
self.delete(rmnames)
r = self._record_map.get('ZNAXIS', None)
self.delete('ZNAXIS')
if r is not None:
znaxis = int(r['value'])
rmnames = ['ZNAXIS%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZTILE%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZNAME%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
rmnames = ['ZVAL%d' % i for i in xrange(1, znaxis+1)]
self.delete(rmnames)
r = self._record_map.get('TFIELDS', None)
if r is not None:
tfields = int(r['value'])
self.delete('TFIELDS')
if tfields > 0:
nbase = [
'TFORM', 'TTYPE', 'TDIM', 'TUNIT', 'TSCAL', 'TZERO',
'TNULL', 'TDISP', 'TDMIN', 'TDMAX', 'TDESC', 'TROTA',
'TRPIX', 'TRVAL', 'TDELT', 'TCUNI',
# 'FZALG'
]
for i in xrange(1, tfields+1):
names = ['%s%d' % (n, i) for n in nbase]
self.delete(names) | [
"def",
"clean",
"(",
"self",
",",
"is_table",
"=",
"False",
")",
":",
"rmnames",
"=",
"[",
"'SIMPLE'",
",",
"'EXTEND'",
",",
"'XTENSION'",
",",
"'BITPIX'",
",",
"'PCOUNT'",
",",
"'GCOUNT'",
",",
"'THEAP'",
",",
"'EXTNAME'",
",",
"'BLANK'",
",",
"'ZQUANTIZ'",
",",
"'ZDITHER0'",
",",
"'ZIMAGE'",
",",
"'ZCMPTYPE'",
",",
"'ZSIMPLE'",
",",
"'ZTENSION'",
",",
"'ZPCOUNT'",
",",
"'ZGCOUNT'",
",",
"'ZBITPIX'",
",",
"'ZEXTEND'",
",",
"# 'FZTILELN','FZALGOR',",
"'CHECKSUM'",
",",
"'DATASUM'",
"]",
"if",
"is_table",
":",
"# these are not allowed in tables",
"rmnames",
"+=",
"[",
"'BUNIT'",
",",
"'BSCALE'",
",",
"'BZERO'",
",",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"r",
"=",
"self",
".",
"_record_map",
".",
"get",
"(",
"'NAXIS'",
",",
"None",
")",
"if",
"r",
"is",
"not",
"None",
":",
"naxis",
"=",
"int",
"(",
"r",
"[",
"'value'",
"]",
")",
"self",
".",
"delete",
"(",
"'NAXIS'",
")",
"rmnames",
"=",
"[",
"'NAXIS%d'",
"%",
"i",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"naxis",
"+",
"1",
")",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"r",
"=",
"self",
".",
"_record_map",
".",
"get",
"(",
"'ZNAXIS'",
",",
"None",
")",
"self",
".",
"delete",
"(",
"'ZNAXIS'",
")",
"if",
"r",
"is",
"not",
"None",
":",
"znaxis",
"=",
"int",
"(",
"r",
"[",
"'value'",
"]",
")",
"rmnames",
"=",
"[",
"'ZNAXIS%d'",
"%",
"i",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"znaxis",
"+",
"1",
")",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"rmnames",
"=",
"[",
"'ZTILE%d'",
"%",
"i",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"znaxis",
"+",
"1",
")",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"rmnames",
"=",
"[",
"'ZNAME%d'",
"%",
"i",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"znaxis",
"+",
"1",
")",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"rmnames",
"=",
"[",
"'ZVAL%d'",
"%",
"i",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"znaxis",
"+",
"1",
")",
"]",
"self",
".",
"delete",
"(",
"rmnames",
")",
"r",
"=",
"self",
".",
"_record_map",
".",
"get",
"(",
"'TFIELDS'",
",",
"None",
")",
"if",
"r",
"is",
"not",
"None",
":",
"tfields",
"=",
"int",
"(",
"r",
"[",
"'value'",
"]",
")",
"self",
".",
"delete",
"(",
"'TFIELDS'",
")",
"if",
"tfields",
">",
"0",
":",
"nbase",
"=",
"[",
"'TFORM'",
",",
"'TTYPE'",
",",
"'TDIM'",
",",
"'TUNIT'",
",",
"'TSCAL'",
",",
"'TZERO'",
",",
"'TNULL'",
",",
"'TDISP'",
",",
"'TDMIN'",
",",
"'TDMAX'",
",",
"'TDESC'",
",",
"'TROTA'",
",",
"'TRPIX'",
",",
"'TRVAL'",
",",
"'TDELT'",
",",
"'TCUNI'",
",",
"# 'FZALG'",
"]",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"tfields",
"+",
"1",
")",
":",
"names",
"=",
"[",
"'%s%d'",
"%",
"(",
"n",
",",
"i",
")",
"for",
"n",
"in",
"nbase",
"]",
"self",
".",
"delete",
"(",
"names",
")"
] | 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 a table, so extra keywords will be cleaned | [
"Remove",
"reserved",
"keywords",
"from",
"the",
"header",
"."
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L218-L288 | train | 235,056 |
esheldon/fitsio | fitsio/header.py | FITSHDR.get | def get(self, item, default_value=None):
"""
Get the requested header entry by keyword name
"""
found, name = self._contains_and_name(item)
if found:
return self._record_map[name]['value']
else:
return default_value | python | def get(self, item, default_value=None):
"""
Get the requested header entry by keyword name
"""
found, name = self._contains_and_name(item)
if found:
return self._record_map[name]['value']
else:
return default_value | [
"def",
"get",
"(",
"self",
",",
"item",
",",
"default_value",
"=",
"None",
")",
":",
"found",
",",
"name",
"=",
"self",
".",
"_contains_and_name",
"(",
"item",
")",
"if",
"found",
":",
"return",
"self",
".",
"_record_map",
"[",
"name",
"]",
"[",
"'value'",
"]",
"else",
":",
"return",
"default_value"
] | Get the requested header entry by keyword name | [
"Get",
"the",
"requested",
"header",
"entry",
"by",
"keyword",
"name"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L290-L299 | train | 235,057 |
esheldon/fitsio | fitsio/header.py | FITSHDR.next | def next(self):
"""
for iteration over the header entries
"""
if self._current < len(self._record_list):
rec = self._record_list[self._current]
key = rec['name']
self._current += 1
return key
else:
raise StopIteration | python | def next(self):
"""
for iteration over the header entries
"""
if self._current < len(self._record_list):
rec = self._record_list[self._current]
key = rec['name']
self._current += 1
return key
else:
raise StopIteration | [
"def",
"next",
"(",
"self",
")",
":",
"if",
"self",
".",
"_current",
"<",
"len",
"(",
"self",
".",
"_record_list",
")",
":",
"rec",
"=",
"self",
".",
"_record_list",
"[",
"self",
".",
"_current",
"]",
"key",
"=",
"rec",
"[",
"'name'",
"]",
"self",
".",
"_current",
"+=",
"1",
"return",
"key",
"else",
":",
"raise",
"StopIteration"
] | for iteration over the header entries | [
"for",
"iteration",
"over",
"the",
"header",
"entries"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L359-L369 | train | 235,058 |
esheldon/fitsio | fitsio/header.py | FITSRecord.set_record | def set_record(self, record, **kw):
"""
check the record is valid and set keys in the dict
parameters
----------
record: string
Dict representing a record or a string representing a FITS header
card
"""
if isstring(record):
card = FITSCard(record)
self.update(card)
self.verify()
else:
if isinstance(record, FITSRecord):
self.update(record)
elif isinstance(record, dict):
if 'name' in record and 'value' in record:
self.update(record)
elif 'card_string' in record:
self.set_record(record['card_string'])
else:
raise ValueError('record must have name,value fields '
'or a card_string field')
else:
raise ValueError("record must be a string card or "
"dictionary or FITSRecord") | python | def set_record(self, record, **kw):
"""
check the record is valid and set keys in the dict
parameters
----------
record: string
Dict representing a record or a string representing a FITS header
card
"""
if isstring(record):
card = FITSCard(record)
self.update(card)
self.verify()
else:
if isinstance(record, FITSRecord):
self.update(record)
elif isinstance(record, dict):
if 'name' in record and 'value' in record:
self.update(record)
elif 'card_string' in record:
self.set_record(record['card_string'])
else:
raise ValueError('record must have name,value fields '
'or a card_string field')
else:
raise ValueError("record must be a string card or "
"dictionary or FITSRecord") | [
"def",
"set_record",
"(",
"self",
",",
"record",
",",
"*",
"*",
"kw",
")",
":",
"if",
"isstring",
"(",
"record",
")",
":",
"card",
"=",
"FITSCard",
"(",
"record",
")",
"self",
".",
"update",
"(",
"card",
")",
"self",
".",
"verify",
"(",
")",
"else",
":",
"if",
"isinstance",
"(",
"record",
",",
"FITSRecord",
")",
":",
"self",
".",
"update",
"(",
"record",
")",
"elif",
"isinstance",
"(",
"record",
",",
"dict",
")",
":",
"if",
"'name'",
"in",
"record",
"and",
"'value'",
"in",
"record",
":",
"self",
".",
"update",
"(",
"record",
")",
"elif",
"'card_string'",
"in",
"record",
":",
"self",
".",
"set_record",
"(",
"record",
"[",
"'card_string'",
"]",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'record must have name,value fields '",
"'or a card_string field'",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"record must be a string card or \"",
"\"dictionary or FITSRecord\"",
")"
] | check the record is valid and set keys in the dict
parameters
----------
record: string
Dict representing a record or a string representing a FITS header
card | [
"check",
"the",
"record",
"is",
"valid",
"and",
"set",
"keys",
"in",
"the",
"dict"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L477-L510 | train | 235,059 |
esheldon/fitsio | fitsio/header.py | FITSCard._check_equals | def _check_equals(self):
"""
check for = in position 8, set attribute _has_equals
"""
card_string = self['card_string']
if len(card_string) < 9:
self._has_equals = False
elif card_string[8] == '=':
self._has_equals = True
else:
self._has_equals = False | python | def _check_equals(self):
"""
check for = in position 8, set attribute _has_equals
"""
card_string = self['card_string']
if len(card_string) < 9:
self._has_equals = False
elif card_string[8] == '=':
self._has_equals = True
else:
self._has_equals = False | [
"def",
"_check_equals",
"(",
"self",
")",
":",
"card_string",
"=",
"self",
"[",
"'card_string'",
"]",
"if",
"len",
"(",
"card_string",
")",
"<",
"9",
":",
"self",
".",
"_has_equals",
"=",
"False",
"elif",
"card_string",
"[",
"8",
"]",
"==",
"'='",
":",
"self",
".",
"_has_equals",
"=",
"True",
"else",
":",
"self",
".",
"_has_equals",
"=",
"False"
] | check for = in position 8, set attribute _has_equals | [
"check",
"for",
"=",
"in",
"position",
"8",
"set",
"attribute",
"_has_equals"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L588-L598 | train | 235,060 |
esheldon/fitsio | fitsio/header.py | FITSCard._convert_value | def _convert_value(self, value_orig):
"""
things like 6 and 1.25 are converted with ast.literal_value
Things like 'hello' are stripped of quotes
"""
import ast
if value_orig is None:
return value_orig
if value_orig.startswith("'") and value_orig.endswith("'"):
value = value_orig[1:-1]
else:
try:
avalue = ast.parse(value_orig).body[0].value
if isinstance(avalue, ast.BinOp):
# this is probably a string that happens to look like
# a binary operation, e.g. '25-3'
value = value_orig
else:
value = ast.literal_eval(value_orig)
except Exception:
value = self._convert_string(value_orig)
if isinstance(value, int) and '_' in value_orig:
value = value_orig
return value | python | def _convert_value(self, value_orig):
"""
things like 6 and 1.25 are converted with ast.literal_value
Things like 'hello' are stripped of quotes
"""
import ast
if value_orig is None:
return value_orig
if value_orig.startswith("'") and value_orig.endswith("'"):
value = value_orig[1:-1]
else:
try:
avalue = ast.parse(value_orig).body[0].value
if isinstance(avalue, ast.BinOp):
# this is probably a string that happens to look like
# a binary operation, e.g. '25-3'
value = value_orig
else:
value = ast.literal_eval(value_orig)
except Exception:
value = self._convert_string(value_orig)
if isinstance(value, int) and '_' in value_orig:
value = value_orig
return value | [
"def",
"_convert_value",
"(",
"self",
",",
"value_orig",
")",
":",
"import",
"ast",
"if",
"value_orig",
"is",
"None",
":",
"return",
"value_orig",
"if",
"value_orig",
".",
"startswith",
"(",
"\"'\"",
")",
"and",
"value_orig",
".",
"endswith",
"(",
"\"'\"",
")",
":",
"value",
"=",
"value_orig",
"[",
"1",
":",
"-",
"1",
"]",
"else",
":",
"try",
":",
"avalue",
"=",
"ast",
".",
"parse",
"(",
"value_orig",
")",
".",
"body",
"[",
"0",
"]",
".",
"value",
"if",
"isinstance",
"(",
"avalue",
",",
"ast",
".",
"BinOp",
")",
":",
"# this is probably a string that happens to look like",
"# a binary operation, e.g. '25-3'",
"value",
"=",
"value_orig",
"else",
":",
"value",
"=",
"ast",
".",
"literal_eval",
"(",
"value_orig",
")",
"except",
"Exception",
":",
"value",
"=",
"self",
".",
"_convert_string",
"(",
"value_orig",
")",
"if",
"isinstance",
"(",
"value",
",",
"int",
")",
"and",
"'_'",
"in",
"value_orig",
":",
"value",
"=",
"value_orig",
"return",
"value"
] | things like 6 and 1.25 are converted with ast.literal_value
Things like 'hello' are stripped of quotes | [
"things",
"like",
"6",
"and",
"1",
".",
"25",
"are",
"converted",
"with",
"ast",
".",
"literal_value"
] | a6f07919f457a282fe240adad9d2c30906b71a15 | https://github.com/esheldon/fitsio/blob/a6f07919f457a282fe240adad9d2c30906b71a15/fitsio/header.py#L641-L669 | train | 235,061 |
sanger-pathogens/ariba | ariba/cluster.py | Cluster._make_reads_for_assembly | def _make_reads_for_assembly(number_of_wanted_reads, total_reads, reads_in1, reads_in2, reads_out1, reads_out2, random_seed=None):
'''Makes fastq files that are random subset of input files. Returns total number of reads in output files.
If the number of wanted reads is >= total reads, then just makes symlinks instead of making
new copies of the input files.'''
random.seed(random_seed)
if number_of_wanted_reads < total_reads:
reads_written = 0
percent_wanted = 100 * number_of_wanted_reads / total_reads
file_reader1 = pyfastaq.sequences.file_reader(reads_in1)
file_reader2 = pyfastaq.sequences.file_reader(reads_in2)
out1 = pyfastaq.utils.open_file_write(reads_out1)
out2 = pyfastaq.utils.open_file_write(reads_out2)
for read1 in file_reader1:
try:
read2 = next(file_reader2)
except StopIteration:
pyfastaq.utils.close(out1)
pyfastaq.utils.close(out2)
raise Error('Error subsetting reads. No mate found for read ' + read1.id)
if random.randint(0, 100) <= percent_wanted:
print(read1, file=out1)
print(read2, file=out2)
reads_written += 2
pyfastaq.utils.close(out1)
pyfastaq.utils.close(out2)
return reads_written
else:
os.symlink(reads_in1, reads_out1)
os.symlink(reads_in2, reads_out2)
return total_reads | python | def _make_reads_for_assembly(number_of_wanted_reads, total_reads, reads_in1, reads_in2, reads_out1, reads_out2, random_seed=None):
'''Makes fastq files that are random subset of input files. Returns total number of reads in output files.
If the number of wanted reads is >= total reads, then just makes symlinks instead of making
new copies of the input files.'''
random.seed(random_seed)
if number_of_wanted_reads < total_reads:
reads_written = 0
percent_wanted = 100 * number_of_wanted_reads / total_reads
file_reader1 = pyfastaq.sequences.file_reader(reads_in1)
file_reader2 = pyfastaq.sequences.file_reader(reads_in2)
out1 = pyfastaq.utils.open_file_write(reads_out1)
out2 = pyfastaq.utils.open_file_write(reads_out2)
for read1 in file_reader1:
try:
read2 = next(file_reader2)
except StopIteration:
pyfastaq.utils.close(out1)
pyfastaq.utils.close(out2)
raise Error('Error subsetting reads. No mate found for read ' + read1.id)
if random.randint(0, 100) <= percent_wanted:
print(read1, file=out1)
print(read2, file=out2)
reads_written += 2
pyfastaq.utils.close(out1)
pyfastaq.utils.close(out2)
return reads_written
else:
os.symlink(reads_in1, reads_out1)
os.symlink(reads_in2, reads_out2)
return total_reads | [
"def",
"_make_reads_for_assembly",
"(",
"number_of_wanted_reads",
",",
"total_reads",
",",
"reads_in1",
",",
"reads_in2",
",",
"reads_out1",
",",
"reads_out2",
",",
"random_seed",
"=",
"None",
")",
":",
"random",
".",
"seed",
"(",
"random_seed",
")",
"if",
"number_of_wanted_reads",
"<",
"total_reads",
":",
"reads_written",
"=",
"0",
"percent_wanted",
"=",
"100",
"*",
"number_of_wanted_reads",
"/",
"total_reads",
"file_reader1",
"=",
"pyfastaq",
".",
"sequences",
".",
"file_reader",
"(",
"reads_in1",
")",
"file_reader2",
"=",
"pyfastaq",
".",
"sequences",
".",
"file_reader",
"(",
"reads_in2",
")",
"out1",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_write",
"(",
"reads_out1",
")",
"out2",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_write",
"(",
"reads_out2",
")",
"for",
"read1",
"in",
"file_reader1",
":",
"try",
":",
"read2",
"=",
"next",
"(",
"file_reader2",
")",
"except",
"StopIteration",
":",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"out1",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"out2",
")",
"raise",
"Error",
"(",
"'Error subsetting reads. No mate found for read '",
"+",
"read1",
".",
"id",
")",
"if",
"random",
".",
"randint",
"(",
"0",
",",
"100",
")",
"<=",
"percent_wanted",
":",
"print",
"(",
"read1",
",",
"file",
"=",
"out1",
")",
"print",
"(",
"read2",
",",
"file",
"=",
"out2",
")",
"reads_written",
"+=",
"2",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"out1",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"out2",
")",
"return",
"reads_written",
"else",
":",
"os",
".",
"symlink",
"(",
"reads_in1",
",",
"reads_out1",
")",
"os",
".",
"symlink",
"(",
"reads_in2",
",",
"reads_out2",
")",
"return",
"total_reads"
] | Makes fastq files that are random subset of input files. Returns total number of reads in output files.
If the number of wanted reads is >= total reads, then just makes symlinks instead of making
new copies of the input files. | [
"Makes",
"fastq",
"files",
"that",
"are",
"random",
"subset",
"of",
"input",
"files",
".",
"Returns",
"total",
"number",
"of",
"reads",
"in",
"output",
"files",
".",
"If",
"the",
"number",
"of",
"wanted",
"reads",
"is",
">",
"=",
"total",
"reads",
"then",
"just",
"makes",
"symlinks",
"instead",
"of",
"making",
"new",
"copies",
"of",
"the",
"input",
"files",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/cluster.py#L262-L295 | train | 235,062 |
sanger-pathogens/ariba | ariba/tb.py | load_mutations | def load_mutations(gene_coords, mutation_to_drug_json, variants_txt, upstream_before=100):
'''Load mutations from "mykrobe-style" files. mutation_to_drug_json is json file
of mutation -> list of drugs. variants_txt is text file of variants used my mykrobe's
make probes. gene_coords should be dict of gene coords made by the function
genbank_to_gene_coords'''
with open(mutation_to_drug_json) as f:
drug_data = json.load(f)
mutations = []
genes_with_indels = set()
genes_need_upstream = set()
genes_non_upstream = set()
with open(variants_txt) as f:
for line in f:
gene, variant, d_or_p = line.rstrip().split('\t')
coding = 0 if gene == 'rrs' else 1
d = {'gene': gene, 'var': variant, 'coding': coding, 'upstream': False}
drug_data_key = d['gene'] + '_' + d['var']
if drug_data_key not in drug_data:
print('KEY', drug_data_key, 'NOT FOUND', file=sys.stderr)
else:
d['drugs'] = ','.join(sorted(drug_data[drug_data_key]))
if d_or_p == 'DNA' and gene != 'rrs':
assert gene != 'rrs'
re_match = re.match('([ACGT]+)(-?[0-9]+)([ACGTX]+)', d['var'])
try:
ref, pos, alt = re_match.groups()
except:
print('regex error:', d['var'], file=sys.stderr)
continue
pos = int(pos)
if len(ref) != len(alt):
genes_with_indels.add(d['gene'])
continue
elif pos > 0:
#print('ignoring synonymous change (not implemented):', d['gene'], d['var'], d['drugs'], file=sys.stderr)
continue
elif pos < 0:
this_gene_coords = gene_coords[d['gene']]
d['upstream'] = True
if this_gene_coords['start'] < this_gene_coords['end']:
variant_pos_in_output_seq = upstream_before + pos + 1
else:
variant_pos_in_output_seq = upstream_before + pos + 1
assert variant_pos_in_output_seq > 0
d['var'] = ref + str(variant_pos_in_output_seq) + alt
d['original_mutation'] = variant
genes_need_upstream.add(d['gene'])
elif pos == 0:
print('Zero coord!', d, file=sys.stderr)
continue
else:
print('deal with?', d, file=sys.stderr)
continue
mutations.append(d)
if not d['upstream']:
genes_non_upstream.add(d['gene'])
return mutations, genes_with_indels, genes_need_upstream, genes_non_upstream | python | def load_mutations(gene_coords, mutation_to_drug_json, variants_txt, upstream_before=100):
'''Load mutations from "mykrobe-style" files. mutation_to_drug_json is json file
of mutation -> list of drugs. variants_txt is text file of variants used my mykrobe's
make probes. gene_coords should be dict of gene coords made by the function
genbank_to_gene_coords'''
with open(mutation_to_drug_json) as f:
drug_data = json.load(f)
mutations = []
genes_with_indels = set()
genes_need_upstream = set()
genes_non_upstream = set()
with open(variants_txt) as f:
for line in f:
gene, variant, d_or_p = line.rstrip().split('\t')
coding = 0 if gene == 'rrs' else 1
d = {'gene': gene, 'var': variant, 'coding': coding, 'upstream': False}
drug_data_key = d['gene'] + '_' + d['var']
if drug_data_key not in drug_data:
print('KEY', drug_data_key, 'NOT FOUND', file=sys.stderr)
else:
d['drugs'] = ','.join(sorted(drug_data[drug_data_key]))
if d_or_p == 'DNA' and gene != 'rrs':
assert gene != 'rrs'
re_match = re.match('([ACGT]+)(-?[0-9]+)([ACGTX]+)', d['var'])
try:
ref, pos, alt = re_match.groups()
except:
print('regex error:', d['var'], file=sys.stderr)
continue
pos = int(pos)
if len(ref) != len(alt):
genes_with_indels.add(d['gene'])
continue
elif pos > 0:
#print('ignoring synonymous change (not implemented):', d['gene'], d['var'], d['drugs'], file=sys.stderr)
continue
elif pos < 0:
this_gene_coords = gene_coords[d['gene']]
d['upstream'] = True
if this_gene_coords['start'] < this_gene_coords['end']:
variant_pos_in_output_seq = upstream_before + pos + 1
else:
variant_pos_in_output_seq = upstream_before + pos + 1
assert variant_pos_in_output_seq > 0
d['var'] = ref + str(variant_pos_in_output_seq) + alt
d['original_mutation'] = variant
genes_need_upstream.add(d['gene'])
elif pos == 0:
print('Zero coord!', d, file=sys.stderr)
continue
else:
print('deal with?', d, file=sys.stderr)
continue
mutations.append(d)
if not d['upstream']:
genes_non_upstream.add(d['gene'])
return mutations, genes_with_indels, genes_need_upstream, genes_non_upstream | [
"def",
"load_mutations",
"(",
"gene_coords",
",",
"mutation_to_drug_json",
",",
"variants_txt",
",",
"upstream_before",
"=",
"100",
")",
":",
"with",
"open",
"(",
"mutation_to_drug_json",
")",
"as",
"f",
":",
"drug_data",
"=",
"json",
".",
"load",
"(",
"f",
")",
"mutations",
"=",
"[",
"]",
"genes_with_indels",
"=",
"set",
"(",
")",
"genes_need_upstream",
"=",
"set",
"(",
")",
"genes_non_upstream",
"=",
"set",
"(",
")",
"with",
"open",
"(",
"variants_txt",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"gene",
",",
"variant",
",",
"d_or_p",
"=",
"line",
".",
"rstrip",
"(",
")",
".",
"split",
"(",
"'\\t'",
")",
"coding",
"=",
"0",
"if",
"gene",
"==",
"'rrs'",
"else",
"1",
"d",
"=",
"{",
"'gene'",
":",
"gene",
",",
"'var'",
":",
"variant",
",",
"'coding'",
":",
"coding",
",",
"'upstream'",
":",
"False",
"}",
"drug_data_key",
"=",
"d",
"[",
"'gene'",
"]",
"+",
"'_'",
"+",
"d",
"[",
"'var'",
"]",
"if",
"drug_data_key",
"not",
"in",
"drug_data",
":",
"print",
"(",
"'KEY'",
",",
"drug_data_key",
",",
"'NOT FOUND'",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"else",
":",
"d",
"[",
"'drugs'",
"]",
"=",
"','",
".",
"join",
"(",
"sorted",
"(",
"drug_data",
"[",
"drug_data_key",
"]",
")",
")",
"if",
"d_or_p",
"==",
"'DNA'",
"and",
"gene",
"!=",
"'rrs'",
":",
"assert",
"gene",
"!=",
"'rrs'",
"re_match",
"=",
"re",
".",
"match",
"(",
"'([ACGT]+)(-?[0-9]+)([ACGTX]+)'",
",",
"d",
"[",
"'var'",
"]",
")",
"try",
":",
"ref",
",",
"pos",
",",
"alt",
"=",
"re_match",
".",
"groups",
"(",
")",
"except",
":",
"print",
"(",
"'regex error:'",
",",
"d",
"[",
"'var'",
"]",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"continue",
"pos",
"=",
"int",
"(",
"pos",
")",
"if",
"len",
"(",
"ref",
")",
"!=",
"len",
"(",
"alt",
")",
":",
"genes_with_indels",
".",
"add",
"(",
"d",
"[",
"'gene'",
"]",
")",
"continue",
"elif",
"pos",
">",
"0",
":",
"#print('ignoring synonymous change (not implemented):', d['gene'], d['var'], d['drugs'], file=sys.stderr)",
"continue",
"elif",
"pos",
"<",
"0",
":",
"this_gene_coords",
"=",
"gene_coords",
"[",
"d",
"[",
"'gene'",
"]",
"]",
"d",
"[",
"'upstream'",
"]",
"=",
"True",
"if",
"this_gene_coords",
"[",
"'start'",
"]",
"<",
"this_gene_coords",
"[",
"'end'",
"]",
":",
"variant_pos_in_output_seq",
"=",
"upstream_before",
"+",
"pos",
"+",
"1",
"else",
":",
"variant_pos_in_output_seq",
"=",
"upstream_before",
"+",
"pos",
"+",
"1",
"assert",
"variant_pos_in_output_seq",
">",
"0",
"d",
"[",
"'var'",
"]",
"=",
"ref",
"+",
"str",
"(",
"variant_pos_in_output_seq",
")",
"+",
"alt",
"d",
"[",
"'original_mutation'",
"]",
"=",
"variant",
"genes_need_upstream",
".",
"add",
"(",
"d",
"[",
"'gene'",
"]",
")",
"elif",
"pos",
"==",
"0",
":",
"print",
"(",
"'Zero coord!'",
",",
"d",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"continue",
"else",
":",
"print",
"(",
"'deal with?'",
",",
"d",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"continue",
"mutations",
".",
"append",
"(",
"d",
")",
"if",
"not",
"d",
"[",
"'upstream'",
"]",
":",
"genes_non_upstream",
".",
"add",
"(",
"d",
"[",
"'gene'",
"]",
")",
"return",
"mutations",
",",
"genes_with_indels",
",",
"genes_need_upstream",
",",
"genes_non_upstream"
] | Load mutations from "mykrobe-style" files. mutation_to_drug_json is json file
of mutation -> list of drugs. variants_txt is text file of variants used my mykrobe's
make probes. gene_coords should be dict of gene coords made by the function
genbank_to_gene_coords | [
"Load",
"mutations",
"from",
"mykrobe",
"-",
"style",
"files",
".",
"mutation_to_drug_json",
"is",
"json",
"file",
"of",
"mutation",
"-",
">",
"list",
"of",
"drugs",
".",
"variants_txt",
"is",
"text",
"file",
"of",
"variants",
"used",
"my",
"mykrobe",
"s",
"make",
"probes",
".",
"gene_coords",
"should",
"be",
"dict",
"of",
"gene",
"coords",
"made",
"by",
"the",
"function",
"genbank_to_gene_coords"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/tb.py#L80-L142 | train | 235,063 |
sanger-pathogens/ariba | ariba/tb.py | write_prepareref_fasta_file | def write_prepareref_fasta_file(outfile, gene_coords, genes_need_upstream, genes_non_upstream, upstream_before=100, upstream_after=100):
'''Writes fasta file to be used with -f option of prepareref'''
tmp_dict = {}
fasta_in = os.path.join(data_dir, 'NC_000962.3.fa.gz')
pyfastaq.tasks.file_to_dict(fasta_in, tmp_dict)
ref_seq = tmp_dict['NC_000962.3']
with open(outfile, 'w') as f:
for gene in genes_non_upstream:
start = gene_coords[gene]['start']
end = gene_coords[gene]['end']
if start < end:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start:end+1])
else:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[end:start+1])
gene_fa.revcomp()
print(gene_fa, file=f)
for gene in genes_need_upstream:
start = gene_coords[gene]['start']
end = gene_coords[gene]['end']
if start < end:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start - upstream_before:start + upstream_after])
else:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start - upstream_after + 1:start + upstream_before + 1])
gene_fa.revcomp()
gene_fa.id += '_upstream'
print(gene_fa, file=f) | python | def write_prepareref_fasta_file(outfile, gene_coords, genes_need_upstream, genes_non_upstream, upstream_before=100, upstream_after=100):
'''Writes fasta file to be used with -f option of prepareref'''
tmp_dict = {}
fasta_in = os.path.join(data_dir, 'NC_000962.3.fa.gz')
pyfastaq.tasks.file_to_dict(fasta_in, tmp_dict)
ref_seq = tmp_dict['NC_000962.3']
with open(outfile, 'w') as f:
for gene in genes_non_upstream:
start = gene_coords[gene]['start']
end = gene_coords[gene]['end']
if start < end:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start:end+1])
else:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[end:start+1])
gene_fa.revcomp()
print(gene_fa, file=f)
for gene in genes_need_upstream:
start = gene_coords[gene]['start']
end = gene_coords[gene]['end']
if start < end:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start - upstream_before:start + upstream_after])
else:
gene_fa = pyfastaq.sequences.Fasta(gene, ref_seq[start - upstream_after + 1:start + upstream_before + 1])
gene_fa.revcomp()
gene_fa.id += '_upstream'
print(gene_fa, file=f) | [
"def",
"write_prepareref_fasta_file",
"(",
"outfile",
",",
"gene_coords",
",",
"genes_need_upstream",
",",
"genes_non_upstream",
",",
"upstream_before",
"=",
"100",
",",
"upstream_after",
"=",
"100",
")",
":",
"tmp_dict",
"=",
"{",
"}",
"fasta_in",
"=",
"os",
".",
"path",
".",
"join",
"(",
"data_dir",
",",
"'NC_000962.3.fa.gz'",
")",
"pyfastaq",
".",
"tasks",
".",
"file_to_dict",
"(",
"fasta_in",
",",
"tmp_dict",
")",
"ref_seq",
"=",
"tmp_dict",
"[",
"'NC_000962.3'",
"]",
"with",
"open",
"(",
"outfile",
",",
"'w'",
")",
"as",
"f",
":",
"for",
"gene",
"in",
"genes_non_upstream",
":",
"start",
"=",
"gene_coords",
"[",
"gene",
"]",
"[",
"'start'",
"]",
"end",
"=",
"gene_coords",
"[",
"gene",
"]",
"[",
"'end'",
"]",
"if",
"start",
"<",
"end",
":",
"gene_fa",
"=",
"pyfastaq",
".",
"sequences",
".",
"Fasta",
"(",
"gene",
",",
"ref_seq",
"[",
"start",
":",
"end",
"+",
"1",
"]",
")",
"else",
":",
"gene_fa",
"=",
"pyfastaq",
".",
"sequences",
".",
"Fasta",
"(",
"gene",
",",
"ref_seq",
"[",
"end",
":",
"start",
"+",
"1",
"]",
")",
"gene_fa",
".",
"revcomp",
"(",
")",
"print",
"(",
"gene_fa",
",",
"file",
"=",
"f",
")",
"for",
"gene",
"in",
"genes_need_upstream",
":",
"start",
"=",
"gene_coords",
"[",
"gene",
"]",
"[",
"'start'",
"]",
"end",
"=",
"gene_coords",
"[",
"gene",
"]",
"[",
"'end'",
"]",
"if",
"start",
"<",
"end",
":",
"gene_fa",
"=",
"pyfastaq",
".",
"sequences",
".",
"Fasta",
"(",
"gene",
",",
"ref_seq",
"[",
"start",
"-",
"upstream_before",
":",
"start",
"+",
"upstream_after",
"]",
")",
"else",
":",
"gene_fa",
"=",
"pyfastaq",
".",
"sequences",
".",
"Fasta",
"(",
"gene",
",",
"ref_seq",
"[",
"start",
"-",
"upstream_after",
"+",
"1",
":",
"start",
"+",
"upstream_before",
"+",
"1",
"]",
")",
"gene_fa",
".",
"revcomp",
"(",
")",
"gene_fa",
".",
"id",
"+=",
"'_upstream'",
"print",
"(",
"gene_fa",
",",
"file",
"=",
"f",
")"
] | Writes fasta file to be used with -f option of prepareref | [
"Writes",
"fasta",
"file",
"to",
"be",
"used",
"with",
"-",
"f",
"option",
"of",
"prepareref"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/tb.py#L145-L174 | train | 235,064 |
sanger-pathogens/ariba | ariba/summary_cluster.py | SummaryCluster._get_known_noncoding_het_snp | def _get_known_noncoding_het_snp(data_dict):
'''If ref is coding, return None. If the data dict has a known snp, and
samtools made a call, then return the string ref_name_change and the
% of reads supporting the variant type. If noncoding, but no
samtools call, then return None'''
if data_dict['gene'] == '1':
return None
if data_dict['known_var'] == '1' and data_dict['ref_ctg_effect'] == 'SNP' \
and data_dict['smtls_nts'] != '.' and ';' not in data_dict['smtls_nts']:
nucleotides = data_dict['smtls_nts'].split(',')
depths = data_dict['smtls_nts_depth'].split(',')
if len(nucleotides) != len(depths):
raise Error('Mismatch in number of inferred nucleotides from ctg_nt, smtls_nts, smtls_nts_depth columns. Cannot continue\n' + str(data_dict))
try:
var_nucleotide = data_dict['known_var_change'][-1]
depths = [int(x) for x in depths]
nuc_to_depth = dict(zip(nucleotides, depths))
total_depth = sum(depths)
var_depth = nuc_to_depth.get(var_nucleotide, 0)
percent_depth = round(100 * var_depth / total_depth, 1)
except:
return None
return data_dict['known_var_change'], percent_depth
else:
return None | python | def _get_known_noncoding_het_snp(data_dict):
'''If ref is coding, return None. If the data dict has a known snp, and
samtools made a call, then return the string ref_name_change and the
% of reads supporting the variant type. If noncoding, but no
samtools call, then return None'''
if data_dict['gene'] == '1':
return None
if data_dict['known_var'] == '1' and data_dict['ref_ctg_effect'] == 'SNP' \
and data_dict['smtls_nts'] != '.' and ';' not in data_dict['smtls_nts']:
nucleotides = data_dict['smtls_nts'].split(',')
depths = data_dict['smtls_nts_depth'].split(',')
if len(nucleotides) != len(depths):
raise Error('Mismatch in number of inferred nucleotides from ctg_nt, smtls_nts, smtls_nts_depth columns. Cannot continue\n' + str(data_dict))
try:
var_nucleotide = data_dict['known_var_change'][-1]
depths = [int(x) for x in depths]
nuc_to_depth = dict(zip(nucleotides, depths))
total_depth = sum(depths)
var_depth = nuc_to_depth.get(var_nucleotide, 0)
percent_depth = round(100 * var_depth / total_depth, 1)
except:
return None
return data_dict['known_var_change'], percent_depth
else:
return None | [
"def",
"_get_known_noncoding_het_snp",
"(",
"data_dict",
")",
":",
"if",
"data_dict",
"[",
"'gene'",
"]",
"==",
"'1'",
":",
"return",
"None",
"if",
"data_dict",
"[",
"'known_var'",
"]",
"==",
"'1'",
"and",
"data_dict",
"[",
"'ref_ctg_effect'",
"]",
"==",
"'SNP'",
"and",
"data_dict",
"[",
"'smtls_nts'",
"]",
"!=",
"'.'",
"and",
"';'",
"not",
"in",
"data_dict",
"[",
"'smtls_nts'",
"]",
":",
"nucleotides",
"=",
"data_dict",
"[",
"'smtls_nts'",
"]",
".",
"split",
"(",
"','",
")",
"depths",
"=",
"data_dict",
"[",
"'smtls_nts_depth'",
"]",
".",
"split",
"(",
"','",
")",
"if",
"len",
"(",
"nucleotides",
")",
"!=",
"len",
"(",
"depths",
")",
":",
"raise",
"Error",
"(",
"'Mismatch in number of inferred nucleotides from ctg_nt, smtls_nts, smtls_nts_depth columns. Cannot continue\\n'",
"+",
"str",
"(",
"data_dict",
")",
")",
"try",
":",
"var_nucleotide",
"=",
"data_dict",
"[",
"'known_var_change'",
"]",
"[",
"-",
"1",
"]",
"depths",
"=",
"[",
"int",
"(",
"x",
")",
"for",
"x",
"in",
"depths",
"]",
"nuc_to_depth",
"=",
"dict",
"(",
"zip",
"(",
"nucleotides",
",",
"depths",
")",
")",
"total_depth",
"=",
"sum",
"(",
"depths",
")",
"var_depth",
"=",
"nuc_to_depth",
".",
"get",
"(",
"var_nucleotide",
",",
"0",
")",
"percent_depth",
"=",
"round",
"(",
"100",
"*",
"var_depth",
"/",
"total_depth",
",",
"1",
")",
"except",
":",
"return",
"None",
"return",
"data_dict",
"[",
"'known_var_change'",
"]",
",",
"percent_depth",
"else",
":",
"return",
"None"
] | If ref is coding, return None. If the data dict has a known snp, and
samtools made a call, then return the string ref_name_change and the
% of reads supporting the variant type. If noncoding, but no
samtools call, then return None | [
"If",
"ref",
"is",
"coding",
"return",
"None",
".",
"If",
"the",
"data",
"dict",
"has",
"a",
"known",
"snp",
"and",
"samtools",
"made",
"a",
"call",
"then",
"return",
"the",
"string",
"ref_name_change",
"and",
"the",
"%",
"of",
"reads",
"supporting",
"the",
"variant",
"type",
".",
"If",
"noncoding",
"but",
"no",
"samtools",
"call",
"then",
"return",
"None"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary_cluster.py#L236-L264 | train | 235,065 |
sanger-pathogens/ariba | ariba/summary_cluster.py | SummaryCluster._has_match | def _has_match(self, assembled_summary):
'''assembled_summary should be output of _to_cluster_summary_assembled'''
if assembled_summary.startswith('yes'):
if self.data[0]['var_only'] == '0' or self._to_cluster_summary_has_known_nonsynonymous(assembled_summary) == 'yes':
return 'yes'
else:
return 'no'
else:
return 'no' | python | def _has_match(self, assembled_summary):
'''assembled_summary should be output of _to_cluster_summary_assembled'''
if assembled_summary.startswith('yes'):
if self.data[0]['var_only'] == '0' or self._to_cluster_summary_has_known_nonsynonymous(assembled_summary) == 'yes':
return 'yes'
else:
return 'no'
else:
return 'no' | [
"def",
"_has_match",
"(",
"self",
",",
"assembled_summary",
")",
":",
"if",
"assembled_summary",
".",
"startswith",
"(",
"'yes'",
")",
":",
"if",
"self",
".",
"data",
"[",
"0",
"]",
"[",
"'var_only'",
"]",
"==",
"'0'",
"or",
"self",
".",
"_to_cluster_summary_has_known_nonsynonymous",
"(",
"assembled_summary",
")",
"==",
"'yes'",
":",
"return",
"'yes'",
"else",
":",
"return",
"'no'",
"else",
":",
"return",
"'no'"
] | assembled_summary should be output of _to_cluster_summary_assembled | [
"assembled_summary",
"should",
"be",
"output",
"of",
"_to_cluster_summary_assembled"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary_cluster.py#L298-L306 | train | 235,066 |
sanger-pathogens/ariba | ariba/summary_cluster.py | SummaryCluster.has_var_groups | def has_var_groups(self):
'''Returns a set of the variant group ids that this cluster has'''
ids = set()
for d in self.data:
if self._has_known_variant(d) != 'no' and d['var_group'] != '.':
ids.add(d['var_group'])
return ids | python | def has_var_groups(self):
'''Returns a set of the variant group ids that this cluster has'''
ids = set()
for d in self.data:
if self._has_known_variant(d) != 'no' and d['var_group'] != '.':
ids.add(d['var_group'])
return ids | [
"def",
"has_var_groups",
"(",
"self",
")",
":",
"ids",
"=",
"set",
"(",
")",
"for",
"d",
"in",
"self",
".",
"data",
":",
"if",
"self",
".",
"_has_known_variant",
"(",
"d",
")",
"!=",
"'no'",
"and",
"d",
"[",
"'var_group'",
"]",
"!=",
"'.'",
":",
"ids",
".",
"add",
"(",
"d",
"[",
"'var_group'",
"]",
")",
"return",
"ids"
] | Returns a set of the variant group ids that this cluster has | [
"Returns",
"a",
"set",
"of",
"the",
"variant",
"group",
"ids",
"that",
"this",
"cluster",
"has"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary_cluster.py#L309-L315 | train | 235,067 |
sanger-pathogens/ariba | ariba/summary_cluster.py | SummaryCluster.column_summary_data | def column_summary_data(self):
'''Returns a dictionary of column name -> value, for cluster-level results'''
assembled_summary = self._to_cluster_summary_assembled()
pct_id, read_depth = self._pc_id_and_read_depth_of_longest()
columns = {
'assembled': self._to_cluster_summary_assembled(),
'match': self._has_match(assembled_summary),
'ref_seq': self.ref_name,
'pct_id': str(pct_id),
'ctg_cov': str(read_depth),
'known_var': self._to_cluster_summary_has_known_nonsynonymous(assembled_summary),
'novel_var': self._to_cluster_summary_has_novel_nonsynonymous(assembled_summary)
}
return columns | python | def column_summary_data(self):
'''Returns a dictionary of column name -> value, for cluster-level results'''
assembled_summary = self._to_cluster_summary_assembled()
pct_id, read_depth = self._pc_id_and_read_depth_of_longest()
columns = {
'assembled': self._to_cluster_summary_assembled(),
'match': self._has_match(assembled_summary),
'ref_seq': self.ref_name,
'pct_id': str(pct_id),
'ctg_cov': str(read_depth),
'known_var': self._to_cluster_summary_has_known_nonsynonymous(assembled_summary),
'novel_var': self._to_cluster_summary_has_novel_nonsynonymous(assembled_summary)
}
return columns | [
"def",
"column_summary_data",
"(",
"self",
")",
":",
"assembled_summary",
"=",
"self",
".",
"_to_cluster_summary_assembled",
"(",
")",
"pct_id",
",",
"read_depth",
"=",
"self",
".",
"_pc_id_and_read_depth_of_longest",
"(",
")",
"columns",
"=",
"{",
"'assembled'",
":",
"self",
".",
"_to_cluster_summary_assembled",
"(",
")",
",",
"'match'",
":",
"self",
".",
"_has_match",
"(",
"assembled_summary",
")",
",",
"'ref_seq'",
":",
"self",
".",
"ref_name",
",",
"'pct_id'",
":",
"str",
"(",
"pct_id",
")",
",",
"'ctg_cov'",
":",
"str",
"(",
"read_depth",
")",
",",
"'known_var'",
":",
"self",
".",
"_to_cluster_summary_has_known_nonsynonymous",
"(",
"assembled_summary",
")",
",",
"'novel_var'",
":",
"self",
".",
"_to_cluster_summary_has_novel_nonsynonymous",
"(",
"assembled_summary",
")",
"}",
"return",
"columns"
] | Returns a dictionary of column name -> value, for cluster-level results | [
"Returns",
"a",
"dictionary",
"of",
"column",
"name",
"-",
">",
"value",
"for",
"cluster",
"-",
"level",
"results"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary_cluster.py#L318-L333 | train | 235,068 |
sanger-pathogens/ariba | ariba/common.py | cat_files | def cat_files(infiles, outfile):
'''Cats all files in list infiles into outfile'''
f_out = pyfastaq.utils.open_file_write(outfile)
for filename in infiles:
if os.path.exists(filename):
f_in = pyfastaq.utils.open_file_read(filename)
for line in f_in:
print(line, end='', file=f_out)
pyfastaq.utils.close(f_in)
pyfastaq.utils.close(f_out) | python | def cat_files(infiles, outfile):
'''Cats all files in list infiles into outfile'''
f_out = pyfastaq.utils.open_file_write(outfile)
for filename in infiles:
if os.path.exists(filename):
f_in = pyfastaq.utils.open_file_read(filename)
for line in f_in:
print(line, end='', file=f_out)
pyfastaq.utils.close(f_in)
pyfastaq.utils.close(f_out) | [
"def",
"cat_files",
"(",
"infiles",
",",
"outfile",
")",
":",
"f_out",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_write",
"(",
"outfile",
")",
"for",
"filename",
"in",
"infiles",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"filename",
")",
":",
"f_in",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_read",
"(",
"filename",
")",
"for",
"line",
"in",
"f_in",
":",
"print",
"(",
"line",
",",
"end",
"=",
"''",
",",
"file",
"=",
"f_out",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f_in",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f_out",
")"
] | Cats all files in list infiles into outfile | [
"Cats",
"all",
"files",
"in",
"list",
"infiles",
"into",
"outfile"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/common.py#L45-L56 | train | 235,069 |
sanger-pathogens/ariba | ariba/assembly.py | Assembly._check_spades_log_file | def _check_spades_log_file(logfile):
'''SPAdes can fail with a strange error. Stop everything if this happens'''
f = pyfastaq.utils.open_file_read(logfile)
for line in f:
if line.startswith('== Error == system call for:') and line.rstrip().endswith('finished abnormally, err code: -7'):
pyfastaq.utils.close(f)
print('Error running SPAdes. Cannot continue. This is the error from the log file', logfile, '...', file=sys.stderr)
print(line, file=sys.stderr)
raise Error('Fatal error ("err code: -7") running spades. Cannot continue')
pyfastaq.utils.close(f)
return True | python | def _check_spades_log_file(logfile):
'''SPAdes can fail with a strange error. Stop everything if this happens'''
f = pyfastaq.utils.open_file_read(logfile)
for line in f:
if line.startswith('== Error == system call for:') and line.rstrip().endswith('finished abnormally, err code: -7'):
pyfastaq.utils.close(f)
print('Error running SPAdes. Cannot continue. This is the error from the log file', logfile, '...', file=sys.stderr)
print(line, file=sys.stderr)
raise Error('Fatal error ("err code: -7") running spades. Cannot continue')
pyfastaq.utils.close(f)
return True | [
"def",
"_check_spades_log_file",
"(",
"logfile",
")",
":",
"f",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_read",
"(",
"logfile",
")",
"for",
"line",
"in",
"f",
":",
"if",
"line",
".",
"startswith",
"(",
"'== Error == system call for:'",
")",
"and",
"line",
".",
"rstrip",
"(",
")",
".",
"endswith",
"(",
"'finished abnormally, err code: -7'",
")",
":",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"print",
"(",
"'Error running SPAdes. Cannot continue. This is the error from the log file'",
",",
"logfile",
",",
"'...'",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"print",
"(",
"line",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"raise",
"Error",
"(",
"'Fatal error (\"err code: -7\") running spades. Cannot continue'",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"return",
"True"
] | SPAdes can fail with a strange error. Stop everything if this happens | [
"SPAdes",
"can",
"fail",
"with",
"a",
"strange",
"error",
".",
"Stop",
"everything",
"if",
"this",
"happens"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly.py#L104-L116 | train | 235,070 |
sanger-pathogens/ariba | ariba/assembly.py | Assembly._fix_contig_orientation | def _fix_contig_orientation(contigs_fa, ref_fa, outfile, min_id=90, min_length=20, breaklen=200):
'''Changes orientation of each contig to match the reference, when possible.
Returns a set of names of contigs that had hits in both orientations to the reference'''
if not os.path.exists(contigs_fa):
raise Error('Cannot fix orientation of assembly contigs because file not found: ' + contigs_fa)
tmp_coords = os.path.join(outfile + '.tmp.rename.coords')
pymummer.nucmer.Runner(
ref_fa,
contigs_fa,
tmp_coords,
min_id=min_id,
min_length=min_length,
breaklen=breaklen,
maxmatch=True,
).run()
to_revcomp = set()
not_revcomp = set()
file_reader = pymummer.coords_file.reader(tmp_coords)
for hit in file_reader:
if hit.on_same_strand():
not_revcomp.add(hit.qry_name)
else:
to_revcomp.add(hit.qry_name)
os.unlink(tmp_coords)
in_both = to_revcomp.intersection(not_revcomp)
f = pyfastaq.utils.open_file_write(outfile)
seq_reader = pyfastaq.sequences.file_reader(contigs_fa)
for seq in seq_reader:
if seq.id in to_revcomp and seq.id not in in_both:
seq.revcomp()
print(seq, file=f)
pyfastaq.utils.close(f)
return in_both | python | def _fix_contig_orientation(contigs_fa, ref_fa, outfile, min_id=90, min_length=20, breaklen=200):
'''Changes orientation of each contig to match the reference, when possible.
Returns a set of names of contigs that had hits in both orientations to the reference'''
if not os.path.exists(contigs_fa):
raise Error('Cannot fix orientation of assembly contigs because file not found: ' + contigs_fa)
tmp_coords = os.path.join(outfile + '.tmp.rename.coords')
pymummer.nucmer.Runner(
ref_fa,
contigs_fa,
tmp_coords,
min_id=min_id,
min_length=min_length,
breaklen=breaklen,
maxmatch=True,
).run()
to_revcomp = set()
not_revcomp = set()
file_reader = pymummer.coords_file.reader(tmp_coords)
for hit in file_reader:
if hit.on_same_strand():
not_revcomp.add(hit.qry_name)
else:
to_revcomp.add(hit.qry_name)
os.unlink(tmp_coords)
in_both = to_revcomp.intersection(not_revcomp)
f = pyfastaq.utils.open_file_write(outfile)
seq_reader = pyfastaq.sequences.file_reader(contigs_fa)
for seq in seq_reader:
if seq.id in to_revcomp and seq.id not in in_both:
seq.revcomp()
print(seq, file=f)
pyfastaq.utils.close(f)
return in_both | [
"def",
"_fix_contig_orientation",
"(",
"contigs_fa",
",",
"ref_fa",
",",
"outfile",
",",
"min_id",
"=",
"90",
",",
"min_length",
"=",
"20",
",",
"breaklen",
"=",
"200",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"contigs_fa",
")",
":",
"raise",
"Error",
"(",
"'Cannot fix orientation of assembly contigs because file not found: '",
"+",
"contigs_fa",
")",
"tmp_coords",
"=",
"os",
".",
"path",
".",
"join",
"(",
"outfile",
"+",
"'.tmp.rename.coords'",
")",
"pymummer",
".",
"nucmer",
".",
"Runner",
"(",
"ref_fa",
",",
"contigs_fa",
",",
"tmp_coords",
",",
"min_id",
"=",
"min_id",
",",
"min_length",
"=",
"min_length",
",",
"breaklen",
"=",
"breaklen",
",",
"maxmatch",
"=",
"True",
",",
")",
".",
"run",
"(",
")",
"to_revcomp",
"=",
"set",
"(",
")",
"not_revcomp",
"=",
"set",
"(",
")",
"file_reader",
"=",
"pymummer",
".",
"coords_file",
".",
"reader",
"(",
"tmp_coords",
")",
"for",
"hit",
"in",
"file_reader",
":",
"if",
"hit",
".",
"on_same_strand",
"(",
")",
":",
"not_revcomp",
".",
"add",
"(",
"hit",
".",
"qry_name",
")",
"else",
":",
"to_revcomp",
".",
"add",
"(",
"hit",
".",
"qry_name",
")",
"os",
".",
"unlink",
"(",
"tmp_coords",
")",
"in_both",
"=",
"to_revcomp",
".",
"intersection",
"(",
"not_revcomp",
")",
"f",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_write",
"(",
"outfile",
")",
"seq_reader",
"=",
"pyfastaq",
".",
"sequences",
".",
"file_reader",
"(",
"contigs_fa",
")",
"for",
"seq",
"in",
"seq_reader",
":",
"if",
"seq",
".",
"id",
"in",
"to_revcomp",
"and",
"seq",
".",
"id",
"not",
"in",
"in_both",
":",
"seq",
".",
"revcomp",
"(",
")",
"print",
"(",
"seq",
",",
"file",
"=",
"f",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"return",
"in_both"
] | Changes orientation of each contig to match the reference, when possible.
Returns a set of names of contigs that had hits in both orientations to the reference | [
"Changes",
"orientation",
"of",
"each",
"contig",
"to",
"match",
"the",
"reference",
"when",
"possible",
".",
"Returns",
"a",
"set",
"of",
"names",
"of",
"contigs",
"that",
"had",
"hits",
"in",
"both",
"orientations",
"to",
"the",
"reference"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly.py#L205-L242 | train | 235,071 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare._parse_nucmer_coords_file | def _parse_nucmer_coords_file(coords_file, ref_name):
'''Input is coords file made by self._run_nucmer. Reference should have one sequence only.
ref_name is name fo the reference sequence, to sanity check the coords file.
Returns dictionary. Key = assembly contig name. Value = list of nucmer hits to that contig'''
file_reader = pymummer.coords_file.reader(coords_file)
nucmer_hits = {}
for hit in file_reader:
assert hit.ref_name == ref_name
contig = hit.qry_name
if contig not in nucmer_hits:
nucmer_hits[contig] = []
nucmer_hits[contig].append(copy.copy(hit))
return nucmer_hits | python | def _parse_nucmer_coords_file(coords_file, ref_name):
'''Input is coords file made by self._run_nucmer. Reference should have one sequence only.
ref_name is name fo the reference sequence, to sanity check the coords file.
Returns dictionary. Key = assembly contig name. Value = list of nucmer hits to that contig'''
file_reader = pymummer.coords_file.reader(coords_file)
nucmer_hits = {}
for hit in file_reader:
assert hit.ref_name == ref_name
contig = hit.qry_name
if contig not in nucmer_hits:
nucmer_hits[contig] = []
nucmer_hits[contig].append(copy.copy(hit))
return nucmer_hits | [
"def",
"_parse_nucmer_coords_file",
"(",
"coords_file",
",",
"ref_name",
")",
":",
"file_reader",
"=",
"pymummer",
".",
"coords_file",
".",
"reader",
"(",
"coords_file",
")",
"nucmer_hits",
"=",
"{",
"}",
"for",
"hit",
"in",
"file_reader",
":",
"assert",
"hit",
".",
"ref_name",
"==",
"ref_name",
"contig",
"=",
"hit",
".",
"qry_name",
"if",
"contig",
"not",
"in",
"nucmer_hits",
":",
"nucmer_hits",
"[",
"contig",
"]",
"=",
"[",
"]",
"nucmer_hits",
"[",
"contig",
"]",
".",
"append",
"(",
"copy",
".",
"copy",
"(",
"hit",
")",
")",
"return",
"nucmer_hits"
] | Input is coords file made by self._run_nucmer. Reference should have one sequence only.
ref_name is name fo the reference sequence, to sanity check the coords file.
Returns dictionary. Key = assembly contig name. Value = list of nucmer hits to that contig | [
"Input",
"is",
"coords",
"file",
"made",
"by",
"self",
".",
"_run_nucmer",
".",
"Reference",
"should",
"have",
"one",
"sequence",
"only",
".",
"ref_name",
"is",
"name",
"fo",
"the",
"reference",
"sequence",
"to",
"sanity",
"check",
"the",
"coords",
"file",
".",
"Returns",
"dictionary",
".",
"Key",
"=",
"assembly",
"contig",
"name",
".",
"Value",
"=",
"list",
"of",
"nucmer",
"hits",
"to",
"that",
"contig"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L61-L74 | train | 235,072 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare._nucmer_hits_to_percent_identity | def _nucmer_hits_to_percent_identity(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = percent identity of hits to that contig'''
percent_identities = {}
max_lengths = {}
for contig in nucmer_hits:
max_length = -1
percent_identity = 0
for hit in nucmer_hits[contig]:
if hit.hit_length_qry > max_length:
max_length = hit.hit_length_qry
percent_identity = hit.percent_identity
percent_identities[contig] = percent_identity
return percent_identities | python | def _nucmer_hits_to_percent_identity(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = percent identity of hits to that contig'''
percent_identities = {}
max_lengths = {}
for contig in nucmer_hits:
max_length = -1
percent_identity = 0
for hit in nucmer_hits[contig]:
if hit.hit_length_qry > max_length:
max_length = hit.hit_length_qry
percent_identity = hit.percent_identity
percent_identities[contig] = percent_identity
return percent_identities | [
"def",
"_nucmer_hits_to_percent_identity",
"(",
"nucmer_hits",
")",
":",
"percent_identities",
"=",
"{",
"}",
"max_lengths",
"=",
"{",
"}",
"for",
"contig",
"in",
"nucmer_hits",
":",
"max_length",
"=",
"-",
"1",
"percent_identity",
"=",
"0",
"for",
"hit",
"in",
"nucmer_hits",
"[",
"contig",
"]",
":",
"if",
"hit",
".",
"hit_length_qry",
">",
"max_length",
":",
"max_length",
"=",
"hit",
".",
"hit_length_qry",
"percent_identity",
"=",
"hit",
".",
"percent_identity",
"percent_identities",
"[",
"contig",
"]",
"=",
"percent_identity",
"return",
"percent_identities"
] | Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = percent identity of hits to that contig | [
"Input",
"is",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
".",
"Returns",
"dictionary",
".",
"key",
"=",
"contig",
"name",
".",
"Value",
"=",
"percent",
"identity",
"of",
"hits",
"to",
"that",
"contig"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L78-L93 | train | 235,073 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare._nucmer_hits_to_assembly_coords | def _nucmer_hits_to_assembly_coords(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = list of coords that match
to the reference gene'''
coords = {}
for l in nucmer_hits.values():
for hit in l:
if hit.qry_name not in coords:
coords[hit.qry_name] = []
coords[hit.qry_name].append(hit.qry_coords())
for scaff in coords:
pyfastaq.intervals.merge_overlapping_in_list(coords[scaff])
return coords | python | def _nucmer_hits_to_assembly_coords(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = list of coords that match
to the reference gene'''
coords = {}
for l in nucmer_hits.values():
for hit in l:
if hit.qry_name not in coords:
coords[hit.qry_name] = []
coords[hit.qry_name].append(hit.qry_coords())
for scaff in coords:
pyfastaq.intervals.merge_overlapping_in_list(coords[scaff])
return coords | [
"def",
"_nucmer_hits_to_assembly_coords",
"(",
"nucmer_hits",
")",
":",
"coords",
"=",
"{",
"}",
"for",
"l",
"in",
"nucmer_hits",
".",
"values",
"(",
")",
":",
"for",
"hit",
"in",
"l",
":",
"if",
"hit",
".",
"qry_name",
"not",
"in",
"coords",
":",
"coords",
"[",
"hit",
".",
"qry_name",
"]",
"=",
"[",
"]",
"coords",
"[",
"hit",
".",
"qry_name",
"]",
".",
"append",
"(",
"hit",
".",
"qry_coords",
"(",
")",
")",
"for",
"scaff",
"in",
"coords",
":",
"pyfastaq",
".",
"intervals",
".",
"merge_overlapping_in_list",
"(",
"coords",
"[",
"scaff",
"]",
")",
"return",
"coords"
] | Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = list of coords that match
to the reference gene | [
"Input",
"is",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
".",
"Returns",
"dictionary",
".",
"key",
"=",
"contig",
"name",
".",
"Value",
"=",
"list",
"of",
"coords",
"that",
"match",
"to",
"the",
"reference",
"gene"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L97-L111 | train | 235,074 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare.nucmer_hits_to_ref_coords | def nucmer_hits_to_ref_coords(cls, nucmer_hits, contig=None):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. Key = contig name. Value = list of coords in the
reference sequence for that contig.
if contig=contig_name, then just gets the ref coords from that contig,
instead of using all the contigs'''
coords = []
if contig is None:
coords = {key: [] for key in nucmer_hits.keys()}
else:
coords = {contig: []}
for key in coords:
coords[key] = [hit.ref_coords() for hit in nucmer_hits[key]]
pyfastaq.intervals.merge_overlapping_in_list(coords[key])
return coords | python | def nucmer_hits_to_ref_coords(cls, nucmer_hits, contig=None):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. Key = contig name. Value = list of coords in the
reference sequence for that contig.
if contig=contig_name, then just gets the ref coords from that contig,
instead of using all the contigs'''
coords = []
if contig is None:
coords = {key: [] for key in nucmer_hits.keys()}
else:
coords = {contig: []}
for key in coords:
coords[key] = [hit.ref_coords() for hit in nucmer_hits[key]]
pyfastaq.intervals.merge_overlapping_in_list(coords[key])
return coords | [
"def",
"nucmer_hits_to_ref_coords",
"(",
"cls",
",",
"nucmer_hits",
",",
"contig",
"=",
"None",
")",
":",
"coords",
"=",
"[",
"]",
"if",
"contig",
"is",
"None",
":",
"coords",
"=",
"{",
"key",
":",
"[",
"]",
"for",
"key",
"in",
"nucmer_hits",
".",
"keys",
"(",
")",
"}",
"else",
":",
"coords",
"=",
"{",
"contig",
":",
"[",
"]",
"}",
"for",
"key",
"in",
"coords",
":",
"coords",
"[",
"key",
"]",
"=",
"[",
"hit",
".",
"ref_coords",
"(",
")",
"for",
"hit",
"in",
"nucmer_hits",
"[",
"key",
"]",
"]",
"pyfastaq",
".",
"intervals",
".",
"merge_overlapping_in_list",
"(",
"coords",
"[",
"key",
"]",
")",
"return",
"coords"
] | Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. Key = contig name. Value = list of coords in the
reference sequence for that contig.
if contig=contig_name, then just gets the ref coords from that contig,
instead of using all the contigs | [
"Input",
"is",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
".",
"Returns",
"dictionary",
".",
"Key",
"=",
"contig",
"name",
".",
"Value",
"=",
"list",
"of",
"coords",
"in",
"the",
"reference",
"sequence",
"for",
"that",
"contig",
".",
"if",
"contig",
"=",
"contig_name",
"then",
"just",
"gets",
"the",
"ref",
"coords",
"from",
"that",
"contig",
"instead",
"of",
"using",
"all",
"the",
"contigs"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L119-L135 | train | 235,075 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare.nucmer_hits_to_ref_and_qry_coords | def nucmer_hits_to_ref_and_qry_coords(cls, nucmer_hits, contig=None):
'''Same as nucmer_hits_to_ref_coords, except removes containing hits first,
and returns ref and qry coords lists'''
if contig is None:
ctg_coords = {key: [] for key in nucmer_hits.keys()}
else:
ctg_coords = {contig: []}
ref_coords = {}
for key in ctg_coords:
hits = copy.copy(nucmer_hits[key])
hits.sort(key=lambda x: len(x.ref_coords()))
if len(hits) > 1:
i = 0
while i < len(hits) - 1:
c1 = hits[i].ref_coords()
c2 = hits[i+1].ref_coords()
if c2.contains(c1):
hits.pop(i)
else:
i += 1
ref_coords[key] = [hit.ref_coords() for hit in hits]
ctg_coords[key] = [hit.qry_coords() for hit in hits]
pyfastaq.intervals.merge_overlapping_in_list(ref_coords[key])
pyfastaq.intervals.merge_overlapping_in_list(ctg_coords[key])
return ctg_coords, ref_coords | python | def nucmer_hits_to_ref_and_qry_coords(cls, nucmer_hits, contig=None):
'''Same as nucmer_hits_to_ref_coords, except removes containing hits first,
and returns ref and qry coords lists'''
if contig is None:
ctg_coords = {key: [] for key in nucmer_hits.keys()}
else:
ctg_coords = {contig: []}
ref_coords = {}
for key in ctg_coords:
hits = copy.copy(nucmer_hits[key])
hits.sort(key=lambda x: len(x.ref_coords()))
if len(hits) > 1:
i = 0
while i < len(hits) - 1:
c1 = hits[i].ref_coords()
c2 = hits[i+1].ref_coords()
if c2.contains(c1):
hits.pop(i)
else:
i += 1
ref_coords[key] = [hit.ref_coords() for hit in hits]
ctg_coords[key] = [hit.qry_coords() for hit in hits]
pyfastaq.intervals.merge_overlapping_in_list(ref_coords[key])
pyfastaq.intervals.merge_overlapping_in_list(ctg_coords[key])
return ctg_coords, ref_coords | [
"def",
"nucmer_hits_to_ref_and_qry_coords",
"(",
"cls",
",",
"nucmer_hits",
",",
"contig",
"=",
"None",
")",
":",
"if",
"contig",
"is",
"None",
":",
"ctg_coords",
"=",
"{",
"key",
":",
"[",
"]",
"for",
"key",
"in",
"nucmer_hits",
".",
"keys",
"(",
")",
"}",
"else",
":",
"ctg_coords",
"=",
"{",
"contig",
":",
"[",
"]",
"}",
"ref_coords",
"=",
"{",
"}",
"for",
"key",
"in",
"ctg_coords",
":",
"hits",
"=",
"copy",
".",
"copy",
"(",
"nucmer_hits",
"[",
"key",
"]",
")",
"hits",
".",
"sort",
"(",
"key",
"=",
"lambda",
"x",
":",
"len",
"(",
"x",
".",
"ref_coords",
"(",
")",
")",
")",
"if",
"len",
"(",
"hits",
")",
">",
"1",
":",
"i",
"=",
"0",
"while",
"i",
"<",
"len",
"(",
"hits",
")",
"-",
"1",
":",
"c1",
"=",
"hits",
"[",
"i",
"]",
".",
"ref_coords",
"(",
")",
"c2",
"=",
"hits",
"[",
"i",
"+",
"1",
"]",
".",
"ref_coords",
"(",
")",
"if",
"c2",
".",
"contains",
"(",
"c1",
")",
":",
"hits",
".",
"pop",
"(",
"i",
")",
"else",
":",
"i",
"+=",
"1",
"ref_coords",
"[",
"key",
"]",
"=",
"[",
"hit",
".",
"ref_coords",
"(",
")",
"for",
"hit",
"in",
"hits",
"]",
"ctg_coords",
"[",
"key",
"]",
"=",
"[",
"hit",
".",
"qry_coords",
"(",
")",
"for",
"hit",
"in",
"hits",
"]",
"pyfastaq",
".",
"intervals",
".",
"merge_overlapping_in_list",
"(",
"ref_coords",
"[",
"key",
"]",
")",
"pyfastaq",
".",
"intervals",
".",
"merge_overlapping_in_list",
"(",
"ctg_coords",
"[",
"key",
"]",
")",
"return",
"ctg_coords",
",",
"ref_coords"
] | Same as nucmer_hits_to_ref_coords, except removes containing hits first,
and returns ref and qry coords lists | [
"Same",
"as",
"nucmer_hits_to_ref_coords",
"except",
"removes",
"containing",
"hits",
"first",
"and",
"returns",
"ref",
"and",
"qry",
"coords",
"lists"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L139-L168 | train | 235,076 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare.ref_cov_per_contig | def ref_cov_per_contig(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = number of bases that
match to the reference sequence.'''
coords = AssemblyCompare.nucmer_hits_to_ref_coords(nucmer_hits)
return {x: pyfastaq.intervals.length_sum_from_list(coords[x]) for x in coords} | python | def ref_cov_per_contig(nucmer_hits):
'''Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = number of bases that
match to the reference sequence.'''
coords = AssemblyCompare.nucmer_hits_to_ref_coords(nucmer_hits)
return {x: pyfastaq.intervals.length_sum_from_list(coords[x]) for x in coords} | [
"def",
"ref_cov_per_contig",
"(",
"nucmer_hits",
")",
":",
"coords",
"=",
"AssemblyCompare",
".",
"nucmer_hits_to_ref_coords",
"(",
"nucmer_hits",
")",
"return",
"{",
"x",
":",
"pyfastaq",
".",
"intervals",
".",
"length_sum_from_list",
"(",
"coords",
"[",
"x",
"]",
")",
"for",
"x",
"in",
"coords",
"}"
] | Input is hits made by self._parse_nucmer_coords_file.
Returns dictionary. key = contig name. Value = number of bases that
match to the reference sequence. | [
"Input",
"is",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
".",
"Returns",
"dictionary",
".",
"key",
"=",
"contig",
"name",
".",
"Value",
"=",
"number",
"of",
"bases",
"that",
"match",
"to",
"the",
"reference",
"sequence",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L172-L177 | train | 235,077 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare._ref_covered_by_at_least_one_full_length_contig | def _ref_covered_by_at_least_one_full_length_contig(nucmer_hits, percent_threshold, max_nt_extend):
'''Returns true iff there exists a contig that completely
covers the reference sequence
nucmer_hits = hits made by self._parse_nucmer_coords_file.'''
for l in nucmer_hits.values():
for hit in l:
if ( (2 * max_nt_extend) + len(hit.ref_coords()) ) / hit.ref_length >= percent_threshold:
return True
return False | python | def _ref_covered_by_at_least_one_full_length_contig(nucmer_hits, percent_threshold, max_nt_extend):
'''Returns true iff there exists a contig that completely
covers the reference sequence
nucmer_hits = hits made by self._parse_nucmer_coords_file.'''
for l in nucmer_hits.values():
for hit in l:
if ( (2 * max_nt_extend) + len(hit.ref_coords()) ) / hit.ref_length >= percent_threshold:
return True
return False | [
"def",
"_ref_covered_by_at_least_one_full_length_contig",
"(",
"nucmer_hits",
",",
"percent_threshold",
",",
"max_nt_extend",
")",
":",
"for",
"l",
"in",
"nucmer_hits",
".",
"values",
"(",
")",
":",
"for",
"hit",
"in",
"l",
":",
"if",
"(",
"(",
"2",
"*",
"max_nt_extend",
")",
"+",
"len",
"(",
"hit",
".",
"ref_coords",
"(",
")",
")",
")",
"/",
"hit",
".",
"ref_length",
">=",
"percent_threshold",
":",
"return",
"True",
"return",
"False"
] | Returns true iff there exists a contig that completely
covers the reference sequence
nucmer_hits = hits made by self._parse_nucmer_coords_file. | [
"Returns",
"true",
"iff",
"there",
"exists",
"a",
"contig",
"that",
"completely",
"covers",
"the",
"reference",
"sequence",
"nucmer_hits",
"=",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L352-L360 | train | 235,078 |
sanger-pathogens/ariba | ariba/assembly_compare.py | AssemblyCompare.nucmer_hit_containing_reference_position | def nucmer_hit_containing_reference_position(nucmer_hits, ref_name, ref_position, qry_name=None):
'''Returns the first nucmer match found that contains the given
reference location. nucmer_hits = hits made by self._parse_nucmer_coords_file.
Returns None if no matching hit found'''
for contig_name in nucmer_hits:
for hit in nucmer_hits[contig_name]:
if hit.ref_name == ref_name and (qry_name is None or qry_name == hit.qry_name) and hit.ref_coords().distance_to_point(ref_position) == 0:
return hit
return None | python | def nucmer_hit_containing_reference_position(nucmer_hits, ref_name, ref_position, qry_name=None):
'''Returns the first nucmer match found that contains the given
reference location. nucmer_hits = hits made by self._parse_nucmer_coords_file.
Returns None if no matching hit found'''
for contig_name in nucmer_hits:
for hit in nucmer_hits[contig_name]:
if hit.ref_name == ref_name and (qry_name is None or qry_name == hit.qry_name) and hit.ref_coords().distance_to_point(ref_position) == 0:
return hit
return None | [
"def",
"nucmer_hit_containing_reference_position",
"(",
"nucmer_hits",
",",
"ref_name",
",",
"ref_position",
",",
"qry_name",
"=",
"None",
")",
":",
"for",
"contig_name",
"in",
"nucmer_hits",
":",
"for",
"hit",
"in",
"nucmer_hits",
"[",
"contig_name",
"]",
":",
"if",
"hit",
".",
"ref_name",
"==",
"ref_name",
"and",
"(",
"qry_name",
"is",
"None",
"or",
"qry_name",
"==",
"hit",
".",
"qry_name",
")",
"and",
"hit",
".",
"ref_coords",
"(",
")",
".",
"distance_to_point",
"(",
"ref_position",
")",
"==",
"0",
":",
"return",
"hit",
"return",
"None"
] | Returns the first nucmer match found that contains the given
reference location. nucmer_hits = hits made by self._parse_nucmer_coords_file.
Returns None if no matching hit found | [
"Returns",
"the",
"first",
"nucmer",
"match",
"found",
"that",
"contains",
"the",
"given",
"reference",
"location",
".",
"nucmer_hits",
"=",
"hits",
"made",
"by",
"self",
".",
"_parse_nucmer_coords_file",
".",
"Returns",
"None",
"if",
"no",
"matching",
"hit",
"found"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_compare.py#L384-L393 | train | 235,079 |
sanger-pathogens/ariba | ariba/external_progs.py | ExternalProgs._get_exe | def _get_exe(prog):
'''Given a program name, return what we expect its exectuable to be called'''
if prog in prog_to_env_var:
env_var = prog_to_env_var[prog]
if env_var in os.environ:
return os.environ[env_var]
return prog_to_default[prog] | python | def _get_exe(prog):
'''Given a program name, return what we expect its exectuable to be called'''
if prog in prog_to_env_var:
env_var = prog_to_env_var[prog]
if env_var in os.environ:
return os.environ[env_var]
return prog_to_default[prog] | [
"def",
"_get_exe",
"(",
"prog",
")",
":",
"if",
"prog",
"in",
"prog_to_env_var",
":",
"env_var",
"=",
"prog_to_env_var",
"[",
"prog",
"]",
"if",
"env_var",
"in",
"os",
".",
"environ",
":",
"return",
"os",
".",
"environ",
"[",
"env_var",
"]",
"return",
"prog_to_default",
"[",
"prog",
"]"
] | Given a program name, return what we expect its exectuable to be called | [
"Given",
"a",
"program",
"name",
"return",
"what",
"we",
"expect",
"its",
"exectuable",
"to",
"be",
"called"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/external_progs.py#L131-L138 | train | 235,080 |
sanger-pathogens/ariba | ariba/cdhit.py | Runner.fake_run | def fake_run(self):
'''Doesn't actually run cd-hit. Instead, puts each input sequence into its own cluster. So it's as if cdhit was run, but didn't cluster anything'''
clusters = {}
used_names = set()
seq_reader = pyfastaq.sequences.file_reader(self.infile)
for seq in seq_reader:
if seq.id in used_names:
raise Error('Sequence name "' + seq.id + '" not unique. Cannot continue')
clusters[str(len(clusters) + self.min_cluster_number)] = {seq.id}
used_names.add(seq.id)
return clusters | python | def fake_run(self):
'''Doesn't actually run cd-hit. Instead, puts each input sequence into its own cluster. So it's as if cdhit was run, but didn't cluster anything'''
clusters = {}
used_names = set()
seq_reader = pyfastaq.sequences.file_reader(self.infile)
for seq in seq_reader:
if seq.id in used_names:
raise Error('Sequence name "' + seq.id + '" not unique. Cannot continue')
clusters[str(len(clusters) + self.min_cluster_number)] = {seq.id}
used_names.add(seq.id)
return clusters | [
"def",
"fake_run",
"(",
"self",
")",
":",
"clusters",
"=",
"{",
"}",
"used_names",
"=",
"set",
"(",
")",
"seq_reader",
"=",
"pyfastaq",
".",
"sequences",
".",
"file_reader",
"(",
"self",
".",
"infile",
")",
"for",
"seq",
"in",
"seq_reader",
":",
"if",
"seq",
".",
"id",
"in",
"used_names",
":",
"raise",
"Error",
"(",
"'Sequence name \"'",
"+",
"seq",
".",
"id",
"+",
"'\" not unique. Cannot continue'",
")",
"clusters",
"[",
"str",
"(",
"len",
"(",
"clusters",
")",
"+",
"self",
".",
"min_cluster_number",
")",
"]",
"=",
"{",
"seq",
".",
"id",
"}",
"used_names",
".",
"add",
"(",
"seq",
".",
"id",
")",
"return",
"clusters"
] | Doesn't actually run cd-hit. Instead, puts each input sequence into its own cluster. So it's as if cdhit was run, but didn't cluster anything | [
"Doesn",
"t",
"actually",
"run",
"cd",
"-",
"hit",
".",
"Instead",
"puts",
"each",
"input",
"sequence",
"into",
"its",
"own",
"cluster",
".",
"So",
"it",
"s",
"as",
"if",
"cdhit",
"was",
"run",
"but",
"didn",
"t",
"cluster",
"anything"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/cdhit.py#L38-L51 | train | 235,081 |
sanger-pathogens/ariba | ariba/cdhit.py | Runner.run_get_clusters_from_file | def run_get_clusters_from_file(self, clusters_infile, all_ref_seqs, rename_dict=None):
'''Instead of running cdhit, gets the clusters info from the input file.'''
if rename_dict is None:
rename_dict = {}
# check that every sequence in the clusters file can be
# found in the fasta file
seq_reader = pyfastaq.sequences.file_reader(self.infile)
names_list_from_fasta_file = [seq.id for seq in seq_reader]
names_set_from_fasta_file = set(names_list_from_fasta_file)
clusters = self._load_user_clusters_file(clusters_infile, all_ref_seqs, rename_dict=rename_dict)
if len(names_set_from_fasta_file) != len(names_list_from_fasta_file):
raise Error('At least one duplicate name in fasta file ' + self.infile + '. Cannot continue')
names_from_clusters_file = set()
for new_names in clusters.values():
names_from_clusters_file.update(new_names)
if not names_set_from_fasta_file.issubset(names_from_clusters_file):
raise Error('Some names in fasta file "' + self.infile + '" not given in cluster file. Cannot continue')
return clusters | python | def run_get_clusters_from_file(self, clusters_infile, all_ref_seqs, rename_dict=None):
'''Instead of running cdhit, gets the clusters info from the input file.'''
if rename_dict is None:
rename_dict = {}
# check that every sequence in the clusters file can be
# found in the fasta file
seq_reader = pyfastaq.sequences.file_reader(self.infile)
names_list_from_fasta_file = [seq.id for seq in seq_reader]
names_set_from_fasta_file = set(names_list_from_fasta_file)
clusters = self._load_user_clusters_file(clusters_infile, all_ref_seqs, rename_dict=rename_dict)
if len(names_set_from_fasta_file) != len(names_list_from_fasta_file):
raise Error('At least one duplicate name in fasta file ' + self.infile + '. Cannot continue')
names_from_clusters_file = set()
for new_names in clusters.values():
names_from_clusters_file.update(new_names)
if not names_set_from_fasta_file.issubset(names_from_clusters_file):
raise Error('Some names in fasta file "' + self.infile + '" not given in cluster file. Cannot continue')
return clusters | [
"def",
"run_get_clusters_from_file",
"(",
"self",
",",
"clusters_infile",
",",
"all_ref_seqs",
",",
"rename_dict",
"=",
"None",
")",
":",
"if",
"rename_dict",
"is",
"None",
":",
"rename_dict",
"=",
"{",
"}",
"# check that every sequence in the clusters file can be",
"# found in the fasta file",
"seq_reader",
"=",
"pyfastaq",
".",
"sequences",
".",
"file_reader",
"(",
"self",
".",
"infile",
")",
"names_list_from_fasta_file",
"=",
"[",
"seq",
".",
"id",
"for",
"seq",
"in",
"seq_reader",
"]",
"names_set_from_fasta_file",
"=",
"set",
"(",
"names_list_from_fasta_file",
")",
"clusters",
"=",
"self",
".",
"_load_user_clusters_file",
"(",
"clusters_infile",
",",
"all_ref_seqs",
",",
"rename_dict",
"=",
"rename_dict",
")",
"if",
"len",
"(",
"names_set_from_fasta_file",
")",
"!=",
"len",
"(",
"names_list_from_fasta_file",
")",
":",
"raise",
"Error",
"(",
"'At least one duplicate name in fasta file '",
"+",
"self",
".",
"infile",
"+",
"'. Cannot continue'",
")",
"names_from_clusters_file",
"=",
"set",
"(",
")",
"for",
"new_names",
"in",
"clusters",
".",
"values",
"(",
")",
":",
"names_from_clusters_file",
".",
"update",
"(",
"new_names",
")",
"if",
"not",
"names_set_from_fasta_file",
".",
"issubset",
"(",
"names_from_clusters_file",
")",
":",
"raise",
"Error",
"(",
"'Some names in fasta file \"'",
"+",
"self",
".",
"infile",
"+",
"'\" not given in cluster file. Cannot continue'",
")",
"return",
"clusters"
] | Instead of running cdhit, gets the clusters info from the input file. | [
"Instead",
"of",
"running",
"cdhit",
"gets",
"the",
"clusters",
"info",
"from",
"the",
"input",
"file",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/cdhit.py#L86-L109 | train | 235,082 |
sanger-pathogens/ariba | ariba/mapping.py | sam_pair_to_insert | def sam_pair_to_insert(s1, s2):
'''Returns insert size from pair of sam records, as long as their orientation is "innies".
Otherwise returns None.'''
if s1.is_unmapped or s2.is_unmapped or (s1.tid != s2.tid) or (s1.is_reverse == s2.is_reverse):
return None
# If here, reads are both mapped to the same ref, and in opposite orientations
if s1.is_reverse:
end = s1.reference_end - 1
start = s2.reference_start
else:
end = s2.reference_end - 1
start = s1.reference_start
if start < end:
return end - start + 1
else:
return None | python | def sam_pair_to_insert(s1, s2):
'''Returns insert size from pair of sam records, as long as their orientation is "innies".
Otherwise returns None.'''
if s1.is_unmapped or s2.is_unmapped or (s1.tid != s2.tid) or (s1.is_reverse == s2.is_reverse):
return None
# If here, reads are both mapped to the same ref, and in opposite orientations
if s1.is_reverse:
end = s1.reference_end - 1
start = s2.reference_start
else:
end = s2.reference_end - 1
start = s1.reference_start
if start < end:
return end - start + 1
else:
return None | [
"def",
"sam_pair_to_insert",
"(",
"s1",
",",
"s2",
")",
":",
"if",
"s1",
".",
"is_unmapped",
"or",
"s2",
".",
"is_unmapped",
"or",
"(",
"s1",
".",
"tid",
"!=",
"s2",
".",
"tid",
")",
"or",
"(",
"s1",
".",
"is_reverse",
"==",
"s2",
".",
"is_reverse",
")",
":",
"return",
"None",
"# If here, reads are both mapped to the same ref, and in opposite orientations",
"if",
"s1",
".",
"is_reverse",
":",
"end",
"=",
"s1",
".",
"reference_end",
"-",
"1",
"start",
"=",
"s2",
".",
"reference_start",
"else",
":",
"end",
"=",
"s2",
".",
"reference_end",
"-",
"1",
"start",
"=",
"s1",
".",
"reference_start",
"if",
"start",
"<",
"end",
":",
"return",
"end",
"-",
"start",
"+",
"1",
"else",
":",
"return",
"None"
] | Returns insert size from pair of sam records, as long as their orientation is "innies".
Otherwise returns None. | [
"Returns",
"insert",
"size",
"from",
"pair",
"of",
"sam",
"records",
"as",
"long",
"as",
"their",
"orientation",
"is",
"innies",
".",
"Otherwise",
"returns",
"None",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/mapping.py#L153-L170 | train | 235,083 |
sanger-pathogens/ariba | ariba/scaffold_graph.py | Graph.update_from_sam | def update_from_sam(self, sam, sam_reader):
'''Updates graph info from a pysam.AlignedSegment object'''
if sam.is_unmapped \
or sam.mate_is_unmapped \
or (sam.reference_id == sam.next_reference_id):
return
new_link = link.Link(sam, sam_reader, self.ref_lengths)
read_name = sam.query_name
if read_name in self.partial_links:
new_link.merge(self.partial_links[read_name])
del self.partial_links[read_name]
key = tuple(sorted((new_link.refnames[0], new_link.refnames[1])))
if key not in self.links:
self.links[key] = []
new_link.sort()
self.links[key].append(new_link)
else:
self.partial_links[read_name] = new_link | python | def update_from_sam(self, sam, sam_reader):
'''Updates graph info from a pysam.AlignedSegment object'''
if sam.is_unmapped \
or sam.mate_is_unmapped \
or (sam.reference_id == sam.next_reference_id):
return
new_link = link.Link(sam, sam_reader, self.ref_lengths)
read_name = sam.query_name
if read_name in self.partial_links:
new_link.merge(self.partial_links[read_name])
del self.partial_links[read_name]
key = tuple(sorted((new_link.refnames[0], new_link.refnames[1])))
if key not in self.links:
self.links[key] = []
new_link.sort()
self.links[key].append(new_link)
else:
self.partial_links[read_name] = new_link | [
"def",
"update_from_sam",
"(",
"self",
",",
"sam",
",",
"sam_reader",
")",
":",
"if",
"sam",
".",
"is_unmapped",
"or",
"sam",
".",
"mate_is_unmapped",
"or",
"(",
"sam",
".",
"reference_id",
"==",
"sam",
".",
"next_reference_id",
")",
":",
"return",
"new_link",
"=",
"link",
".",
"Link",
"(",
"sam",
",",
"sam_reader",
",",
"self",
".",
"ref_lengths",
")",
"read_name",
"=",
"sam",
".",
"query_name",
"if",
"read_name",
"in",
"self",
".",
"partial_links",
":",
"new_link",
".",
"merge",
"(",
"self",
".",
"partial_links",
"[",
"read_name",
"]",
")",
"del",
"self",
".",
"partial_links",
"[",
"read_name",
"]",
"key",
"=",
"tuple",
"(",
"sorted",
"(",
"(",
"new_link",
".",
"refnames",
"[",
"0",
"]",
",",
"new_link",
".",
"refnames",
"[",
"1",
"]",
")",
")",
")",
"if",
"key",
"not",
"in",
"self",
".",
"links",
":",
"self",
".",
"links",
"[",
"key",
"]",
"=",
"[",
"]",
"new_link",
".",
"sort",
"(",
")",
"self",
".",
"links",
"[",
"key",
"]",
".",
"append",
"(",
"new_link",
")",
"else",
":",
"self",
".",
"partial_links",
"[",
"read_name",
"]",
"=",
"new_link"
] | Updates graph info from a pysam.AlignedSegment object | [
"Updates",
"graph",
"info",
"from",
"a",
"pysam",
".",
"AlignedSegment",
"object"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/scaffold_graph.py#L13-L32 | train | 235,084 |
sanger-pathogens/ariba | ariba/scaffold_graph.py | Graph._make_graph | def _make_graph(self, max_insert):
'''helper function to construct graph from current state of object'''
if len(self.partial_links) != 0:
raise Error('Error in _make_graph(). Cannot continue because there are partial links')
self.contig_links = {}
for key in self.links:
for l in self.links[key]:
insert_size = l.insert_size()
if insert_size <= max_insert:
if key not in self.contig_links:
self.contig_links[key] = {}
dirs = ''.join(l.dirs)
self.contig_links[key][dirs] = self.contig_links[key].get(dirs, 0) + 1 | python | def _make_graph(self, max_insert):
'''helper function to construct graph from current state of object'''
if len(self.partial_links) != 0:
raise Error('Error in _make_graph(). Cannot continue because there are partial links')
self.contig_links = {}
for key in self.links:
for l in self.links[key]:
insert_size = l.insert_size()
if insert_size <= max_insert:
if key not in self.contig_links:
self.contig_links[key] = {}
dirs = ''.join(l.dirs)
self.contig_links[key][dirs] = self.contig_links[key].get(dirs, 0) + 1 | [
"def",
"_make_graph",
"(",
"self",
",",
"max_insert",
")",
":",
"if",
"len",
"(",
"self",
".",
"partial_links",
")",
"!=",
"0",
":",
"raise",
"Error",
"(",
"'Error in _make_graph(). Cannot continue because there are partial links'",
")",
"self",
".",
"contig_links",
"=",
"{",
"}",
"for",
"key",
"in",
"self",
".",
"links",
":",
"for",
"l",
"in",
"self",
".",
"links",
"[",
"key",
"]",
":",
"insert_size",
"=",
"l",
".",
"insert_size",
"(",
")",
"if",
"insert_size",
"<=",
"max_insert",
":",
"if",
"key",
"not",
"in",
"self",
".",
"contig_links",
":",
"self",
".",
"contig_links",
"[",
"key",
"]",
"=",
"{",
"}",
"dirs",
"=",
"''",
".",
"join",
"(",
"l",
".",
"dirs",
")",
"self",
".",
"contig_links",
"[",
"key",
"]",
"[",
"dirs",
"]",
"=",
"self",
".",
"contig_links",
"[",
"key",
"]",
".",
"get",
"(",
"dirs",
",",
"0",
")",
"+",
"1"
] | helper function to construct graph from current state of object | [
"helper",
"function",
"to",
"construct",
"graph",
"from",
"current",
"state",
"of",
"object"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/scaffold_graph.py#L35-L48 | train | 235,085 |
sanger-pathogens/ariba | ariba/bam_parse.py | Parser._sam_to_soft_clipped | def _sam_to_soft_clipped(self, sam):
'''Returns tuple of whether or not the left and right end of the mapped read in the sam record is soft-clipped'''
if sam.is_unmapped:
raise Error('Cannot get soft clip info from an unmapped read')
if sam.cigar is None or len(sam.cigar) == 0:
return False, False
return (sam.cigar[0][0] == 4, sam.cigar[-1][0] == 4) | python | def _sam_to_soft_clipped(self, sam):
'''Returns tuple of whether or not the left and right end of the mapped read in the sam record is soft-clipped'''
if sam.is_unmapped:
raise Error('Cannot get soft clip info from an unmapped read')
if sam.cigar is None or len(sam.cigar) == 0:
return False, False
return (sam.cigar[0][0] == 4, sam.cigar[-1][0] == 4) | [
"def",
"_sam_to_soft_clipped",
"(",
"self",
",",
"sam",
")",
":",
"if",
"sam",
".",
"is_unmapped",
":",
"raise",
"Error",
"(",
"'Cannot get soft clip info from an unmapped read'",
")",
"if",
"sam",
".",
"cigar",
"is",
"None",
"or",
"len",
"(",
"sam",
".",
"cigar",
")",
"==",
"0",
":",
"return",
"False",
",",
"False",
"return",
"(",
"sam",
".",
"cigar",
"[",
"0",
"]",
"[",
"0",
"]",
"==",
"4",
",",
"sam",
".",
"cigar",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"==",
"4",
")"
] | Returns tuple of whether or not the left and right end of the mapped read in the sam record is soft-clipped | [
"Returns",
"tuple",
"of",
"whether",
"or",
"not",
"the",
"left",
"and",
"right",
"end",
"of",
"the",
"mapped",
"read",
"in",
"the",
"sam",
"record",
"is",
"soft",
"-",
"clipped"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/bam_parse.py#L21-L28 | train | 235,086 |
sanger-pathogens/ariba | ariba/report_filter.py | ReportFilter._report_line_to_dict | def _report_line_to_dict(cls, line):
'''Takes report line string as input. Returns a dict of column name -> value in line'''
data = line.split('\t')
if len(data) != len(report.columns):
return None
d = dict(zip(report.columns, data))
for key in report.int_columns:
try:
d[key] = int(d[key])
except:
assert d[key] == '.'
for key in report.float_columns:
try:
d[key] = float(d[key])
except:
assert d[key] == '.'
d['flag'] = flag.Flag(int(d['flag']))
return d | python | def _report_line_to_dict(cls, line):
'''Takes report line string as input. Returns a dict of column name -> value in line'''
data = line.split('\t')
if len(data) != len(report.columns):
return None
d = dict(zip(report.columns, data))
for key in report.int_columns:
try:
d[key] = int(d[key])
except:
assert d[key] == '.'
for key in report.float_columns:
try:
d[key] = float(d[key])
except:
assert d[key] == '.'
d['flag'] = flag.Flag(int(d['flag']))
return d | [
"def",
"_report_line_to_dict",
"(",
"cls",
",",
"line",
")",
":",
"data",
"=",
"line",
".",
"split",
"(",
"'\\t'",
")",
"if",
"len",
"(",
"data",
")",
"!=",
"len",
"(",
"report",
".",
"columns",
")",
":",
"return",
"None",
"d",
"=",
"dict",
"(",
"zip",
"(",
"report",
".",
"columns",
",",
"data",
")",
")",
"for",
"key",
"in",
"report",
".",
"int_columns",
":",
"try",
":",
"d",
"[",
"key",
"]",
"=",
"int",
"(",
"d",
"[",
"key",
"]",
")",
"except",
":",
"assert",
"d",
"[",
"key",
"]",
"==",
"'.'",
"for",
"key",
"in",
"report",
".",
"float_columns",
":",
"try",
":",
"d",
"[",
"key",
"]",
"=",
"float",
"(",
"d",
"[",
"key",
"]",
")",
"except",
":",
"assert",
"d",
"[",
"key",
"]",
"==",
"'.'",
"d",
"[",
"'flag'",
"]",
"=",
"flag",
".",
"Flag",
"(",
"int",
"(",
"d",
"[",
"'flag'",
"]",
")",
")",
"return",
"d"
] | Takes report line string as input. Returns a dict of column name -> value in line | [
"Takes",
"report",
"line",
"string",
"as",
"input",
".",
"Returns",
"a",
"dict",
"of",
"column",
"name",
"-",
">",
"value",
"in",
"line"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/report_filter.py#L33-L53 | train | 235,087 |
sanger-pathogens/ariba | ariba/report_filter.py | ReportFilter._dict_to_report_line | def _dict_to_report_line(cls, report_dict):
'''Takes a report_dict as input and returns a report line'''
return '\t'.join([str(report_dict[x]) for x in report.columns]) | python | def _dict_to_report_line(cls, report_dict):
'''Takes a report_dict as input and returns a report line'''
return '\t'.join([str(report_dict[x]) for x in report.columns]) | [
"def",
"_dict_to_report_line",
"(",
"cls",
",",
"report_dict",
")",
":",
"return",
"'\\t'",
".",
"join",
"(",
"[",
"str",
"(",
"report_dict",
"[",
"x",
"]",
")",
"for",
"x",
"in",
"report",
".",
"columns",
"]",
")"
] | Takes a report_dict as input and returns a report line | [
"Takes",
"a",
"report_dict",
"as",
"input",
"and",
"returns",
"a",
"report",
"line"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/report_filter.py#L57-L59 | train | 235,088 |
sanger-pathogens/ariba | ariba/report_filter.py | ReportFilter._load_report | def _load_report(infile):
'''Loads report file into a dictionary. Key=reference name.
Value = list of report lines for that reference'''
report_dict = {}
f = pyfastaq.utils.open_file_read(infile)
first_line = True
for line in f:
line = line.rstrip()
if first_line:
expected_first_line = '#' + '\t'.join(report.columns)
if line != expected_first_line:
pyfastaq.utils.close(f)
raise Error('Error reading report file. Expected first line of file is\n' + expected_first_line + '\nbut got:\n' + line)
first_line = False
else:
line_dict = ReportFilter._report_line_to_dict(line)
if line_dict is None:
pyfastaq.utils.close(f)
raise Error('Error reading report file at this line:\n' + line)
ref_name = line_dict['ref_name']
ctg_name = line_dict['ctg']
if ref_name not in report_dict:
report_dict[ref_name] = {}
if ctg_name not in report_dict[ref_name]:
report_dict[ref_name][ctg_name] = []
report_dict[ref_name][ctg_name].append(line_dict)
pyfastaq.utils.close(f)
return report_dict | python | def _load_report(infile):
'''Loads report file into a dictionary. Key=reference name.
Value = list of report lines for that reference'''
report_dict = {}
f = pyfastaq.utils.open_file_read(infile)
first_line = True
for line in f:
line = line.rstrip()
if first_line:
expected_first_line = '#' + '\t'.join(report.columns)
if line != expected_first_line:
pyfastaq.utils.close(f)
raise Error('Error reading report file. Expected first line of file is\n' + expected_first_line + '\nbut got:\n' + line)
first_line = False
else:
line_dict = ReportFilter._report_line_to_dict(line)
if line_dict is None:
pyfastaq.utils.close(f)
raise Error('Error reading report file at this line:\n' + line)
ref_name = line_dict['ref_name']
ctg_name = line_dict['ctg']
if ref_name not in report_dict:
report_dict[ref_name] = {}
if ctg_name not in report_dict[ref_name]:
report_dict[ref_name][ctg_name] = []
report_dict[ref_name][ctg_name].append(line_dict)
pyfastaq.utils.close(f)
return report_dict | [
"def",
"_load_report",
"(",
"infile",
")",
":",
"report_dict",
"=",
"{",
"}",
"f",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_read",
"(",
"infile",
")",
"first_line",
"=",
"True",
"for",
"line",
"in",
"f",
":",
"line",
"=",
"line",
".",
"rstrip",
"(",
")",
"if",
"first_line",
":",
"expected_first_line",
"=",
"'#'",
"+",
"'\\t'",
".",
"join",
"(",
"report",
".",
"columns",
")",
"if",
"line",
"!=",
"expected_first_line",
":",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"raise",
"Error",
"(",
"'Error reading report file. Expected first line of file is\\n'",
"+",
"expected_first_line",
"+",
"'\\nbut got:\\n'",
"+",
"line",
")",
"first_line",
"=",
"False",
"else",
":",
"line_dict",
"=",
"ReportFilter",
".",
"_report_line_to_dict",
"(",
"line",
")",
"if",
"line_dict",
"is",
"None",
":",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"raise",
"Error",
"(",
"'Error reading report file at this line:\\n'",
"+",
"line",
")",
"ref_name",
"=",
"line_dict",
"[",
"'ref_name'",
"]",
"ctg_name",
"=",
"line_dict",
"[",
"'ctg'",
"]",
"if",
"ref_name",
"not",
"in",
"report_dict",
":",
"report_dict",
"[",
"ref_name",
"]",
"=",
"{",
"}",
"if",
"ctg_name",
"not",
"in",
"report_dict",
"[",
"ref_name",
"]",
":",
"report_dict",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
"=",
"[",
"]",
"report_dict",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
".",
"append",
"(",
"line_dict",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"return",
"report_dict"
] | Loads report file into a dictionary. Key=reference name.
Value = list of report lines for that reference | [
"Loads",
"report",
"file",
"into",
"a",
"dictionary",
".",
"Key",
"=",
"reference",
"name",
".",
"Value",
"=",
"list",
"of",
"report",
"lines",
"for",
"that",
"reference"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/report_filter.py#L63-L94 | train | 235,089 |
sanger-pathogens/ariba | ariba/report_filter.py | ReportFilter._filter_dicts | def _filter_dicts(self):
'''Filters out all the report_dicts that do not pass the cutoffs. If any ref sequence
loses all of its report_dicts, then it is completely removed.'''
keys_to_remove = set()
for ref_name in self.report:
for ctg_name in self.report[ref_name]:
self.report[ref_name][ctg_name] = self._filter_list_of_dicts(self.report[ref_name][ctg_name])
if len(self.report[ref_name][ctg_name]) == 0:
keys_to_remove.add((ref_name, ctg_name))
refs_to_remove = set()
for ref_name, ctg_name in keys_to_remove:
del self.report[ref_name][ctg_name]
if len(self.report[ref_name]) == 0:
refs_to_remove.add(ref_name)
for ref_name in refs_to_remove:
del self.report[ref_name] | python | def _filter_dicts(self):
'''Filters out all the report_dicts that do not pass the cutoffs. If any ref sequence
loses all of its report_dicts, then it is completely removed.'''
keys_to_remove = set()
for ref_name in self.report:
for ctg_name in self.report[ref_name]:
self.report[ref_name][ctg_name] = self._filter_list_of_dicts(self.report[ref_name][ctg_name])
if len(self.report[ref_name][ctg_name]) == 0:
keys_to_remove.add((ref_name, ctg_name))
refs_to_remove = set()
for ref_name, ctg_name in keys_to_remove:
del self.report[ref_name][ctg_name]
if len(self.report[ref_name]) == 0:
refs_to_remove.add(ref_name)
for ref_name in refs_to_remove:
del self.report[ref_name] | [
"def",
"_filter_dicts",
"(",
"self",
")",
":",
"keys_to_remove",
"=",
"set",
"(",
")",
"for",
"ref_name",
"in",
"self",
".",
"report",
":",
"for",
"ctg_name",
"in",
"self",
".",
"report",
"[",
"ref_name",
"]",
":",
"self",
".",
"report",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
"=",
"self",
".",
"_filter_list_of_dicts",
"(",
"self",
".",
"report",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
")",
"if",
"len",
"(",
"self",
".",
"report",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
")",
"==",
"0",
":",
"keys_to_remove",
".",
"add",
"(",
"(",
"ref_name",
",",
"ctg_name",
")",
")",
"refs_to_remove",
"=",
"set",
"(",
")",
"for",
"ref_name",
",",
"ctg_name",
"in",
"keys_to_remove",
":",
"del",
"self",
".",
"report",
"[",
"ref_name",
"]",
"[",
"ctg_name",
"]",
"if",
"len",
"(",
"self",
".",
"report",
"[",
"ref_name",
"]",
")",
"==",
"0",
":",
"refs_to_remove",
".",
"add",
"(",
"ref_name",
")",
"for",
"ref_name",
"in",
"refs_to_remove",
":",
"del",
"self",
".",
"report",
"[",
"ref_name",
"]"
] | Filters out all the report_dicts that do not pass the cutoffs. If any ref sequence
loses all of its report_dicts, then it is completely removed. | [
"Filters",
"out",
"all",
"the",
"report_dicts",
"that",
"do",
"not",
"pass",
"the",
"cutoffs",
".",
"If",
"any",
"ref",
"sequence",
"loses",
"all",
"of",
"its",
"report_dicts",
"then",
"it",
"is",
"completely",
"removed",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/report_filter.py#L167-L186 | train | 235,090 |
sanger-pathogens/ariba | ariba/link.py | Link.merge | def merge(self, other):
'''Merge another link into this one. Expected that each link was created from each mate from a pair. We only know both distances to contig ends when we have read info from both mappings in a BAM file. All other info should be the same.'''
assert self.refnames == other.refnames
assert self.dirs == other.dirs
assert self.lengths == other.lengths
for i in range(2):
if self.pos[i] is None:
if other.pos[i] is None:
raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other))
self.pos[i] = other.pos[i]
else:
if other.pos[i] is not None:
raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other)) | python | def merge(self, other):
'''Merge another link into this one. Expected that each link was created from each mate from a pair. We only know both distances to contig ends when we have read info from both mappings in a BAM file. All other info should be the same.'''
assert self.refnames == other.refnames
assert self.dirs == other.dirs
assert self.lengths == other.lengths
for i in range(2):
if self.pos[i] is None:
if other.pos[i] is None:
raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other))
self.pos[i] = other.pos[i]
else:
if other.pos[i] is not None:
raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other)) | [
"def",
"merge",
"(",
"self",
",",
"other",
")",
":",
"assert",
"self",
".",
"refnames",
"==",
"other",
".",
"refnames",
"assert",
"self",
".",
"dirs",
"==",
"other",
".",
"dirs",
"assert",
"self",
".",
"lengths",
"==",
"other",
".",
"lengths",
"for",
"i",
"in",
"range",
"(",
"2",
")",
":",
"if",
"self",
".",
"pos",
"[",
"i",
"]",
"is",
"None",
":",
"if",
"other",
".",
"pos",
"[",
"i",
"]",
"is",
"None",
":",
"raise",
"Error",
"(",
"'Error merging these two links:\\n'",
"+",
"str",
"(",
"self",
")",
"+",
"'\\n'",
"+",
"str",
"(",
"other",
")",
")",
"self",
".",
"pos",
"[",
"i",
"]",
"=",
"other",
".",
"pos",
"[",
"i",
"]",
"else",
":",
"if",
"other",
".",
"pos",
"[",
"i",
"]",
"is",
"not",
"None",
":",
"raise",
"Error",
"(",
"'Error merging these two links:\\n'",
"+",
"str",
"(",
"self",
")",
"+",
"'\\n'",
"+",
"str",
"(",
"other",
")",
")"
] | Merge another link into this one. Expected that each link was created from each mate from a pair. We only know both distances to contig ends when we have read info from both mappings in a BAM file. All other info should be the same. | [
"Merge",
"another",
"link",
"into",
"this",
"one",
".",
"Expected",
"that",
"each",
"link",
"was",
"created",
"from",
"each",
"mate",
"from",
"a",
"pair",
".",
"We",
"only",
"know",
"both",
"distances",
"to",
"contig",
"ends",
"when",
"we",
"have",
"read",
"info",
"from",
"both",
"mappings",
"in",
"a",
"BAM",
"file",
".",
"All",
"other",
"info",
"should",
"be",
"the",
"same",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/link.py#L80-L93 | train | 235,091 |
sanger-pathogens/ariba | ariba/summary.py | Summary._load_fofn | def _load_fofn(cls, fofn):
'''Returns dictionary of filename -> short name. Value is None
whenever short name is not provided'''
filenames = {}
f = pyfastaq.utils.open_file_read(fofn)
for line in f:
fields = line.rstrip().split()
if len(fields) == 1:
filenames[fields[0]] = None
elif len(fields) == 2:
filenames[fields[0]] = fields[1]
else:
raise Error('Error at the following line of file ' + fofn + '. Expected at most 2 fields.\n' + line)
pyfastaq.utils.close(f)
return filenames | python | def _load_fofn(cls, fofn):
'''Returns dictionary of filename -> short name. Value is None
whenever short name is not provided'''
filenames = {}
f = pyfastaq.utils.open_file_read(fofn)
for line in f:
fields = line.rstrip().split()
if len(fields) == 1:
filenames[fields[0]] = None
elif len(fields) == 2:
filenames[fields[0]] = fields[1]
else:
raise Error('Error at the following line of file ' + fofn + '. Expected at most 2 fields.\n' + line)
pyfastaq.utils.close(f)
return filenames | [
"def",
"_load_fofn",
"(",
"cls",
",",
"fofn",
")",
":",
"filenames",
"=",
"{",
"}",
"f",
"=",
"pyfastaq",
".",
"utils",
".",
"open_file_read",
"(",
"fofn",
")",
"for",
"line",
"in",
"f",
":",
"fields",
"=",
"line",
".",
"rstrip",
"(",
")",
".",
"split",
"(",
")",
"if",
"len",
"(",
"fields",
")",
"==",
"1",
":",
"filenames",
"[",
"fields",
"[",
"0",
"]",
"]",
"=",
"None",
"elif",
"len",
"(",
"fields",
")",
"==",
"2",
":",
"filenames",
"[",
"fields",
"[",
"0",
"]",
"]",
"=",
"fields",
"[",
"1",
"]",
"else",
":",
"raise",
"Error",
"(",
"'Error at the following line of file '",
"+",
"fofn",
"+",
"'. Expected at most 2 fields.\\n'",
"+",
"line",
")",
"pyfastaq",
".",
"utils",
".",
"close",
"(",
"f",
")",
"return",
"filenames"
] | Returns dictionary of filename -> short name. Value is None
whenever short name is not provided | [
"Returns",
"dictionary",
"of",
"filename",
"-",
">",
"short",
"name",
".",
"Value",
"is",
"None",
"whenever",
"short",
"name",
"is",
"not",
"provided"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary.py#L70-L85 | train | 235,092 |
sanger-pathogens/ariba | ariba/summary.py | Summary._filter_matrix_rows | def _filter_matrix_rows(cls, matrix):
'''matrix = output from _to_matrix'''
indexes_to_keep = []
for i in range(len(matrix)):
keep_row = False
for element in matrix[i]:
if element not in {'NA', 'no'}:
keep_row = True
break
if keep_row:
indexes_to_keep.append(i)
return [matrix[i] for i in indexes_to_keep] | python | def _filter_matrix_rows(cls, matrix):
'''matrix = output from _to_matrix'''
indexes_to_keep = []
for i in range(len(matrix)):
keep_row = False
for element in matrix[i]:
if element not in {'NA', 'no'}:
keep_row = True
break
if keep_row:
indexes_to_keep.append(i)
return [matrix[i] for i in indexes_to_keep] | [
"def",
"_filter_matrix_rows",
"(",
"cls",
",",
"matrix",
")",
":",
"indexes_to_keep",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"matrix",
")",
")",
":",
"keep_row",
"=",
"False",
"for",
"element",
"in",
"matrix",
"[",
"i",
"]",
":",
"if",
"element",
"not",
"in",
"{",
"'NA'",
",",
"'no'",
"}",
":",
"keep_row",
"=",
"True",
"break",
"if",
"keep_row",
":",
"indexes_to_keep",
".",
"append",
"(",
"i",
")",
"return",
"[",
"matrix",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes_to_keep",
"]"
] | matrix = output from _to_matrix | [
"matrix",
"=",
"output",
"from",
"_to_matrix"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary.py#L223-L236 | train | 235,093 |
sanger-pathogens/ariba | ariba/summary.py | Summary._filter_matrix_columns | def _filter_matrix_columns(cls, matrix, phandango_header, csv_header):
'''phandango_header, csv_header, matrix = output from _to_matrix'''
indexes_to_keep = set()
for row in matrix:
for i in range(len(row)):
if row[i] not in {'NA', 'no'}:
indexes_to_keep.add(i)
indexes_to_keep = sorted(list(indexes_to_keep))
for i in range(len(matrix)):
matrix[i] = [matrix[i][j] for j in indexes_to_keep]
phandango_header = [phandango_header[i] for i in indexes_to_keep]
csv_header = [csv_header[i] for i in indexes_to_keep]
return phandango_header, csv_header, matrix | python | def _filter_matrix_columns(cls, matrix, phandango_header, csv_header):
'''phandango_header, csv_header, matrix = output from _to_matrix'''
indexes_to_keep = set()
for row in matrix:
for i in range(len(row)):
if row[i] not in {'NA', 'no'}:
indexes_to_keep.add(i)
indexes_to_keep = sorted(list(indexes_to_keep))
for i in range(len(matrix)):
matrix[i] = [matrix[i][j] for j in indexes_to_keep]
phandango_header = [phandango_header[i] for i in indexes_to_keep]
csv_header = [csv_header[i] for i in indexes_to_keep]
return phandango_header, csv_header, matrix | [
"def",
"_filter_matrix_columns",
"(",
"cls",
",",
"matrix",
",",
"phandango_header",
",",
"csv_header",
")",
":",
"indexes_to_keep",
"=",
"set",
"(",
")",
"for",
"row",
"in",
"matrix",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"row",
")",
")",
":",
"if",
"row",
"[",
"i",
"]",
"not",
"in",
"{",
"'NA'",
",",
"'no'",
"}",
":",
"indexes_to_keep",
".",
"add",
"(",
"i",
")",
"indexes_to_keep",
"=",
"sorted",
"(",
"list",
"(",
"indexes_to_keep",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"matrix",
")",
")",
":",
"matrix",
"[",
"i",
"]",
"=",
"[",
"matrix",
"[",
"i",
"]",
"[",
"j",
"]",
"for",
"j",
"in",
"indexes_to_keep",
"]",
"phandango_header",
"=",
"[",
"phandango_header",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes_to_keep",
"]",
"csv_header",
"=",
"[",
"csv_header",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes_to_keep",
"]",
"return",
"phandango_header",
",",
"csv_header",
",",
"matrix"
] | phandango_header, csv_header, matrix = output from _to_matrix | [
"phandango_header",
"csv_header",
"matrix",
"=",
"output",
"from",
"_to_matrix"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/summary.py#L240-L256 | train | 235,094 |
sanger-pathogens/ariba | ariba/assembly_variants.py | AssemblyVariants._get_remaining_known_ref_variants | def _get_remaining_known_ref_variants(known_ref_variants, used_ref_variants, nucmer_coords):
'''Finds variants where ref has the variant and so does the contig. Which means
that there was no mummer call to flag it up so need to look through the known
ref variants. Also need to check that the variant is in a nucmer match to an
assembly contig.'''
variants = []
for ref_variant_pos, ref_variants_set in sorted(known_ref_variants.items()):
for known_ref_variant in ref_variants_set:
if known_ref_variant not in used_ref_variants:
variant_pos_matches_contig = False
pos = known_ref_variant.variant.position
if known_ref_variant.seq_type == 'n':
ref_interval = intervals.Interval(pos, pos)
elif known_ref_variant.seq_type == 'p':
ref_interval = intervals.Interval(3 * pos, 3 * pos + 2)
else:
raise Error('Unexpected variant type "' + known_ref_variant.variant_type + '" in _get_remaining_known_ref_variants. Cannot continue')
for interval in nucmer_coords:
if ref_interval.intersects(interval):
variant_pos_matches_contig = True
break
if variant_pos_matches_contig:
variants.append((None, known_ref_variant.seq_type, None, None, None, {known_ref_variant}, set()))
return variants | python | def _get_remaining_known_ref_variants(known_ref_variants, used_ref_variants, nucmer_coords):
'''Finds variants where ref has the variant and so does the contig. Which means
that there was no mummer call to flag it up so need to look through the known
ref variants. Also need to check that the variant is in a nucmer match to an
assembly contig.'''
variants = []
for ref_variant_pos, ref_variants_set in sorted(known_ref_variants.items()):
for known_ref_variant in ref_variants_set:
if known_ref_variant not in used_ref_variants:
variant_pos_matches_contig = False
pos = known_ref_variant.variant.position
if known_ref_variant.seq_type == 'n':
ref_interval = intervals.Interval(pos, pos)
elif known_ref_variant.seq_type == 'p':
ref_interval = intervals.Interval(3 * pos, 3 * pos + 2)
else:
raise Error('Unexpected variant type "' + known_ref_variant.variant_type + '" in _get_remaining_known_ref_variants. Cannot continue')
for interval in nucmer_coords:
if ref_interval.intersects(interval):
variant_pos_matches_contig = True
break
if variant_pos_matches_contig:
variants.append((None, known_ref_variant.seq_type, None, None, None, {known_ref_variant}, set()))
return variants | [
"def",
"_get_remaining_known_ref_variants",
"(",
"known_ref_variants",
",",
"used_ref_variants",
",",
"nucmer_coords",
")",
":",
"variants",
"=",
"[",
"]",
"for",
"ref_variant_pos",
",",
"ref_variants_set",
"in",
"sorted",
"(",
"known_ref_variants",
".",
"items",
"(",
")",
")",
":",
"for",
"known_ref_variant",
"in",
"ref_variants_set",
":",
"if",
"known_ref_variant",
"not",
"in",
"used_ref_variants",
":",
"variant_pos_matches_contig",
"=",
"False",
"pos",
"=",
"known_ref_variant",
".",
"variant",
".",
"position",
"if",
"known_ref_variant",
".",
"seq_type",
"==",
"'n'",
":",
"ref_interval",
"=",
"intervals",
".",
"Interval",
"(",
"pos",
",",
"pos",
")",
"elif",
"known_ref_variant",
".",
"seq_type",
"==",
"'p'",
":",
"ref_interval",
"=",
"intervals",
".",
"Interval",
"(",
"3",
"*",
"pos",
",",
"3",
"*",
"pos",
"+",
"2",
")",
"else",
":",
"raise",
"Error",
"(",
"'Unexpected variant type \"'",
"+",
"known_ref_variant",
".",
"variant_type",
"+",
"'\" in _get_remaining_known_ref_variants. Cannot continue'",
")",
"for",
"interval",
"in",
"nucmer_coords",
":",
"if",
"ref_interval",
".",
"intersects",
"(",
"interval",
")",
":",
"variant_pos_matches_contig",
"=",
"True",
"break",
"if",
"variant_pos_matches_contig",
":",
"variants",
".",
"append",
"(",
"(",
"None",
",",
"known_ref_variant",
".",
"seq_type",
",",
"None",
",",
"None",
",",
"None",
",",
"{",
"known_ref_variant",
"}",
",",
"set",
"(",
")",
")",
")",
"return",
"variants"
] | Finds variants where ref has the variant and so does the contig. Which means
that there was no mummer call to flag it up so need to look through the known
ref variants. Also need to check that the variant is in a nucmer match to an
assembly contig. | [
"Finds",
"variants",
"where",
"ref",
"has",
"the",
"variant",
"and",
"so",
"does",
"the",
"contig",
".",
"Which",
"means",
"that",
"there",
"was",
"no",
"mummer",
"call",
"to",
"flag",
"it",
"up",
"so",
"need",
"to",
"look",
"through",
"the",
"known",
"ref",
"variants",
".",
"Also",
"need",
"to",
"check",
"that",
"the",
"variant",
"is",
"in",
"a",
"nucmer",
"match",
"to",
"an",
"assembly",
"contig",
"."
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/assembly_variants.py#L232-L260 | train | 235,095 |
sanger-pathogens/ariba | ariba/report.py | _samtools_depths_at_known_snps_all_wild | def _samtools_depths_at_known_snps_all_wild(sequence_meta, contig_name, cluster, variant_list):
'''Input is a known variants, as sequence_metadata object. The
assumption is that both the reference and the assembly have the
variant type, not wild type. The list variant_list should be a list
of pymummer.variant.Variant objects, only contaning variants to the
relevant query contig'''
ref_nuc_range = sequence_meta.variant.nucleotide_range()
if ref_nuc_range is None:
return None
bases = []
ctg_nts = []
ref_nts = []
smtls_total_depths = []
smtls_nts = []
smtls_depths = []
contig_positions = []
for ref_position in range(ref_nuc_range[0], ref_nuc_range[1]+1, 1):
nucmer_match = cluster.assembly_compare.nucmer_hit_containing_reference_position(cluster.assembly_compare.nucmer_hits, cluster.ref_sequence.id, ref_position, qry_name=contig_name)
if nucmer_match is not None:
# work out contig position. Needs indels variants to correct the position
ref_nts.append(cluster.ref_sequence[ref_position])
contig_position, in_indel = nucmer_match.qry_coords_from_ref_coord(ref_position, variant_list)
contig_positions.append(contig_position)
bases, total_depth, base_depths = cluster.samtools_vars.get_depths_at_position(contig_name, contig_position)
ctg_nts.append(cluster.assembly.sequences[contig_name][contig_position])
smtls_nts.append(bases)
smtls_total_depths.append(total_depth)
smtls_depths.append(base_depths)
ctg_nts = ';'.join(ctg_nts) if len(ctg_nts) else '.'
ref_nts = ';'.join(ref_nts) if len(ref_nts) else '.'
smtls_nts = ';'.join(smtls_nts) if len(smtls_nts) else '.'
smtls_total_depths = ';'.join([str(x)for x in smtls_total_depths]) if len(smtls_total_depths) else '.'
smtls_depths = ';'.join([str(x)for x in smtls_depths]) if len(smtls_depths) else '.'
ctg_start = str(min(contig_positions) + 1) if contig_positions is not None else '.'
ctg_end = str(max(contig_positions) + 1) if contig_positions is not None else '.'
return [str(x) for x in [
ref_nuc_range[0] + 1,
ref_nuc_range[1] + 1,
ref_nts,
ctg_start,
ctg_end,
ctg_nts,
smtls_total_depths,
smtls_nts,
smtls_depths
]] | python | def _samtools_depths_at_known_snps_all_wild(sequence_meta, contig_name, cluster, variant_list):
'''Input is a known variants, as sequence_metadata object. The
assumption is that both the reference and the assembly have the
variant type, not wild type. The list variant_list should be a list
of pymummer.variant.Variant objects, only contaning variants to the
relevant query contig'''
ref_nuc_range = sequence_meta.variant.nucleotide_range()
if ref_nuc_range is None:
return None
bases = []
ctg_nts = []
ref_nts = []
smtls_total_depths = []
smtls_nts = []
smtls_depths = []
contig_positions = []
for ref_position in range(ref_nuc_range[0], ref_nuc_range[1]+1, 1):
nucmer_match = cluster.assembly_compare.nucmer_hit_containing_reference_position(cluster.assembly_compare.nucmer_hits, cluster.ref_sequence.id, ref_position, qry_name=contig_name)
if nucmer_match is not None:
# work out contig position. Needs indels variants to correct the position
ref_nts.append(cluster.ref_sequence[ref_position])
contig_position, in_indel = nucmer_match.qry_coords_from_ref_coord(ref_position, variant_list)
contig_positions.append(contig_position)
bases, total_depth, base_depths = cluster.samtools_vars.get_depths_at_position(contig_name, contig_position)
ctg_nts.append(cluster.assembly.sequences[contig_name][contig_position])
smtls_nts.append(bases)
smtls_total_depths.append(total_depth)
smtls_depths.append(base_depths)
ctg_nts = ';'.join(ctg_nts) if len(ctg_nts) else '.'
ref_nts = ';'.join(ref_nts) if len(ref_nts) else '.'
smtls_nts = ';'.join(smtls_nts) if len(smtls_nts) else '.'
smtls_total_depths = ';'.join([str(x)for x in smtls_total_depths]) if len(smtls_total_depths) else '.'
smtls_depths = ';'.join([str(x)for x in smtls_depths]) if len(smtls_depths) else '.'
ctg_start = str(min(contig_positions) + 1) if contig_positions is not None else '.'
ctg_end = str(max(contig_positions) + 1) if contig_positions is not None else '.'
return [str(x) for x in [
ref_nuc_range[0] + 1,
ref_nuc_range[1] + 1,
ref_nts,
ctg_start,
ctg_end,
ctg_nts,
smtls_total_depths,
smtls_nts,
smtls_depths
]] | [
"def",
"_samtools_depths_at_known_snps_all_wild",
"(",
"sequence_meta",
",",
"contig_name",
",",
"cluster",
",",
"variant_list",
")",
":",
"ref_nuc_range",
"=",
"sequence_meta",
".",
"variant",
".",
"nucleotide_range",
"(",
")",
"if",
"ref_nuc_range",
"is",
"None",
":",
"return",
"None",
"bases",
"=",
"[",
"]",
"ctg_nts",
"=",
"[",
"]",
"ref_nts",
"=",
"[",
"]",
"smtls_total_depths",
"=",
"[",
"]",
"smtls_nts",
"=",
"[",
"]",
"smtls_depths",
"=",
"[",
"]",
"contig_positions",
"=",
"[",
"]",
"for",
"ref_position",
"in",
"range",
"(",
"ref_nuc_range",
"[",
"0",
"]",
",",
"ref_nuc_range",
"[",
"1",
"]",
"+",
"1",
",",
"1",
")",
":",
"nucmer_match",
"=",
"cluster",
".",
"assembly_compare",
".",
"nucmer_hit_containing_reference_position",
"(",
"cluster",
".",
"assembly_compare",
".",
"nucmer_hits",
",",
"cluster",
".",
"ref_sequence",
".",
"id",
",",
"ref_position",
",",
"qry_name",
"=",
"contig_name",
")",
"if",
"nucmer_match",
"is",
"not",
"None",
":",
"# work out contig position. Needs indels variants to correct the position",
"ref_nts",
".",
"append",
"(",
"cluster",
".",
"ref_sequence",
"[",
"ref_position",
"]",
")",
"contig_position",
",",
"in_indel",
"=",
"nucmer_match",
".",
"qry_coords_from_ref_coord",
"(",
"ref_position",
",",
"variant_list",
")",
"contig_positions",
".",
"append",
"(",
"contig_position",
")",
"bases",
",",
"total_depth",
",",
"base_depths",
"=",
"cluster",
".",
"samtools_vars",
".",
"get_depths_at_position",
"(",
"contig_name",
",",
"contig_position",
")",
"ctg_nts",
".",
"append",
"(",
"cluster",
".",
"assembly",
".",
"sequences",
"[",
"contig_name",
"]",
"[",
"contig_position",
"]",
")",
"smtls_nts",
".",
"append",
"(",
"bases",
")",
"smtls_total_depths",
".",
"append",
"(",
"total_depth",
")",
"smtls_depths",
".",
"append",
"(",
"base_depths",
")",
"ctg_nts",
"=",
"';'",
".",
"join",
"(",
"ctg_nts",
")",
"if",
"len",
"(",
"ctg_nts",
")",
"else",
"'.'",
"ref_nts",
"=",
"';'",
".",
"join",
"(",
"ref_nts",
")",
"if",
"len",
"(",
"ref_nts",
")",
"else",
"'.'",
"smtls_nts",
"=",
"';'",
".",
"join",
"(",
"smtls_nts",
")",
"if",
"len",
"(",
"smtls_nts",
")",
"else",
"'.'",
"smtls_total_depths",
"=",
"';'",
".",
"join",
"(",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"smtls_total_depths",
"]",
")",
"if",
"len",
"(",
"smtls_total_depths",
")",
"else",
"'.'",
"smtls_depths",
"=",
"';'",
".",
"join",
"(",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"smtls_depths",
"]",
")",
"if",
"len",
"(",
"smtls_depths",
")",
"else",
"'.'",
"ctg_start",
"=",
"str",
"(",
"min",
"(",
"contig_positions",
")",
"+",
"1",
")",
"if",
"contig_positions",
"is",
"not",
"None",
"else",
"'.'",
"ctg_end",
"=",
"str",
"(",
"max",
"(",
"contig_positions",
")",
"+",
"1",
")",
"if",
"contig_positions",
"is",
"not",
"None",
"else",
"'.'",
"return",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"[",
"ref_nuc_range",
"[",
"0",
"]",
"+",
"1",
",",
"ref_nuc_range",
"[",
"1",
"]",
"+",
"1",
",",
"ref_nts",
",",
"ctg_start",
",",
"ctg_end",
",",
"ctg_nts",
",",
"smtls_total_depths",
",",
"smtls_nts",
",",
"smtls_depths",
"]",
"]"
] | Input is a known variants, as sequence_metadata object. The
assumption is that both the reference and the assembly have the
variant type, not wild type. The list variant_list should be a list
of pymummer.variant.Variant objects, only contaning variants to the
relevant query contig | [
"Input",
"is",
"a",
"known",
"variants",
"as",
"sequence_metadata",
"object",
".",
"The",
"assumption",
"is",
"that",
"both",
"the",
"reference",
"and",
"the",
"assembly",
"have",
"the",
"variant",
"type",
"not",
"wild",
"type",
".",
"The",
"list",
"variant_list",
"should",
"be",
"a",
"list",
"of",
"pymummer",
".",
"variant",
".",
"Variant",
"objects",
"only",
"contaning",
"variants",
"to",
"the",
"relevant",
"query",
"contig"
] | 16a0b1916ce0e886bd22550ba2d648542977001b | https://github.com/sanger-pathogens/ariba/blob/16a0b1916ce0e886bd22550ba2d648542977001b/ariba/report.py#L85-L136 | train | 235,096 |
ethereum/eth-abi | eth_abi/utils/string.py | abbr | def abbr(value: Any, limit: int=20) -> str:
"""
Converts a value into its string representation and abbreviates that
representation based on the given length `limit` if necessary.
"""
rep = repr(value)
if len(rep) > limit:
if limit < 3:
raise ValueError('Abbreviation limit may not be less than 3')
rep = rep[:limit - 3] + '...'
return rep | python | def abbr(value: Any, limit: int=20) -> str:
"""
Converts a value into its string representation and abbreviates that
representation based on the given length `limit` if necessary.
"""
rep = repr(value)
if len(rep) > limit:
if limit < 3:
raise ValueError('Abbreviation limit may not be less than 3')
rep = rep[:limit - 3] + '...'
return rep | [
"def",
"abbr",
"(",
"value",
":",
"Any",
",",
"limit",
":",
"int",
"=",
"20",
")",
"->",
"str",
":",
"rep",
"=",
"repr",
"(",
"value",
")",
"if",
"len",
"(",
"rep",
")",
">",
"limit",
":",
"if",
"limit",
"<",
"3",
":",
"raise",
"ValueError",
"(",
"'Abbreviation limit may not be less than 3'",
")",
"rep",
"=",
"rep",
"[",
":",
"limit",
"-",
"3",
"]",
"+",
"'...'",
"return",
"rep"
] | Converts a value into its string representation and abbreviates that
representation based on the given length `limit` if necessary. | [
"Converts",
"a",
"value",
"into",
"its",
"string",
"representation",
"and",
"abbreviates",
"that",
"representation",
"based",
"on",
"the",
"given",
"length",
"limit",
"if",
"necessary",
"."
] | 0a5cab0bdeae30b77efa667379427581784f1707 | https://github.com/ethereum/eth-abi/blob/0a5cab0bdeae30b77efa667379427581784f1707/eth_abi/utils/string.py#L6-L19 | train | 235,097 |
ethereum/eth-abi | eth_abi/encoding.py | BaseEncoder.invalidate_value | def invalidate_value(
cls,
value: Any,
exc: Type[Exception]=EncodingTypeError,
msg: Optional[str]=None,
) -> None:
"""
Throws a standard exception for when a value is not encodable by an
encoder.
"""
raise exc(
"Value `{rep}` of type {typ} cannot be encoded by {cls}{msg}".format(
rep=abbr(value),
typ=type(value),
cls=cls.__name__,
msg="" if msg is None else (": " + msg),
)
) | python | def invalidate_value(
cls,
value: Any,
exc: Type[Exception]=EncodingTypeError,
msg: Optional[str]=None,
) -> None:
"""
Throws a standard exception for when a value is not encodable by an
encoder.
"""
raise exc(
"Value `{rep}` of type {typ} cannot be encoded by {cls}{msg}".format(
rep=abbr(value),
typ=type(value),
cls=cls.__name__,
msg="" if msg is None else (": " + msg),
)
) | [
"def",
"invalidate_value",
"(",
"cls",
",",
"value",
":",
"Any",
",",
"exc",
":",
"Type",
"[",
"Exception",
"]",
"=",
"EncodingTypeError",
",",
"msg",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"raise",
"exc",
"(",
"\"Value `{rep}` of type {typ} cannot be encoded by {cls}{msg}\"",
".",
"format",
"(",
"rep",
"=",
"abbr",
"(",
"value",
")",
",",
"typ",
"=",
"type",
"(",
"value",
")",
",",
"cls",
"=",
"cls",
".",
"__name__",
",",
"msg",
"=",
"\"\"",
"if",
"msg",
"is",
"None",
"else",
"(",
"\": \"",
"+",
"msg",
")",
",",
")",
")"
] | Throws a standard exception for when a value is not encodable by an
encoder. | [
"Throws",
"a",
"standard",
"exception",
"for",
"when",
"a",
"value",
"is",
"not",
"encodable",
"by",
"an",
"encoder",
"."
] | 0a5cab0bdeae30b77efa667379427581784f1707 | https://github.com/ethereum/eth-abi/blob/0a5cab0bdeae30b77efa667379427581784f1707/eth_abi/encoding.py#L78-L95 | train | 235,098 |
ethereum/eth-abi | eth_abi/base.py | parse_tuple_type_str | def parse_tuple_type_str(old_from_type_str):
"""
Used by BaseCoder subclasses as a convenience for implementing the
``from_type_str`` method required by ``ABIRegistry``. Useful if normalizing
then parsing a tuple type string is required in that method.
"""
@functools.wraps(old_from_type_str)
def new_from_type_str(cls, type_str, registry):
normalized_type_str = normalize(type_str)
abi_type = parse(normalized_type_str)
type_str_repr = repr(type_str)
if type_str != normalized_type_str:
type_str_repr = '{} (normalized to {})'.format(
type_str_repr,
repr(normalized_type_str),
)
if not isinstance(abi_type, TupleType):
raise ValueError(
'Cannot create {} for non-tuple type {}'.format(
cls.__name__,
type_str_repr,
)
)
abi_type.validate()
return old_from_type_str(cls, abi_type, registry)
return classmethod(new_from_type_str) | python | def parse_tuple_type_str(old_from_type_str):
"""
Used by BaseCoder subclasses as a convenience for implementing the
``from_type_str`` method required by ``ABIRegistry``. Useful if normalizing
then parsing a tuple type string is required in that method.
"""
@functools.wraps(old_from_type_str)
def new_from_type_str(cls, type_str, registry):
normalized_type_str = normalize(type_str)
abi_type = parse(normalized_type_str)
type_str_repr = repr(type_str)
if type_str != normalized_type_str:
type_str_repr = '{} (normalized to {})'.format(
type_str_repr,
repr(normalized_type_str),
)
if not isinstance(abi_type, TupleType):
raise ValueError(
'Cannot create {} for non-tuple type {}'.format(
cls.__name__,
type_str_repr,
)
)
abi_type.validate()
return old_from_type_str(cls, abi_type, registry)
return classmethod(new_from_type_str) | [
"def",
"parse_tuple_type_str",
"(",
"old_from_type_str",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"old_from_type_str",
")",
"def",
"new_from_type_str",
"(",
"cls",
",",
"type_str",
",",
"registry",
")",
":",
"normalized_type_str",
"=",
"normalize",
"(",
"type_str",
")",
"abi_type",
"=",
"parse",
"(",
"normalized_type_str",
")",
"type_str_repr",
"=",
"repr",
"(",
"type_str",
")",
"if",
"type_str",
"!=",
"normalized_type_str",
":",
"type_str_repr",
"=",
"'{} (normalized to {})'",
".",
"format",
"(",
"type_str_repr",
",",
"repr",
"(",
"normalized_type_str",
")",
",",
")",
"if",
"not",
"isinstance",
"(",
"abi_type",
",",
"TupleType",
")",
":",
"raise",
"ValueError",
"(",
"'Cannot create {} for non-tuple type {}'",
".",
"format",
"(",
"cls",
".",
"__name__",
",",
"type_str_repr",
",",
")",
")",
"abi_type",
".",
"validate",
"(",
")",
"return",
"old_from_type_str",
"(",
"cls",
",",
"abi_type",
",",
"registry",
")",
"return",
"classmethod",
"(",
"new_from_type_str",
")"
] | Used by BaseCoder subclasses as a convenience for implementing the
``from_type_str`` method required by ``ABIRegistry``. Useful if normalizing
then parsing a tuple type string is required in that method. | [
"Used",
"by",
"BaseCoder",
"subclasses",
"as",
"a",
"convenience",
"for",
"implementing",
"the",
"from_type_str",
"method",
"required",
"by",
"ABIRegistry",
".",
"Useful",
"if",
"normalizing",
"then",
"parsing",
"a",
"tuple",
"type",
"string",
"is",
"required",
"in",
"that",
"method",
"."
] | 0a5cab0bdeae30b77efa667379427581784f1707 | https://github.com/ethereum/eth-abi/blob/0a5cab0bdeae30b77efa667379427581784f1707/eth_abi/base.py#L80-L110 | train | 235,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.