import sys import unittest import os import tempfile from numarray import strings from numarray import records from numarray import * import tables from tables import * from tables import nra from tables.tests import common from tables.tests.common import allequal # To delete the internal attributes automagically unittest.TestCase.tearDown = common.cleanup types = ['Int8', 'Int16', 'Int32', 'Int64', 'Float32', 'Float64'] types += ['UInt8', 'UInt16', 'UInt32', 'Complex32', 'Complex64'] # UInt64 checking disabled on win platforms # because this type is not supported if sys.platform != 'win32': types += ['UInt64'] types += ['Bool'] class BasicTestCase(unittest.TestCase): """Basic test for all the supported types present in numarray. All of them are included on PyTables. """ endiancheck = 0 def WriteRead(self, testArray): if common.verbose: print '\n', '-=' * 30 if type(testArray) == NumArray: type_ = testArray.type() else: type_ = "String" print "Running test for array with type '%s'" % \ type_, print "for class check:", self.title # Create an instance of HDF5 Table self.file = tempfile.mktemp(".h5") self.fileh = openFile(self.file, mode = "w") self.root = self.fileh.root # Create the array under root and name 'somearray' a = testArray self.fileh.createArray(self.root, 'somearray', a, "Some array") # Close the file self.fileh.close() # Re-open the file in read-only mode self.fileh = openFile(self.file, mode = "r") self.root = self.fileh.root # Read the saved array b = self.root.somearray.read() # For cases that read returns a python type instead of a numarray type if not hasattr(b, "shape"): b = array(b, type=a.type()) # Compare them. They should be equal. #if not allequal(a,b, "numarray") and common.verbose: if common.verbose and type(a) == NumArray: print "Array written:", a print "Array written shape:", a.shape print "Array written itemsize:", a.itemsize print "Array written type:", a.type() print "Array read:", b print "Array read shape:", b.shape print "Array read itemsize:", b.itemsize print "Array read type:", b.type() type_ = self.root.somearray.atom.type # Check strictly the array equality assert type(a) == type(b) assert a.shape == b.shape assert a.shape == self.root.somearray.shape if type(a) == strings.CharArray: assert type_ == "string" else: assert a.type() == b.type() if not type_.startswith('complex'): assert str(a.type()).lower() == type_ else: if type_ == 'complex64': assert str(a.type()) == "Complex32" else: assert str(a.type()) == "Complex64" assert allequal(a,b, "numarray") self.fileh.close() # Then, delete the file os.remove(self.file) return def test00_char(self): "Data integrity during recovery (character objects)" a = strings.array(self.tupleChar) self.WriteRead(a) return def test01_char_nc(self): "Data integrity during recovery (non-contiguous character objects)" a = strings.array(self.tupleChar) if a.shape == (): b = a # We cannot use the indexing notation else: b = a[::2] # Ensure that this numarray string is non-contiguous if a.shape[0] > 2: assert b.iscontiguous() == 0 self.WriteRead(b) return def test02_types(self): "Data integrity during recovery (numerical types)" for type_ in types: if self.tupleInt.shape: a = self.tupleInt.astype(type_) else: # shape is the empty tuple () a = array(self.tupleInt, type=type_) self.WriteRead(a) return def test03_types_nc(self): "Data integrity during recovery (non-contiguous numerical types)" for type_ in types: if self.tupleInt.shape: a = self.tupleInt.astype(type_) else: # shape is the empty tuple () a = array(self.tupleInt, dtype=type_) # This should not be tested for the rank-0 case if len(a.shape) == 0: return b = a[::2] # Ensure that this array is non-contiguous (for non-trivial case) if a.shape[0] > 2: assert b.iscontiguous() == 0 self.WriteRead(b) return class Basic0DOneTestCase(BasicTestCase): # Rank-0 case title = "Rank-0 case 1" tupleInt = array(3) tupleChar = "4" class Basic0DTwoTestCase(BasicTestCase): # Rank-0 case title = "Rank-0 case 2" tupleInt = array(33) tupleChar = "44" class Basic1DOneTestCase(BasicTestCase): # 1D case title = "Rank-1 case 1" tupleInt = array((3,)) tupleChar = ("a",) class Basic1DTwoTestCase(BasicTestCase): # 1D case title = "Rank-1 case 2" tupleInt = array((0, 4)) tupleChar = ("aaa",) class Basic1DThreeTestCase(BasicTestCase): # 1D case title = "Rank-1 case 3" tupleInt = array((3, 4, 5)) tupleChar = ("aaaa", "bbb",) class Basic2DTestCase(BasicTestCase): # 2D case title = "Rank-2 case 1" #tupleInt = reshape(array(arange((4)**2)), (4,)*2) tupleInt = ones((4,)*2) tupleChar = [["aaa","ddddd"],["d","ss"],["s","tt"]] class Basic10DTestCase(BasicTestCase): # 10D case title = "Rank-10 case 1" tupleInt = ones((2,)*10, 'Int32') # The next tuple consumes far more time, so this # test should be run in common.heavy mode. # Dimensions greather than 6 in numarray strings gives some warnings tupleChar = strings.array("abc"*2**6, shape=(2,)*6, itemsize=3) class GroupsArrayTestCase(unittest.TestCase): """This test class checks combinations of arrays with groups. It also uses arrays ranks which ranges until 10. """ def test00_iterativeGroups(self): """Checking combinations of arrays with groups It also uses arrays ranks which ranges until 10. """ if common.verbose: print '\n', '-=' * 30 print "Running %s.test00_iterativeGroups..." % \ self.__class__.__name__ # Open a new empty HDF5 file file = tempfile.mktemp(".h5") fileh = openFile(file, mode = "w") # Get the root group group = fileh.root i = 1 for type_ in types: # Create an array of type_, with incrementally bigger ranges a = ones((2,) * i, type_) # Save it on the HDF5 file dsetname = 'array_' + type_ if common.verbose: print "Creating dataset:", group._g_join(dsetname) hdfarray = fileh.createArray(group, dsetname, a, "Large array") # Create a new group group = fileh.createGroup(group, 'group' + str(i)) # increment the range for next iteration i += 1 # Close the file fileh.close() # Open the previous HDF5 file in read-only mode fileh = openFile(file, mode = "r") # Get the root group group = fileh.root # Get the metadata on the previosly saved arrays for i in range(1,len(types)): # Create an array for later comparison a = ones((2,) * i, types[i - 1]) # Get the dset object hanging from group dset = getattr(group, 'array_' + types[i-1]) # Get the actual array b = dset.read() if not allequal(a,b, "numarray") and common.verbose: print "Array a original. Shape: ==>", a.shape print "Array a original. Data: ==>", a print "Info from dataset:", dset._v_pathname print " shape ==>", dset.shape, print " type ==> %s" % dset.atom.type print "Array b read from file. Shape: ==>", b.shape, print ". Type ==> %s" % b.type() assert a.shape == b.shape assert allequal(a,b, "numarray") # Iterate over the next group group = getattr(group, 'group' + str(i)) # Close the file fileh.close() # Then, delete the file os.remove(file) def test01_largeRankArrays(self): """Checking creation of large rank arrays (0 < rank <= 32) It also uses arrays ranks which ranges until maxrank. """ # maximum level of recursivity (deepest group level) achieved: # maxrank = 32 (for a effective maximum rank of 32) # This limit is due to a limit in the HDF5 library. minrank = 1 maxrank = 32 if common.verbose: print '\n', '-=' * 30 print "Running %s.test01_largeRankArrays..." % \ self.__class__.__name__ print "Maximum rank for tested arrays:", maxrank # Open a new empty HDF5 file file = tempfile.mktemp(".h5") fileh = openFile(file, mode = "w") group = fileh.root if common.verbose: print "Rank array writing progress: ", for rank in range(minrank, maxrank + 1): # Create an array of integers, with incrementally bigger ranges a = ones((1,) * rank, 'Int32') if common.verbose: print "%3d," % (rank), fileh.createArray(group, "array", a, "Rank: %s" % rank) group = fileh.createGroup(group, 'group' + str(rank)) # Flush the buffers fileh.flush() # Close the file fileh.close() # Open the previous HDF5 file in read-only mode fileh = openFile(file, mode = "r") group = fileh.root if common.verbose: print print "Rank array reading progress: " # Get the metadata on the previosly saved arrays for rank in range(minrank, maxrank + 1): # Create an array for later comparison a = ones((1,) * rank, 'Int32') # Get the actual array b = group.array.read() if common.verbose: print "%3d," % (rank), if not a.tolist() == b.tolist() and common.verbose: print "Array b read from file. Shape: ==>", b.shape, print ". Type ==> %c" % b.type() assert a.shape == b.shape assert a.type() == b.type() assert allequal(a, b, "numarray") # Iterate over the next group group = fileh.getNode(group, 'group' + str(rank)) if common.verbose: print # This flush the stdout buffer # Close the file fileh.close() # Delete the file os.remove(file) # Test Record class class Record(IsDescription): var1 = StringCol(itemsize=4, dflt="abcd", pos=0) var2 = StringCol(itemsize=1, dflt="a", pos=1) var3 = BoolCol(dflt=1) var4 = Int8Col(dflt=1) var5 = UInt8Col(dflt=1) var6 = Int16Col(dflt=1) var7 = UInt16Col(dflt=1) var8 = Int32Col(dflt=1) var9 = UInt32Col(dflt=1) var10 = Int64Col(dflt=1) var11 = Float32Col(dflt=1.0) var12 = Float64Col(dflt=1.0) var13 = ComplexCol(dflt=(1.+0.j), itemsize=8) var14 = ComplexCol(dflt=(1.+0.j), itemsize=16) class TableReadTestCase(common.PyTablesTestCase): nrows = 100 def setUp(self): # Create an instance of an HDF5 Table self.file = tempfile.mktemp(".h5") fileh = openFile(self.file, "w") table = fileh.createTable(fileh.root, 'table', Record) for i in range(self.nrows): table.row.append() # Fill 100 rows with default values fileh.close() self.fileh = openFile(self.file, "a") # allow flavor changes def tearDown(self): self.fileh.close() os.remove(self.file) common.cleanup(self) def test01_readTableChar(self): """Checking column conversion into numarray in read(). Chars.""" table = self.fileh.root.table table.flavor = "numarray" for colname in table.colnames: numcol = table.read(field=colname) typecol = table.coltypes[colname] itemsizecol = table.description._v_dtypes[colname].base.itemsize if typecol == "string": if itemsizecol > 1: orignumcol = strings.array(['abcd']*self.nrows, itemsize=4) else: orignumcol = strings.array(['a']*self.nrows, itemsize=1) if common.verbose: print "Itemsize of column:", itemsizecol print "Shape of numarray column read:", numcol.shape print "Should look like:", orignumcol.shape print "First 3 elements of read col:", numcol[:3] # Check that both numarray objects are equal assert allequal(numcol, orignumcol, "numarray") def test01_readTableNum(self): """Checking column conversion into numarray in read(). Numerical.""" table = self.fileh.root.table table.flavor="numarray" for colname in table.colnames: numcol = table.read(field=colname) typecol = table.coltypes[colname] if typecol != "string": type_ = numcol.type() if common.verbose: print "Type of numarray column read:", type_ print "Should look like:", typecol orignumcol = ones(shape=self.nrows, dtype=numcol.type()) # Check that both numarray objects are equal assert allequal(numcol, orignumcol, "numarray") def test02_readCoordsChar(self): """Column conversion into numarray in readCoordinates(). Chars.""" table = self.fileh.root.table table.flavor = "numarray" coords = (1,2,3) self.nrows = len(coords) for colname in table.colnames: numcol = table.readCoordinates(coords, field=colname) typecol = table.coltypes[colname] itemsizecol = table.description._v_dtypes[colname].base.itemsize if typecol == "string": if itemsizecol > 1: orignumcol = strings.array(['abcd']*self.nrows, itemsize=4) else: orignumcol = strings.array(['a']*self.nrows, itemsize=1) if common.verbose: print "Itemsize of column:", itemsizecol print "Shape of numarray column read:", numcol.shape print "Should look like:", orignumcol.shape print "First 3 elements of read col:", numcol[:3] # Check that both numarray objects are equal assert allequal(numcol, orignumcol, "numarray") def test02_readCoordsNum(self): """Column conversion into numarray in readCoordinates(). Numerical.""" table = self.fileh.root.table table.flavor="numarray" coords = (1,2,3) self.nrows = len(coords) for colname in table.colnames: numcol = table.readCoordinates(coords, field=colname) typecol = table.coltypes[colname] if typecol != "string": type_ = numcol.type() if typecol == "int64": return if common.verbose: print "Type of read numarray column:", type_ print "Should look like:", typecol orignumcol = ones(shape=self.nrows, type=numcol.type()) # Check that both numarray objects are equal assert allequal(numcol, orignumcol, "numarray") def test03_getIndexnumarray(self): """Getting table rows specifyied as numarray scalar integers.""" table = self.fileh.root.table coords = array([1,2,3], type='Int8') for colname in table.colnames: numcol = [ table[coord][colname].item() for coord in coords ] typecol = table.coltypes[colname] if typecol != "string": if typecol == "bool": # Special case for boolean translation typecol = "Bool" numcol = array(numcol, dtype=typecol) if common.verbose: type_ = numcol.type() print "Type of read numarray column:", type_ print "Should look like:", typecol orignumcol = ones(shape=len(numcol), type=numcol.type()) # Check that both numarray objects are equal assert allequal(numcol, orignumcol, "numarray") def test04_setIndexnumarray(self): """Setting table rows specifyied as numarray integers.""" self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table table.flavor = "numarray" coords = array([1,2,3], dtype='int8') # Modify row 1 # From PyTables 2.0 on, assignments to records can be done # only as tuples (see http://projects.scipy.org/scipy/numarray/ticket/315) #table[coords[0]] = ["aasa","x"]+[232]*12 table[coords[0]] = tuple(["aasa","x"]+[232]*12) #record = list(table[coords[0]]) record = table.read(coords[0])[0] if common.verbose: print """Original row: ['aasa', 'x', 232, -24, 232, 232, 1, 232L, 232, (232+0j), 232.0, 232L, (232+0j), 232.0] """ print "Read row:\n", record assert record.field('var1') == 'aasa' assert record.field('var2') == 'x' assert record.field('var3') == True assert record.field('var4') == -24 assert record.field('var7') == 232 # The declaration of the nested table: class Info(IsDescription): _v_pos = 3 Name = StringCol(itemsize=2) Value = ComplexCol(itemsize=16) class TestTDescr(IsDescription): """A description that has several nested columns.""" x = Int32Col(dflt=0, shape=2, pos=0) #0 y = Float64Col(dflt=1, shape=(2,2)) z = UInt8Col(dflt=1) z3 = EnumCol({'r':4, 'g':2, 'b':1}, dflt='r', base='int32', shape=2) color = StringCol(itemsize=4, dflt="ab", pos=2) info = Info() class Info(IsDescription): #1 _v_pos = 1 name = StringCol(itemsize=2) value = ComplexCol(itemsize=16, pos=0) #0 y2 = Float64Col(pos=1) #1 z2 = UInt8Col() class Info2(IsDescription): y3 = Time64Col(shape=2) name = StringCol(itemsize=2) value = ComplexCol(itemsize=16, shape=2) class TableNativeFlavorTestCase(common.PyTablesTestCase): nrows = 100 dtype = [('value', 'c16'), ('y2', 'f8'), ('Info2', [('name', 'a2'), ('value', '(2,)c16'), ('y3', '(2,)f8')]), ('name', 'a2'), ('z2', 'u1')] _infozeros = nra.array(descr=dtype, shape=3) # Set the contents to zero (or empty strings) _infozeros.field('value')[:] = 0 _infozeros.field('y2')[:] = 0 _infozeros.field('Info2/name')[:] = "\0" _infozeros.field('Info2/value')[:] = 0 _infozeros.field('Info2/y3')[:] = 0 _infozeros.field('name')[:] = "\0" _infozeros.field('z2')[:] = 0 _infoones = nra.array(descr=dtype, shape=3) # Set the contents to one (or blank strings) _infoones.field('value')[:] = 1 _infoones.field('y2')[:] = 1 _infoones.field('Info2/name')[:] = " " _infoones.field('Info2/value')[:] = 1 _infoones.field('Info2/y3')[:] = 1 _infoones.field('name')[:] = " " _infoones.field('z2')[:] = 1 def setUp(self): # Create an instance of an HDF5 Table self.file = tempfile.mktemp(".h5") fileh = openFile(self.file, "w") table = fileh.createTable(fileh.root, 'table', TestTDescr, expectedrows=self.nrows) table.flavor = 'numarray' for i in range(self.nrows): table.row.append() # Fill 100 rows with default values table.flush() self.fileh = fileh def tearDown(self): self.fileh.close() os.remove(self.file) common.cleanup(self) def test01a_basicTableRead(self): """Checking the return of a numarray in read().""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table[:] if common.verbose: print "Type of read:", type(data) print "Formats of the record:", data._formats print "First 3 elements of read:", data[:3] # Check the type of the recarray assert isinstance(data, records.RecArray) # Check the value of some columns # A flat column col = table.cols.x[:3] assert isinstance(col, NumArray) npcol = zeros((3,2), type="Int32") if common.verbose: print "Plain column:" print "read column-->", col print "should look like-->", npcol assert allequal(col, npcol, "numarray") # A nested column col = table.cols.Info[:3] assert isinstance(col, records.RecArray) npcol = self._infozeros if common.verbose: print "Nested column:" print "read column-->", col print "should look like-->", npcol assert col.descr == npcol.descr assert str(col) == str(npcol) def test01b_basicTableRead(self): """Checking the return of a numarray in read() (strided version).""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table[::3] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check the value of some columns # A flat column col = table.cols.x[:9:3] assert isinstance(col, NumArray) npcol = zeros((3,2), dtype="Int32") if common.verbose: print "Plain column:" print "read column-->", col print "should look like-->", npcol assert allequal(col, npcol, "numarray") # A nested column col = table.cols.Info[:9:3] assert isinstance(col, records.RecArray) npcol = self._infozeros if common.verbose: print "Nested column:" print "read column-->", col print "should look like-->", npcol assert col.descr == npcol.descr assert str(col) == str(npcol) def test02_getWhereList(self): """Checking the return of numarray in getWhereList method.""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.getWhereList('z == 1') if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check that all columns have been selected assert len(data) == 100 # Finally, check that the contents are ok assert allequal(data, arange(100, type="Int64"), "numarray") def test03a_readWhere(self): """Checking the return of numarray in readWhere method (strings).""" table = self.fileh.root.table if tables.is_pro: table.cols.color.createIndex() if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.readWhere('color == "ab"') if common.verbose: print "Type of read:", type(data) print "Length of the data read:", len(data) # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check that all columns have been selected assert len(data) == self.nrows def test03b_readWhere(self): """Checking the return of numarray in readWhere method (numeric).""" table = self.fileh.root.table if tables.is_pro: table.cols.z.createIndex() if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.readWhere('z == 0') if common.verbose: print "Type of read:", type(data) print "Length of the data read:", len(data) # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check that all columns have been selected assert len(data) == 0 def test04a_createTable(self): """Checking the Table creation from a numarray recarray.""" npdata = self._infozeros table = self.fileh.createTable(self.fileh.root, 'table2', npdata) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table2 data = table[:] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "npdata-->", npdata print "data-->", data # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check the type assert data.descr == npdata.descr assert str(data) == str(npdata) def test04b_appendTable(self): """Checking appending a numarray recarray.""" table = self.fileh.root.table npdata = table[3:6] table.append(npdata) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table[-3:] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "Last 3 elements of read:", data[-3:] print "Length of the data read:", len(data) if common.verbose: print "npdata-->", npdata print "data-->", data # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check the type assert data.descr == npdata.descr assert str(data) == str(npdata) def test05a_assignColumn(self): """Checking assigning to a column.""" table = self.fileh.root.table table.cols.z[:] = ones((100,), dtype='UInt8') if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.cols.z[:] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check that all columns have been selected assert len(data) == 100 # Finally, check that the contents are ok assert allequal(data, ones((100,), dtype="UInt8"), "numarray") def test05b_modifyingColumns(self): """Checking modifying several columns at once.""" table = self.fileh.root.table xcol = ones((3,2), 'Int32') ycol = ones((3,2,2), 'Float64') zcol = zeros((3,), 'UInt8') table.modifyColumns(3, 6, 1, [xcol, ycol, zcol], ['x', 'y', 'z']) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.cols.y[3:6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert allequal(data, ycol, "numarray") def test05c_modifyingColumns(self): """Checking modifying several columns using a numarray buffer.""" table = self.fileh.root.table dtype=[('x', '(2,)i4'), ('y', '(2,2)f8'), ('z', 'u1')] nparray = nra.array(shape=(3,), descr=dtype) nparray.field('x')[:] = 1 nparray.field('y')[:] = 1 nparray.field('z')[:] = 2 table.modifyColumns(3, 6, 1, nparray, ['x', 'y', 'z']) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table ycol = ones((3, 2, 2), 'Float64') data = table.cols.y[3:6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert str(data) == str(ycol) def test06a_assignNestedColumn(self): """Checking assigning a nested column (using modifyColumn).""" npdata = self._infoones table = self.fileh.root.table data = table.cols.Info[3:6] table.modifyColumn(3, 6, 1, column=npdata, colname='Info') if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.cols.Info[3:6] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "npdata-->", npdata print "data-->", data # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check the type assert data.descr == npdata.descr assert str(data) == str(npdata) def test06b_assignNestedColumn(self): """Checking assigning a nested column (using the .cols accessor).""" table = self.fileh.root.table npdata = self._infoones table.cols.Info[3:6] = npdata if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table data = table.cols.Info[3:6] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "npdata-->", npdata print "data-->", data # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check the type assert data.descr == npdata.descr assert str(data) == str(npdata) def test07a_modifyingRows(self): """Checking modifying several rows at once (using modifyRows).""" table = self.fileh.root.table # Read a chunk of the table chunk = table[0:3] # Modify it somewhat chunk.field('y')[:] = -1 table.modifyRows(3, 6, 1, rows=chunk) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table ycol = zeros((3,2,2), 'Float64')-1 data = table.cols.y[3:6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert allequal(ycol, data, "numarray") def test07b_modifyingRows(self): """Checking modifying several rows at once (using cols accessor).""" table = self.fileh.root.table # Read a chunk of the table chunk = table[0:3] # Modify it somewhat chunk.field('y')[:] = -1 table.cols[3:6] = chunk if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table # Check that some column has been actually modified ycol = zeros((3,2,2), 'Float64')-1 data = table.cols.y[3:6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert allequal(ycol, data, "numarray") def test08a_modifyingRows(self): """Checking modifying just one row at once (using modifyRows).""" table = self.fileh.root.table # Read a chunk of the table chunk = table[3] # Modify it somewhat chunk.field('y')[:] = -1 table.modifyRows(6, 7, 1, chunk) if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table # Check that some column has been actually modified ycol = zeros((2,2), 'Float64')-1 data = table.cols.y[6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert allequal(ycol, data, "numarray") def test08b_modifyingRows(self): """Checking modifying just one row at once (using cols accessor).""" table = self.fileh.root.table # Read a chunk of the table chunk = table[3] # Modify it somewhat chunk['y'][:] = -1 table.cols[6] = chunk if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table # Check that some column has been actually modified ycol = zeros((2,2), 'Float64')-1 data = table.cols.y[6] if common.verbose: print "Type of read:", type(data) print "First 3 elements of read:", data[:3] print "Length of the data read:", len(data) if common.verbose: print "ycol-->", ycol print "data-->", data # Check that both numarray objects are equal assert isinstance(data, NumArray) # Check the type assert data.type() == ycol.type() assert allequal(ycol, data, "numarray") def test09a_getStrings(self): """Checking the return of string columns with spaces.""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table rdata = table.getWhereList('color == "ab"') data = table.readCoordinates(rdata) if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check that all columns have been selected assert len(data) == 100 # Finally, check that the contents are ok for idata in data.field('color'): assert idata == "ab" def test09b_getStrings(self): """Checking the return of string columns with spaces. (modify)""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table for i in range(50): table.cols.color[i] = "a " table.flush() data = table[:] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check that all columns have been selected assert len(data) == 100 # Finally, check that the contents are ok for i in range(100): idata = data.field('color')[i] if i >= 50: assert idata == "ab" else: assert idata == "a" def test09c_getStrings(self): """Checking the return of string columns with spaces. (append)""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") table = self.fileh.root.table row = table.row for i in range(50): row["color"] = "a " # note the trailing spaces row.append() table.flush() if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") data = self.fileh.root.table[:] if common.verbose: print "Type of read:", type(data) print "Description of the record:", data.descr print "First 3 elements of read:", data[:3] # Check that both numarray objects are equal assert isinstance(data, records.RecArray) # Check that all columns have been selected assert len(data) == 150 # Finally, check that the contents are ok # Finally, check that the contents are ok for i in range(150): idata = data.field('color')[i] if i < 100: assert idata == "ab" else: assert idata == "a" class TableNativeFlavorOpenTestCase(TableNativeFlavorTestCase): close = 0 class TableNativeFlavorCloseTestCase(TableNativeFlavorTestCase): close = 1 class StrlenTestCase(common.PyTablesTestCase): def setUp(self): # Create an instance of an HDF5 Table self.file = tempfile.mktemp(".h5") self.fileh = openFile(self.file, "w") group = self.fileh.createGroup(self.fileh.root, 'group') tablelayout = {'Text': StringCol(itemsize=1000),} self.table = self.fileh.createTable(group, 'table', tablelayout) self.table.flavor = 'numarray' row = self.table.row row['Text'] = 'Hello Francesc!' row.append() row['Text'] = 'Hola Francesc!' row.append() self.table.flush() def tearDown(self): self.fileh.close() os.remove(self.file) common.cleanup(self) def test01(self): """Checking the lengths of strings (read field).""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") self.table = self.fileh.root.group.table # Get both strings str1 = self.table.col('Text')[0] str2 = self.table.col('Text')[1] if common.verbose: print "string1-->", str1 print "string2-->", str2 # Check that both numarray objects are equal assert len(str1) == len('Hello Francesc!') assert len(str2) == len('Hola Francesc!') assert str1 == 'Hello Francesc!' assert str2 == 'Hola Francesc!' def test02(self): """Checking the lengths of strings (read recarray).""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") self.table = self.fileh.root.group.table # Get both strings str1 = self.table[:].field('Text')[0] str2 = self.table[:].field('Text')[1] # Check that both numarray objects are equal assert len(str1) == len('Hello Francesc!') assert len(str2) == len('Hola Francesc!') assert str1 == 'Hello Francesc!' assert str2 == 'Hola Francesc!' def test03(self): """Checking the lengths of strings (read recarray, row by row).""" if self.close: self.fileh.close() self.fileh = openFile(self.file, "a") self.table = self.fileh.root.group.table # Get both strings str1 = self.table[0].field('Text') str2 = self.table[1].field('Text') # Check that both numarray objects are equal assert len(str1) == len('Hello Francesc!') assert len(str2) == len('Hola Francesc!') assert str1 == 'Hello Francesc!' assert str2 == 'Hola Francesc!' class StrlenOpenTestCase(StrlenTestCase): close = 0 class StrlenCloseTestCase(StrlenTestCase): close = 1 class ScalarTestCase(common.TempFileMixin, common.PyTablesTestCase): def test(self): """Reading scalar arrays (see #98).""" arr = self.h5file.createArray('/', 'scalar_na', 1234) arr.flavor = 'numarray' self._reopen() arr = self.h5file.root.scalar_na common.verbosePrint("* %r == %r ?" % (arr.read(), array(1234))) self.assert_(all(arr.read() == array(1234))) common.verbosePrint("* %r == %r ?" % (arr[()], array(1234))) self.assert_(all(arr[()] == 1234)) #-------------------------------------------------------- def suite(): theSuite = unittest.TestSuite() niter = 1 #theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase)) #theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase)) #theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase)) for i in range(niter): theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase)) theSuite.addTest(unittest.makeSuite(Basic0DTwoTestCase)) theSuite.addTest(unittest.makeSuite(Basic1DOneTestCase)) theSuite.addTest(unittest.makeSuite(Basic1DTwoTestCase)) theSuite.addTest(unittest.makeSuite(Basic1DThreeTestCase)) theSuite.addTest(unittest.makeSuite(Basic2DTestCase)) theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase)) theSuite.addTest(unittest.makeSuite(TableReadTestCase)) theSuite.addTest(unittest.makeSuite(TableNativeFlavorOpenTestCase)) theSuite.addTest(unittest.makeSuite(TableNativeFlavorCloseTestCase)) theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase)) theSuite.addTest(unittest.makeSuite(StrlenCloseTestCase)) theSuite.addTest(unittest.makeSuite(ScalarTestCase)) if common.heavy: theSuite.addTest(unittest.makeSuite(Basic10DTestCase)) return theSuite if __name__ == '__main__': unittest.main( defaultTest='suite' )