def test01_MultidimLeaves(self):
"""Creating new nodes with multidimensional time elements."""
# Table creation.
class MyTimeRow(tb.IsDescription):
intcol = tb.IntCol(shape=(2, 1))
t32col = tb.Time32Col(shape=(2, 1))
t64col = tb.Time64Col(shape=(2, 1))
self.h5file.create_table('/', 'table', MyTimeRow)
# VLArray creation.
self.h5file.create_vlarray('/', 'vlarray4',
tb.Time32Atom(shape=(2, 1)))
self.h5file.create_vlarray('/', 'vlarray8',
tb.Time64Atom(shape=(2, 1)))
# EArray creation.
self.h5file.create_earray('/',
'earray4',
tb.Time32Atom(),
shape=(0, 2, 1))
self.h5file.create_earray('/',
'earray8',
tb.Time64Atom(),
shape=(0, 2, 1))
def test00_UnidimLeaves(self):
"Creating new nodes with unidimensional time elements."
# Table creation.
class MyTimeRow(tables.IsDescription):
intcol = tables.IntCol()
t32col = tables.Time32Col()
t64col = tables.Time64Col()
self.h5file.create_table('/', 'table', MyTimeRow)
# VLArray creation.
self.h5file.create_vlarray('/', 'vlarray4', tables.Time32Atom())
self.h5file.create_vlarray('/', 'vlarray8', tables.Time64Atom())
# EArray creation.
self.h5file.create_earray('/', 'earray4',
tables.Time32Atom(), shape=(0,))
self.h5file.create_earray('/', 'earray8',
tables.Time64Atom(), shape=(0,))
class OpenTestCase(common.TempFileMixin, common.PyTablesTestCase):
"""Tests opening a file with Time nodes."""
# The description used in the test Table.
class MyTimeRow(tb.IsDescription):
t32col = tb.Time32Col(shape=(2, 1))
t64col = tb.Time64Col(shape=(2, 1))
# The atoms used in the test VLArrays.
myTime32Atom = tb.Time32Atom(shape=(2, 1))
myTime64Atom = tb.Time64Atom(shape=(2, 1))
def setUp(self):
super().setUp()
# Create test Table.
self.h5file.create_table('/', 'table', self.MyTimeRow)
# Create test VLArrays.
self.h5file.create_vlarray('/', 'vlarray4', self.myTime32Atom)
self.h5file.create_vlarray('/', 'vlarray8', self.myTime64Atom)
self._reopen()
def test00_OpenFile(self):
"""Opening a file with Time nodes."""
# Test the Table node.
tbl = self.h5file.root.table
self.assertEqual(tbl.coldtypes['t32col'],
self.MyTimeRow.columns['t32col'].dtype,
"Column dtypes do not match.")
self.assertEqual(tbl.coldtypes['t64col'],
self.MyTimeRow.columns['t64col'].dtype,
"Column dtypes do not match.")
# Test the VLArray nodes.
vla4 = self.h5file.root.vlarray4
self.assertEqual(vla4.atom.dtype, self.myTime32Atom.dtype,
"Atom types do not match.")
self.assertEqual(vla4.atom.shape, self.myTime32Atom.shape,
"Atom shapes do not match.")
vla8 = self.h5file.root.vlarray8
self.assertEqual(vla8.atom.dtype, self.myTime64Atom.dtype,
"Atom types do not match.")
self.assertEqual(vla8.atom.shape, self.myTime64Atom.shape,
"Atom shapes do not match.")
def test01_OpenFileStype(self):
"""Opening a file with Time nodes, comparing Atom.stype."""
# Test the Table node.
tbl = self.h5file.root.table
self.assertEqual(tbl.coltypes['t32col'],
self.MyTimeRow.columns['t32col'].type,
"Column types do not match.")
self.assertEqual(tbl.coltypes['t64col'],
self.MyTimeRow.columns['t64col'].type,
"Column types do not match.")
# Test the VLArray nodes.
vla4 = self.h5file.root.vlarray4
self.assertEqual(vla4.atom.type, self.myTime32Atom.type,
"Atom types do not match.")
vla8 = self.h5file.root.vlarray8
self.assertEqual(vla8.atom.type, self.myTime64Atom.type,
"Atom types do not match.")
class CompareTestCase(common.TempFileMixin, common.PyTablesTestCase):
"""Tests whether stored and retrieved time data is kept the same."""
# The description used in the test Table.
class MyTimeRow(tb.IsDescription):
t32col = tb.Time32Col(pos=0)
t64col = tb.Time64Col(shape=(2, ), pos=1)
# The atoms used in the test VLArrays.
myTime32Atom = tb.Time32Atom(shape=(2, ))
myTime64Atom = tb.Time64Atom(shape=(2, ))
def test00_Compare32VLArray(self):
"""Comparing written 32-bit time data with read data in a VLArray."""
wtime = np.array((1_234_567_890, ) * 2, np.int32)
# Create test VLArray with data.
vla = self.h5file.create_vlarray('/', 'test', self.myTime32Atom)
vla.append(wtime)
self._reopen()
# Check the written data.
rtime = self.h5file.root.test.read()[0][0]
self.h5file.close()
self.assertTrue(common.allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test01_Compare64VLArray(self):
"""Comparing written 64-bit time data with read data in a VLArray."""
wtime = np.array((1_234_567_890.123456, ) * 2, np.float64)
# Create test VLArray with data.
vla = self.h5file.create_vlarray('/', 'test', self.myTime64Atom)
vla.append(wtime)
self._reopen()
# Check the written data.
rtime = self.h5file.root.test.read()[0][0]
self.h5file.close()
self.assertTrue(common.allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test01b_Compare64VLArray(self):
"""Comparing several written and read 64-bit time values in a
VLArray."""
# Create test VLArray with data.
vla = self.h5file.create_vlarray('/', 'test', self.myTime64Atom)
# Size of the test.
nrows = vla.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
# nrows = 10
for i in range(nrows):
j = i * 2
vla.append((j + 0.012, j + 1 + 0.012))
self._reopen()
# Check the written data.
arr = self.h5file.root.test.read()
self.h5file.close()
arr = np.array(arr)
orig_val = np.arange(0, nrows * 2, dtype=np.int32) + 0.012
orig_val.shape = (nrows, 1, 2)
if common.verbose:
print("Original values:", orig_val)
print("Retrieved values:", arr)
self.assertTrue(common.allequal(arr, orig_val),
"Stored and retrieved values do not match.")
def test02_CompareTable(self):
"""Comparing written time data with read data in a Table."""
wtime = 1_234_567_890.123456
# Create test Table with data.
tbl = self.h5file.create_table('/', 'test', self.MyTimeRow)
row = tbl.row
row['t32col'] = int(wtime)
row['t64col'] = (wtime, wtime)
row.append()
self._reopen()
# Check the written data.
recarr = self.h5file.root.test.read(0)
self.h5file.close()
self.assertEqual(recarr['t32col'][0], int(wtime),
"Stored and retrieved values do not match.")
comp = (recarr['t64col'][0] == np.array((wtime, wtime)))
self.assertTrue(np.alltrue(comp),
"Stored and retrieved values do not match.")
def test02b_CompareTable(self):
"""Comparing several written and read time values in a Table."""
# Create test Table with data.
tbl = self.h5file.create_table('/', 'test', self.MyTimeRow)
# Size of the test.
nrows = tbl.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
# nrows = 10
row = tbl.row
for i in range(nrows):
row['t32col'] = i
j = i * 2
row['t64col'] = (j + 0.012, j + 1 + 0.012)
row.append()
self._reopen()
# Check the written data.
recarr = self.h5file.root.test.read()
self.h5file.close()
# Time32 column.
orig_val = np.arange(nrows, dtype=np.int32)
if common.verbose:
print("Original values:", orig_val)
print("Retrieved values:", recarr['t32col'][:])
self.assertTrue(np.alltrue(recarr['t32col'][:] == orig_val),
"Stored and retrieved values do not match.")
# Time64 column.
orig_val = np.arange(0, nrows * 2, dtype=np.int32) + 0.012
orig_val.shape = (nrows, 2)
if common.verbose:
print("Original values:", orig_val)
print("Retrieved values:", recarr['t64col'][:])
self.assertTrue(
common.allequal(recarr['t64col'][:], orig_val, np.float64),
"Stored and retrieved values do not match.")
def test03_Compare64EArray(self):
"""Comparing written 64-bit time data with read data in an EArray."""
wtime = 1_234_567_890.123456
# Create test EArray with data.
ea = self.h5file.create_earray('/',
'test',
tb.Time64Atom(),
shape=(0, ))
ea.append((wtime, ))
self._reopen()
# Check the written data.
rtime = self.h5file.root.test[0]
self.h5file.close()
self.assertTrue(common.allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test03b_Compare64EArray(self):
"""Comparing several written and read 64-bit time values in an
EArray."""
# Create test EArray with data.
ea = self.h5file.create_earray('/',
'test',
tb.Time64Atom(),
shape=(0, 2))
# Size of the test.
nrows = ea.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
# nrows = 10
for i in range(nrows):
j = i * 2
ea.append(((j + 0.012, j + 1 + 0.012), ))
self._reopen()
# Check the written data.
arr = self.h5file.root.test.read()
self.h5file.close()
orig_val = np.arange(0, nrows * 2, dtype=np.int32) + 0.012
orig_val.shape = (nrows, 2)
if common.verbose:
print("Original values:", orig_val)
print("Retrieved values:", arr)
self.assertTrue(common.allequal(arr, orig_val),
"Stored and retrieved values do not match.")
class CompareTestCase(common.PyTablesTestCase):
"Tests whether stored and retrieved time data is kept the same."
# The description used in the test Table.
class MyTimeRow(tables.IsDescription):
t32col = tables.Time32Col(pos=0)
t64col = tables.Time64Col(shape=(2, ), pos=1)
# The atoms used in the test VLArrays.
myTime32Atom = tables.Time32Atom(shape=(2, ))
myTime64Atom = tables.Time64Atom(shape=(2, ))
def setUp(self):
"""setUp() -> None
This method sets the following instance attributes:
* 'h5fname', the name of the temporary HDF5 file
"""
self.h5fname = tempfile.mktemp(suffix='.h5')
def tearDown(self):
"""tearDown() -> None
Removes 'h5fname'.
"""
os.remove(self.h5fname)
def test00_Compare32VLArray(self):
"Comparing written 32-bit time data with read data in a VLArray."
wtime = numpy.array((1234567890, ) * 2, numpy.int32)
# Create test VLArray with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time32 VL arrays")
vla = h5file.createVLArray('/', 'test', self.myTime32Atom)
vla.append(wtime)
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
rtime = h5file.root.test.read()[0][0]
h5file.close()
self.assertTrue(allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test01_Compare64VLArray(self):
"Comparing written 64-bit time data with read data in a VLArray."
wtime = numpy.array((1234567890.123456, ) * 2, numpy.float64)
# Create test VLArray with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time64 VL arrays")
vla = h5file.createVLArray('/', 'test', self.myTime64Atom)
vla.append(wtime)
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
rtime = h5file.root.test.read()[0][0]
h5file.close()
self.assertTrue(allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test01b_Compare64VLArray(self):
"Comparing several written and read 64-bit time values in a VLArray."
# Create test VLArray with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time64 VL arrays")
vla = h5file.createVLArray('/', 'test', self.myTime64Atom)
# Size of the test.
nrows = vla.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
#nrows = 10
for i in xrange(nrows):
j = i * 2
vla.append((j + 0.012, j + 1 + 0.012))
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
arr = h5file.root.test.read()
h5file.close()
arr = numpy.array(arr)
orig_val = numpy.arange(0, nrows * 2, dtype=numpy.int32) + 0.012
orig_val.shape = (nrows, 1, 2)
if common.verbose:
print "Original values:", orig_val
print "Retrieved values:", arr
self.assertTrue(allequal(arr, orig_val),
"Stored and retrieved values do not match.")
def test02_CompareTable(self):
"Comparing written time data with read data in a Table."
wtime = 1234567890.123456
# Create test Table with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time tables")
tbl = h5file.createTable('/', 'test', self.MyTimeRow)
row = tbl.row
row['t32col'] = int(wtime)
row['t64col'] = (wtime, wtime)
row.append()
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
recarr = h5file.root.test.read(0)
h5file.close()
self.assertEqual(recarr['t32col'][0], int(wtime),
"Stored and retrieved values do not match.")
comp = (recarr['t64col'][0] == numpy.array((wtime, wtime)))
self.assertTrue(numpy.alltrue(comp),
"Stored and retrieved values do not match.")
def test02b_CompareTable(self):
"Comparing several written and read time values in a Table."
# Create test Table with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time tables")
tbl = h5file.createTable('/', 'test', self.MyTimeRow)
# Size of the test.
nrows = tbl.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
##nrows = 10
row = tbl.row
for i in xrange(nrows):
row['t32col'] = i
j = i * 2
row['t64col'] = (j + 0.012, j + 1 + 0.012)
row.append()
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
recarr = h5file.root.test.read()
h5file.close()
# Time32 column.
orig_val = numpy.arange(nrows, dtype=numpy.int32)
if common.verbose:
print "Original values:", orig_val
print "Retrieved values:", recarr['t32col'][:]
self.assertTrue(numpy.alltrue(recarr['t32col'][:] == orig_val),
"Stored and retrieved values do not match.")
# Time64 column.
orig_val = numpy.arange(0, nrows * 2, dtype=numpy.int32) + 0.012
orig_val.shape = (nrows, 2)
if common.verbose:
print "Original values:", orig_val
print "Retrieved values:", recarr['t64col'][:]
self.assertTrue(allequal(recarr['t64col'][:], orig_val, numpy.float64),
"Stored and retrieved values do not match.")
def test03_Compare64EArray(self):
"Comparing written 64-bit time data with read data in an EArray."
wtime = 1234567890.123456
# Create test EArray with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time64 EArrays")
ea = h5file.createEArray('/', 'test', tables.Time64Atom(), shape=(0, ))
ea.append((wtime, ))
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
rtime = h5file.root.test[0]
h5file.close()
self.assertTrue(allequal(rtime, wtime),
"Stored and retrieved values do not match.")
def test03b_Compare64EArray(self):
"Comparing several written and read 64-bit time values in an EArray."
# Create test EArray with data.
h5file = tables.openFile(self.h5fname,
'w',
title="Test for comparing Time64 E arrays")
ea = h5file.createEArray('/',
'test',
tables.Time64Atom(),
shape=(0, 2))
# Size of the test.
nrows = ea.nrowsinbuf + 34 # Add some more rows than buffer.
# Only for home checks; the value above should check better
# the I/O with multiple buffers.
##nrows = 10
for i in xrange(nrows):
j = i * 2
ea.append(((j + 0.012, j + 1 + 0.012), ))
h5file.close()
# Check the written data.
h5file = tables.openFile(self.h5fname)
arr = h5file.root.test.read()
h5file.close()
orig_val = numpy.arange(0, nrows * 2, dtype=numpy.int32) + 0.012
orig_val.shape = (nrows, 2)
if common.verbose:
print "Original values:", orig_val
print "Retrieved values:", arr
self.assertTrue(allequal(arr, orig_val),
"Stored and retrieved values do not match.")
class OpenTestCase(common.PyTablesTestCase):
"Tests opening a file with Time nodes."
# The description used in the test Table.
class MyTimeRow(tables.IsDescription):
t32col = tables.Time32Col(shape=(2, 1))
t64col = tables.Time64Col(shape=(2, 1))
# The atoms used in the test VLArrays.
myTime32Atom = tables.Time32Atom(shape=(2, 1))
myTime64Atom = tables.Time64Atom(shape=(2, 1))
def setUp(self):
"""setUp() -> None
This method sets the following instance attributes:
* 'h5fname', the name of the temporary HDF5 file with '/table',
'/vlarray4' and '/vlarray8' nodes.
"""
self.h5fname = tempfile.mktemp(suffix='.h5')
h5file = tables.openFile(self.h5fname,
'w',
title="Test for creating time leaves")
# Create test Table.
h5file.createTable('/', 'table', self.MyTimeRow)
# Create test VLArrays.
h5file.createVLArray('/', 'vlarray4', self.myTime32Atom)
h5file.createVLArray('/', 'vlarray8', self.myTime64Atom)
h5file.close()
def tearDown(self):
"""tearDown() -> None
Removes 'h5fname'.
"""
os.remove(self.h5fname)
def test00_OpenFile(self):
"Opening a file with Time nodes."
h5file = tables.openFile(self.h5fname)
# Test the Table node.
tbl = h5file.root.table
self.assertEqual(tbl.coldtypes['t32col'],
self.MyTimeRow.columns['t32col'].dtype,
"Column dtypes do not match.")
self.assertEqual(tbl.coldtypes['t64col'],
self.MyTimeRow.columns['t64col'].dtype,
"Column dtypes do not match.")
# Test the VLArray nodes.
vla4 = h5file.root.vlarray4
self.assertEqual(vla4.atom.dtype, self.myTime32Atom.dtype,
"Atom types do not match.")
self.assertEqual(vla4.atom.shape, self.myTime32Atom.shape,
"Atom shapes do not match.")
vla8 = h5file.root.vlarray8
self.assertEqual(vla8.atom.dtype, self.myTime64Atom.dtype,
"Atom types do not match.")
self.assertEqual(vla8.atom.shape, self.myTime64Atom.shape,
"Atom shapes do not match.")
h5file.close()
def test01_OpenFileStype(self):
"Opening a file with Time nodes, comparing Atom.stype."
h5file = tables.openFile(self.h5fname)
# Test the Table node.
tbl = h5file.root.table
self.assertEqual(tbl.coltypes['t32col'],
self.MyTimeRow.columns['t32col'].type,
"Column types do not match.")
self.assertEqual(tbl.coltypes['t64col'],
self.MyTimeRow.columns['t64col'].type,
"Column types do not match.")
# Test the VLArray nodes.
vla4 = h5file.root.vlarray4
self.assertEqual(vla4.atom.type, self.myTime32Atom.type,
"Atom types do not match.")
vla8 = h5file.root.vlarray8
self.assertEqual(vla8.atom.type, self.myTime64Atom.type,
"Atom types do not match.")
h5file.close()
output_dir = '../timeseries'
try:
os.mkdir(output_dir)
except OSError:
pass
# Open a new empty HDF5 file
hdf5_name = "carray_ts.h5"
filepath_hdf5 = os.path.join(output_dir, hdf5_name)
h5file = tables.open_file(filepath_hdf5, mode="w",
title='Example CArray with time fields')
# Create a CArray and fill it
root = h5file.root
shape = (300, 2)
atom = tables.Time32Atom()
filters = tables.Filters(complevel=5, complib='zlib')
hdfarray = h5file.create_carray(root, 'test_carray_1', atom, shape,
"Signed short array")
now = time.time()
seconds_by_day = 1*24*60*60
for index in range(0, 600, 2):
seconds = now - seconds_by_day * index
hdfarray[index/2, 0] = seconds
hdfarray[299-index/2, 1] = seconds
# Create other CArray and fill it
shape = (300,)
atom = tables.Time32Atom(shape=(2,))
filters = tables.Filters(complevel=5, complib='zlib')
hdfarray = h5file.create_carray(root, 'test_carray_2', atom, shape,
