def time_records(
data,
dates=None,
start_date=None,
freq=None,
mask=nomask,
dtype=None,
copy=False,
fill_value=None,
keep_mask=True,
hard_mask=False,
):
"""
Creates a TimeSeriesRecords object.
Parameters
----------
data : array_like
Data portion of the array. Any data that is valid for constructing a
MaskedArray can be used here. May also be a TimeSeries object.
dates : {None, DateArray}, optional
A sequence of dates corresponding to each entry.
If None, the dates will be constructed as a DateArray with the same
length as ``data``, starting at ``start_date`` with frequency ``freq``.
start_date : {Date}, optional
Date corresponding to the first entry of the data (index 0).
This parameter must be a valid Date object, and is mandatory if ``dates``
is None and if ``data`` has a length greater or equal to 1.
freq : {freq_spec}, optional
A valid frequency specification, as a string or an integer.
This parameter is mandatory if ``dates`` is None.
mask : {nomask, sequence}, optional
Mask. Must be convertible to an array of booleans with
the same shape as data: True indicates a masked (eg.,
invalid) data.
dtype : {dtype}, optional
Data type of the output.
If dtype is None, the type of the data argument (`data.dtype`) is used.
If dtype is not None and different from `data.dtype`, a copy is performed.
copy : {False, True}, optional
Whether to copy the input data (True), or to use a reference instead.
Note: data are NOT copied by default.
fill_value : {var}, optional
Value used to fill in the masked values when necessary.
If None, a default based on the datatype is used.
keep_mask : {True, boolean}, optional
Whether to combine mask with the mask of the input data,
if any (True), or to use only mask for the output (False).
hard_mask : {False, boolean}, optional
Whether to use a hard mask or not.
With a hard mask, masked values cannot be unmasked.
Notes
-----
* All other parameters that are accepted by the :func:`numpy.ma.array`
function in the :mod:`numpy.ma` module are also accepted by this function.
* The date portion of the time series must be specified in one of the
following ways:
* specify a TimeSeries object for the ``data`` parameter.
* pass a DateArray for the ``dates`` parameter.
* specify a start_date (a continuous DateArray will be automatically
constructed for the dates portion).
* specify just a frequency (for TimeSeries of size zero).
"""
series = time_series(
data,
dates=dates,
start_date=start_date,
freq=freq,
mask=mask,
dtype=dtype,
copy=copy,
fill_value=fill_value,
keep_mask=keep_mask,
hard_mask=hard_mask,
)
return series.view(TimeSeriesRecords)
def tsfromtxt(fname,
dtype=None,
freq='U',
comments='#',
delimiter=None,
skip_header=0,
skip_footer=0,
skiprows=0,
converters=None,
dateconverter=None,
missing='',
missing_values=None,
filling_values=None,
usecols=None,
datecols=None,
names=None,
excludelist=None,
deletechars=None,
autostrip=True,
case_sensitive=True,
defaultfmt="f%i",
unpack=None,
loose=True,
asrecarray=False,
invalid_raise=True):
"""
Load a TimeSeries from a text file.
Each line of the input after the first `skiprows` ones is split at
`delimiter`. Characters occuring after `comments` are discarded.
If a column is named ``'dates'`` (case insensitive), it is used to define
the dates. The ``freq`` parameter should be set to the expected frequency of
the output series.
If the date information spans several columns (for example, year in col #1,
month in col #2...), a specific conversion function must be defined with
the ``dateconverter`` parameter. This function should accept as many inputs
as date columns, and return a valid :class:`Date` object.
Parameters
----------
fname : file or string
File or filename to read.
If the file extension is ``.gz`` or ``.bz2``, the file is first
decompressed.
dtype : data-type, optional
Data type of the resulting array.
If it is a structured data-type, the resulting array is 1-dimensional,
and each row is interpreted as an element of the array. In this case,
the number of columns used must match the number of fields in the dtype
and the names of each field are set by the corresponding name of the dtype.
If None, the dtypes will be determined by the contents of each
column, individually.
comments : {string}, optional
The character used to indicate the start of a comment.
All the characters occurring on a line after a comment are discarded.
delimiter : {string}, optional
The string used to separate values. By default, any consecutive
whitespace act as delimiter.
skip_header : int, optional
The numbers of lines to skip at the beginning of the file.
skip_footer : int, optional
The numbers of lines to skip at the end of the file
converters : variable or None, optional
The set of functions that convert the data of a column to a value.
The converters can also be used to provide a default value
for missing data: ``converters = {3: lambda s: float(s or 0)}``.
dateconverter : {function}, optional
The function to convert the date information to a :class:`Date` object.
This function requires as many parameters as number of ``datecols``.
This parameter is mandatory if ``dtype=None``.
missing_values : variable or None, optional
The set of strings corresponding to missing data.
filling_values : variable or None, optional
The set of values to be used as default when the data are missing.
usecols : sequence or None, optional
Which columns to read, with 0 being the first. For example,
``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
datecols : {None, int, sequence}, optional
Which columns store the date information.
names : {None, True, str, sequence}, optional
If `names` is True, the field names are read from the first valid line
after the first `skiprows` lines.
If `names` is a sequence or a single-string of comma-separated names,
the names will be used to define the field names in a structured dtype.
If `names` is None, the names of the dtype fields will be used, if any.
excludelist : sequence, optional
A list of names to exclude. This list is appended to the default list
['return','file','print']. Excluded names are appended an underscore:
for example, `file` would become `file_`.
deletechars : str, optional
A string combining invalid characters that must be deleted from the
names.
defaultfmt : str, optional
A format used to define default field names, such as "f%i" or "f_%02i".
autostrip : bool, optional
Whether to automatically strip white spaces from the variables.
case_sensitive : {True, False, 'upper', 'lower'}, optional
If True, field names are case sensitive.
If False or 'upper', field names are converted to upper case.
If 'lower', field names are converted to lower case.
unpack : bool, optional
If True, the returned array is transposed, so that arguments may be
unpacked using ``x, y, z = loadtxt(...)``.
asrecarray : {False, True}, optional
Whether to return a TimeSeriesRecords or a series with a structured
dtype.
invalid_raise : bool, optional
If True, an exception is raised if an inconsistency is detected in the
number of columns.
If False, a warning is emitted and the offending lines are skipped.
Returns
-------
out : MaskedArray
Data read from the text file.
See Also
--------
numpy.lib.io.genfromtxt
Equivalent function for standard arrays
Notes
-----
* When spaces are used as delimiters, or when no delimiter has been given
as input, there should not be any missing data between two fields.
* When the variable are named (either by a flexible dtype or with `names`,
there must not be any header in the file (else a :exc:`ValueError`
exception is raised).
* If ``names`` is True or a sequence of strings, these names overwrite
the fields names of a structured array.
* The sequence of names must NOT take the date columns into account.
* If the datatype is not given explicitly (``dtype=None``),
a :keyword:`dateconverter` must be given explicitly.
* If the ``dtype`` is given explicitly,
it must NOT refer to the date columns.
* By default, the types of variables is defined from the values encountered
in the file (``dtype=None``). This is *NOT* the default for np.genfromtxt.
Examples
--------
>>> data = "year, month, a, b\\n 2001, 01, 0.0, 10.\\n 2001, 02, 1.1, 11."
>>> dateconverter = lambda y, m: Date('M', year=int(y), month=int(m))
>>> series = tsfromtxt(StringIO.StringIO(data), delimiter=',', names=True,
... datecols=(0,1), dateconverter=dateconverter,)
>>> series
timeseries([(0.0, 10.0) (1.1, 11.0)],
dtype = [('a', '<f8'), ('b', '<f8')],
dates = [Jan-2001 Feb-2001],
freq = M)
>>> series = tsfromtxt(StringIO.StringIO(data), delimiter=",",
... datecols=(0, 1), dateconverter=dateconverter,
... names="A, B", skip_header=1)
timeseries([(0.0, 10.0) (1.1000000000000001, 11.0)],
dtype = [('A', '<f8'), ('B', '<f8')],
dates = [Jan-2001 Feb-2001],
freq = M)
"""
# Update the date converter ...........................
converters = converters or {}
dateconv = dateconverter or None
if dateconv is None:
dateconv = lambda s: Date(freq, string=s)
if 'dates' in converters:
dateconv = converters['dates']
del (converters['dates'])
# Make sure `datecols` is a sequence ..................
if datecols is not None:
try:
datecols = [_.strip() for _ in datecols.split(",")]
except AttributeError:
try:
datecols = list(datecols)
except TypeError:
datecols = [
datecols,
]
# ... and update the converters
converters.update((i, str) for i in datecols)
# Save the initial names and dtypes ...................
idtype = dtype
if isinstance(names, basestring):
names = names.split(",")
inames = names
# Update the dtype (if needed) ........................
if (dtype is not None):
# Crash if we can't find the datecols
if datecols is None:
raise TypeError("No column selected for the dates!")
# Make sure dtype is a valid np.dtype and make a copy
dtype = easy_dtype(dtype, names=names)
idtype = dtype
inames = dtype.names
if inames is not None:
nbfields = len(inames) + len(datecols)
# Create a new dtype description and a set of names
dtype = [''] * nbfields
names = [''] * nbfields
idx = range(nbfields)
for i in datecols:
if i < 0:
i += nbfields
del idx[idx.index(i)]
# Set the default dtype for date columns, as np.object
# (we can't use string as we don't know the final size)
dtype[i] = ('', np.object)
convdict = {
'b': bool,
'i': int,
'l': int,
'u': int,
'f': float,
'd': float,
'g': float,
'c': complex,
'D': complex,
'S': str,
'U': str,
'a': str
}
converter_update = []
for (i, name) in zip(idx, inames):
field = idtype[name]
dtype[i] = (name, field)
converter_update.append((i, convdict[field.char]))
names[i] = name
converters.update(converter_update)
elif names not in (True, None):
# Make sure that we saved the names as a list
inames = list(inames)
# Get the list of columns to use
if usecols is None:
nbcols = len(datecols) + len(inames)
names = [''] * nbcols
ucols = range(nbcols)
else:
names = [''] * (max(usecols) + 1)
ucols = usecols
# Fill the list of names:
for i in ucols:
if i in datecols:
names[i] = "__%i" % i
else:
names[i] = inames.pop(0)
#
# Update the optional arguments ...
kwargs = dict(dtype=dtype,
comments=comments,
delimiter=delimiter,
skiprows=skiprows,
converters=converters,
skip_header=skip_header,
skip_footer=skip_footer,
missing=missing,
missing_values=missing_values,
filling_values=filling_values,
usecols=usecols,
unpack=unpack,
names=names,
excludelist=excludelist,
deletechars=deletechars,
case_sensitive=case_sensitive,
defaultfmt=defaultfmt,
autostrip=autostrip,
loose=loose,
invalid_raise=invalid_raise,
usemask=True)
# Get the raw data ................
mrec = genfromtxt(fname, **kwargs)
if not mrec.shape:
mrec.shape = -1
names = mrec.dtype.names
# Revert to the original dtype.....
dtype = idtype
# Get the date columns ................................
if datecols is None:
import re
datespattern = re.compile("'?_?dates?'?", re.IGNORECASE)
datecols = [
i for (i, name) in enumerate(names or ())
if datespattern.search(name)
]
if not datecols:
raise TypeError("No column selected for the dates!")
else:
# We have `datecols` already, make sure the indices are positive
# (the nb of fields might still be undefined)
nbfields = len(names)
for (i, v) in enumerate(datecols):
if (v < 0):
datecols[i] = v + nbfields
# Fix the date columns if usecols was given
if usecols is not None:
datecols = tuple([list(usecols).index(d) for d in datecols])
# Get the date info ...............
if names:
_dates = [mrec[names[i]] for i in datecols]
else:
_dates = [mrec[:, i] for i in datecols]
# Convert the date columns to a date_array
if len(_dates) == 1:
_dates = np.array(_dates[0], copy=False, ndmin=1)
dates = date_array([dateconv(args) for args in _dates],
freq=freq,
autosort=False)
else:
dates = date_array([dateconv(*args) for args in zip(*_dates)],
freq=freq,
autosort=False)
# Resort the array according to the dates
sortidx = dates.argsort()
dates = dates[sortidx]
mrec = mrec[sortidx]
# Get the dtype from the named columns (if any), or just use the initial one
mdtype = mrec.dtype
if mdtype.names:
newdescr = [
descr for (i, descr) in enumerate(mdtype.descr)
if i not in datecols
]
output = time_series(ma.empty((len(mrec), ), dtype=newdescr),
dates=dates)
for name in output.dtype.names:
output[name] = mrec[name]
if (idtype is not None):
if (idtype.names is None):
dtype = (idtype, len(output.dtype.names))
else:
dtype = idtype
output = output.view(dtype)
else:
dataidx = [i for i in range(mrec.shape[-1]) if i not in datecols]
if len(dataidx) == 1:
dataidx = dataidx[0]
output = time_series(mrec[:, dataidx], dates=dates)
#
if asrecarray:
from trecords import TimeSeriesRecords
return output.view(TimeSeriesRecords)
return output
def time_records(data, dates=None, start_date=None, freq=None, mask=nomask,
dtype=None, copy=False, fill_value=None, keep_mask=True,
hard_mask=False):
"""
Creates a TimeSeriesRecords object.
Parameters
----------
data : array_like
Data portion of the array. Any data that is valid for constructing a
MaskedArray can be used here. May also be a TimeSeries object.
dates : {None, DateArray}, optional
A sequence of dates corresponding to each entry.
If None, the dates will be constructed as a DateArray with the same
length as ``data``, starting at ``start_date`` with frequency ``freq``.
start_date : {Date}, optional
Date corresponding to the first entry of the data (index 0).
This parameter must be a valid Date object, and is mandatory if ``dates``
is None and if ``data`` has a length greater or equal to 1.
freq : {freq_spec}, optional
A valid frequency specification, as a string or an integer.
This parameter is mandatory if ``dates`` is None.
mask : {nomask, sequence}, optional
Mask. Must be convertible to an array of booleans with
the same shape as data: True indicates a masked (eg.,
invalid) data.
dtype : {dtype}, optional
Data type of the output.
If dtype is None, the type of the data argument (`data.dtype`) is used.
If dtype is not None and different from `data.dtype`, a copy is performed.
copy : {False, True}, optional
Whether to copy the input data (True), or to use a reference instead.
Note: data are NOT copied by default.
fill_value : {var}, optional
Value used to fill in the masked values when necessary.
If None, a default based on the datatype is used.
keep_mask : {True, boolean}, optional
Whether to combine mask with the mask of the input data,
if any (True), or to use only mask for the output (False).
hard_mask : {False, boolean}, optional
Whether to use a hard mask or not.
With a hard mask, masked values cannot be unmasked.
Notes
-----
* All other parameters that are accepted by the :func:`numpy.ma.array`
function in the :mod:`numpy.ma` module are also accepted by this function.
* The date portion of the time series must be specified in one of the
following ways:
* specify a TimeSeries object for the ``data`` parameter.
* pass a DateArray for the ``dates`` parameter.
* specify a start_date (a continuous DateArray will be automatically
constructed for the dates portion).
* specify just a frequency (for TimeSeries of size zero).
"""
series = time_series(data, dates=dates, start_date=start_date, freq=freq,
mask=mask, dtype=dtype, copy=copy,
fill_value=fill_value, keep_mask=keep_mask,
hard_mask=hard_mask)
return series.view(TimeSeriesRecords)
def tsfromtxt(fname, dtype=None, freq='U', comments='#', delimiter=None,
skip_header=0, skip_footer=0, skiprows=0,
converters=None, dateconverter=None,
missing='', missing_values=None, filling_values=None,
usecols=None, datecols=None,
names=None, excludelist=None, deletechars=None, autostrip=True,
case_sensitive=True, defaultfmt="f%i", unpack=None, loose=True,
asrecarray=False, invalid_raise=True):
"""
Load a TimeSeries from a text file.
Each line of the input after the first `skiprows` ones is split at
`delimiter`. Characters occuring after `comments` are discarded.
If a column is named ``'dates'`` (case insensitive), it is used to define
the dates. The ``freq`` parameter should be set to the expected frequency of
the output series.
If the date information spans several columns (for example, year in col #1,
month in col #2...), a specific conversion function must be defined with
the ``dateconverter`` parameter. This function should accept as many inputs
as date columns, and return a valid :class:`Date` object.
Parameters
----------
fname : file or string
File or filename to read.
If the file extension is ``.gz`` or ``.bz2``, the file is first
decompressed.
dtype : data-type, optional
Data type of the resulting array.
If it is a structured data-type, the resulting array is 1-dimensional,
and each row is interpreted as an element of the array. In this case,
the number of columns used must match the number of fields in the dtype
and the names of each field are set by the corresponding name of the dtype.
If None, the dtypes will be determined by the contents of each
column, individually.
comments : {string}, optional
The character used to indicate the start of a comment.
All the characters occurring on a line after a comment are discarded.
delimiter : {string}, optional
The string used to separate values. By default, any consecutive
whitespace act as delimiter.
skip_header : int, optional
The numbers of lines to skip at the beginning of the file.
skip_footer : int, optional
The numbers of lines to skip at the end of the file
converters : variable or None, optional
The set of functions that convert the data of a column to a value.
The converters can also be used to provide a default value
for missing data: ``converters = {3: lambda s: float(s or 0)}``.
dateconverter : {function}, optional
The function to convert the date information to a :class:`Date` object.
This function requires as many parameters as number of ``datecols``.
This parameter is mandatory if ``dtype=None``.
missing_values : variable or None, optional
The set of strings corresponding to missing data.
filling_values : variable or None, optional
The set of values to be used as default when the data are missing.
usecols : sequence or None, optional
Which columns to read, with 0 being the first. For example,
``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
datecols : {None, int, sequence}, optional
Which columns store the date information.
names : {None, True, str, sequence}, optional
If `names` is True, the field names are read from the first valid line
after the first `skiprows` lines.
If `names` is a sequence or a single-string of comma-separated names,
the names will be used to define the field names in a structured dtype.
If `names` is None, the names of the dtype fields will be used, if any.
excludelist : sequence, optional
A list of names to exclude. This list is appended to the default list
['return','file','print']. Excluded names are appended an underscore:
for example, `file` would become `file_`.
deletechars : str, optional
A string combining invalid characters that must be deleted from the
names.
defaultfmt : str, optional
A format used to define default field names, such as "f%i" or "f_%02i".
autostrip : bool, optional
Whether to automatically strip white spaces from the variables.
case_sensitive : {True, False, 'upper', 'lower'}, optional
If True, field names are case sensitive.
If False or 'upper', field names are converted to upper case.
If 'lower', field names are converted to lower case.
unpack : bool, optional
If True, the returned array is transposed, so that arguments may be
unpacked using ``x, y, z = loadtxt(...)``
usemask : bool, optional
If True, return a masked array.
If False, return a regular array.
asrecarray : {False, True}, optional
Whether to return a TimeSeriesRecords or a series with a structured
dtype.
invalid_raise : bool, optional
If True, an exception is raised if an inconsistency is detected in the
number of columns.
If False, a warning is emitted and the offending lines are skipped.
Returns
-------
out : MaskedArray
Data read from the text file.
See Also
--------
numpy.lib.io.genfromtxt
Equivalent function for standard arrays
Notes
-----
* When spaces are used as delimiters, or when no delimiter has been given
as input, there should not be any missing data between two fields.
* When the variable are named (either by a flexible dtype or with `names`,
there must not be any header in the file (else a :exc:`ValueError`
exception is raised).
* If ``names`` is True or a sequence of strings, these names overwrite
the fields names of a structured array.
* The sequence of names must NOT take the date columns into account.
* If the datatype is not given explicitly (``dtype=None``),
a :keyword:`dateconverter` must be given explicitly.
* If the ``dtype`` is given explicitly,
it must NOT refer to the date columns.
Examples
--------
>>> data = "year, month, a, b\\n 2001, 01, 0.0, 10.\\n 2001, 02, 1.1, 11."
>>> dateconverter = lambda y, m: Date('M', year=int(y), month=int(m))
>>> series = tsfromtxt(StringIO.StringIO(data), delimiter=',', names=True,
... datecols=(0,1), dateconverter=dateconverter,)
>>> series
timeseries([(0.0, 10.0) (1.1, 11.0)],
dtype = [('a', '<f8'), ('b', '<f8')],
dates = [Jan-2001 Feb-2001],
freq = M)
>>> series = tsfromtxt(StringIO.StringIO(data), delimiter=",",
... datecols=(0, 1), dateconverter=dateconverter,
... names="A, B", skip_header=1)
timeseries([(0.0, 10.0) (1.1000000000000001, 11.0)],
dtype = [('A', '<f8'), ('B', '<f8')],
dates = [Jan-2001 Feb-2001],
freq = M)
"""
# Update the date converter ...........................
converters = converters or {}
dateconv = dateconverter or None
if dateconv is None:
dateconv = lambda s: Date(freq, string=s)
if 'dates' in converters:
dateconv = converters['dates']
del(converters['dates'])
# Make sure `datecols` is a sequence ..................
if datecols is not None:
try:
datecols = [_.strip() for _ in datecols.split(",")]
except AttributeError:
try:
datecols = list(datecols)
except TypeError:
datecols = [datecols, ]
# ... and update the converters
converters.update((i, str) for i in datecols)
# Save the initial names and dtypes ...................
idtype = dtype
if isinstance(names, basestring):
names = names.split(",")
inames = names
# Update the dtype (if needed) ........................
if (dtype is not None):
# Crash if we can't find the datecols
if datecols is None:
raise TypeError("No column selected for the dates!")
# Make sure dtype is a valid np.dtype and make a copy
dtype = easy_dtype(dtype, names=names)
idtype = dtype
inames = dtype.names
if inames is not None:
nbfields = len(inames) + len(datecols)
# Create a new dtype description and a set of names
dtype = [''] * nbfields
names = [''] * nbfields
idx = range(nbfields)
for i in datecols:
if i < 0:
i += nbfields
del idx[idx.index(i)]
# Set the default dtype for date columns, as np.object
# (we can't use string as we don't know the final size)
dtype[i] = ('', np.object)
convdict = {'b': bool, 'i': int, 'l':int, 'u': int,
'f': float, 'd': float, 'g': float,
'c': complex, 'D': complex,
'S': str, 'U': str, 'a': str}
converter_update = []
for (i, name) in zip(idx, inames):
field = idtype[name]
dtype[i] = (name, field)
converter_update.append((i, convdict[field.char]))
names[i] = name
converters.update(converter_update)
elif names not in (True, None):
# Store the initial names and create a new list
nbnames = len(datecols) + len(inames)
names = [''] * nbnames
# Find where the names should go in the new list
idx = range(nbnames)
for (i, k) in enumerate(datecols):
if k < 0:
k += nbnames
del idx[idx.index(k)]
names[k] = "_tmp%i" % i
for (i, k) in zip(idx, inames):
names[i] = k
#
# Update the optional arguments ...
kwargs = dict(dtype=dtype, comments=comments, delimiter=delimiter,
skiprows=skiprows, converters=converters,
skip_header=skip_header, skip_footer=skip_footer,
missing=missing, missing_values=missing_values,
filling_values=filling_values,
usecols=usecols, unpack=unpack, names=names,
excludelist=excludelist, deletechars=deletechars,
case_sensitive=case_sensitive, defaultfmt=defaultfmt,
autostrip=autostrip, loose=loose, invalid_raise=invalid_raise,
usemask=True)
# Get the raw data ................
mrec = genfromtxt(fname, **kwargs)
if not mrec.shape:
mrec.shape = -1
names = mrec.dtype.names
# Revert to the original dtype.....
dtype = idtype
# Get the date columns ................................
if datecols is None:
import re
datespattern = re.compile("'?_?dates?'?", re.IGNORECASE)
datecols = [i for (i, name) in enumerate(names or ())
if datespattern.search(name)]
if not datecols:
raise TypeError("No column selected for the dates!")
else:
# We have `datecols` already, make sure the indices are positive
# (the nb of fields might still be undefined)
nbfields = len(names)
for (i, v) in enumerate(datecols):
if (v < 0):
datecols[i] = v + nbfields
# Fix the date columns if usecols was given
if usecols is not None:
datecols = tuple([list(usecols).index(d) for d in datecols])
# Get the date info ...............
if names:
_dates = [mrec[names[i]] for i in datecols]
else:
_dates = [mrec[:, i] for i in datecols]
# Convert the date columns to a date_array
if len(_dates) == 1:
_dates = np.array(_dates[0], copy=False, ndmin=1)
dates = date_array([dateconv(args) for args in _dates],
freq=freq, autosort=False)
else:
dates = date_array([dateconv(*args) for args in zip(*_dates)],
freq=freq, autosort=False)
# Resort the array according to the dates
sortidx = dates.argsort()
dates = dates[sortidx]
mrec = mrec[sortidx]
# Get the dtype from the named columns (if any), or just use the initial one
mdtype = mrec.dtype
if mdtype.names:
newdescr = [descr for (i, descr) in enumerate(mdtype.descr)
if i not in datecols]
output = time_series(ma.empty((len(mrec),), dtype=newdescr),
dates=dates)
for name in output.dtype.names:
output[name] = mrec[name]
if (idtype is not None):
if (idtype.names is None):
dtype = (idtype, len(output.dtype.names))
else:
dtype = idtype
output = output.view(dtype)
else:
dataidx = [i for i in range(mrec.shape[-1]) if i not in datecols]
if len(dataidx) == 1:
dataidx = dataidx[0]
output = time_series(mrec[:, dataidx], dates=dates)
#
if asrecarray:
from trecords import TimeSeriesRecords
return output.view(TimeSeriesRecords)
return output
################################################################################
if __name__ == "__main__":
import numpy as N
from maskedarray.testutils import assert_equal
if 1:
d = N.arange(5)
m = MA.make_mask([1, 0, 0, 1, 1])
base_d = N.r_[d, d[::-1]].reshape(2, -1).T
base_m = N.r_[[m, m[::-1]]].T
base = MA.array(base_d, mask=base_m)
mrec = MR.fromarrays(base.T)
dlist = ["2007-%02i" % (i + 1) for i in d]
dates = date_array(dlist)
ts = time_series(mrec, dates)
mts = MultiTimeSeries(mrec, dates)
self_data = [d, m, mrec, dlist, dates, ts, mts]
assert isinstance(mts.f0, TimeSeries)
if 0:
mts[:2] = 5
assert_equal(mts.f0._data, [5, 5, 2, 3, 4])
assert_equal(mts.f1._data, [5, 5, 2, 1, 0])
assert_equal(mts.f0._mask, [0, 0, 0, 1, 1])
assert_equal(mts.f1._mask, [0, 0, 0, 0, 1])
mts.harden_mask()
mts[-2:] = 5
assert_equal(mts.f0._data, [5, 5, 2, 3, 4])
assert_equal(mts.f1._data, [5, 5, 2, 5, 0])