mirror of https://github.com/exaloop/codon.git
1310 lines
40 KiB
Python
1310 lines
40 KiB
Python
import numpy as np
|
|
import gzip
|
|
import bz2
|
|
|
|
test_dir = "test/numpy/data"
|
|
|
|
# TestSaveLoad
|
|
|
|
def test_array():
|
|
a = np.array(np.empty((1, )), dtype=float)
|
|
f = test_dir + "/bin_0.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=float)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_array()
|
|
|
|
def test_save_load_int_1D():
|
|
a = np.array([1, 2, 3, 4], dtype=int)
|
|
f = test_dir + "/bin_1.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=int)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_int_1D()
|
|
|
|
def test_save_load_float_1D():
|
|
a = np.array([1.0, 2.0, 3.0, 4.0], dtype=float)
|
|
f = test_dir + "/bin_2.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=float)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_float_1D()
|
|
|
|
def test_save_load_complex_1D():
|
|
a = np.array([1 + 2j, 2 + 7j, 3 - 6j, 4 + 12j], dtype=complex)
|
|
f = test_dir + "/bin_3.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=complex)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_complex_1D()
|
|
|
|
def test_save_load_int_2D():
|
|
a = np.array([[1, 2], [3, 4]], dtype=int)
|
|
f = test_dir + "/bin_4.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=int, ndim=2)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_int_2D()
|
|
|
|
def test_save_load_float_2D():
|
|
a = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=float)
|
|
f = test_dir + "/bin_5.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=float, ndim=2)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_float_2D()
|
|
|
|
def test_save_load_complex_2D():
|
|
a = np.array([[1 + 2j, 2 + 7j], [3 - 6j, 4 + 12j]], complex)
|
|
f = test_dir + "/bin_6.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=complex, ndim=2)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_complex_2D()
|
|
|
|
def test_save_load_int_3D():
|
|
a = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]],
|
|
dtype=int)
|
|
f = test_dir + "/bin_7.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=int, ndim=3)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_int_3D()
|
|
|
|
def test_save_load_float_3D():
|
|
a = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]],
|
|
[[7.0, 8.0, 9.0], [10.0, 11.0, 12.0]]],
|
|
dtype=float)
|
|
f = test_dir + "/bin_8.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=float, ndim=3)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_float_3D()
|
|
|
|
def test_save_load_complex_3D():
|
|
a = np.array([[[1 + 2j, 2 + 7j, 3 + 4j], [4 - 5j, 5 + 6j, 6 - 7j]],
|
|
[[7 + 8j, 8 - 9j, 9 + 10j], [10 - 11j, 11 + 12j, 12 - 13j]]],
|
|
dtype=complex)
|
|
f = test_dir + "/bin_9.npy"
|
|
np.save(f, a)
|
|
l = np.load(f, dtype=complex, ndim=3)
|
|
assert np.array_equal(a, l)
|
|
|
|
test_save_load_complex_3D()
|
|
|
|
# savetxt / loadtxt / genfromtxt
|
|
|
|
# def test_0D_3D(): TODO
|
|
|
|
def test_txt_int_1D():
|
|
a = np.array([1, 2, 3, 4], int)
|
|
f = test_dir + "/text_1.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=int)
|
|
g = np.genfromtxt(f, dtype=int)
|
|
assert np.array_equal(l.reshape(-1), a)
|
|
assert np.array_equal(g.reshape(-1), a)
|
|
|
|
test_txt_int_1D()
|
|
|
|
def test_txt_float_1D():
|
|
a = np.array([1, 2, 3, 4], float)
|
|
f = test_dir + "/text_2.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=float)
|
|
g = np.genfromtxt(f, dtype=float)
|
|
assert np.array_equal(l.reshape(-1), a)
|
|
assert np.array_equal(g.reshape(-1), a)
|
|
|
|
test_txt_float_1D()
|
|
|
|
def test_txt_int_2D():
|
|
a = np.array([[1, 2], [3, 4]], dtype=int)
|
|
f = test_dir + "/text_3.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=int)
|
|
g = np.genfromtxt(f, dtype=int)
|
|
assert np.array_equal(l, a)
|
|
assert np.array_equal(g, a)
|
|
|
|
test_txt_int_2D()
|
|
|
|
def test_txt_float_2D():
|
|
a = np.array([[1, 2], [3, 4]], dtype=float)
|
|
f = test_dir + "/text_4.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=float)
|
|
g = np.genfromtxt(f, dtype=float)
|
|
assert np.array_equal(l, a)
|
|
assert np.array_equal(g, a)
|
|
|
|
test_txt_float_2D()
|
|
|
|
# def test_structured(): TODO
|
|
# def test_structured_padded(): TODO
|
|
# def test_multifield_view(): TODO
|
|
|
|
def test_txt_delimiter_1D():
|
|
a = np.array([1., 2., 3., 4.])
|
|
f = test_dir + "/text_8.txt"
|
|
np.savetxt(f, a, delimiter=',')
|
|
l = np.loadtxt(f, delimiter=',')
|
|
g = np.genfromtxt(f, delimiter=',')
|
|
assert np.array_equal(l.reshape(-1), a)
|
|
assert np.array_equal(g.reshape(-1), a)
|
|
|
|
test_txt_delimiter_1D()
|
|
|
|
def test_txt_delimiter_2D():
|
|
a = np.array([[1., 2.], [3., 4.]])
|
|
f = test_dir + "/text_9.txt"
|
|
np.savetxt(f, a, delimiter=',')
|
|
l = np.loadtxt(f, delimiter=',')
|
|
g = np.genfromtxt(f, delimiter=',')
|
|
assert np.array_equal(l, a)
|
|
assert np.array_equal(g, a)
|
|
|
|
test_txt_delimiter_2D()
|
|
|
|
# def test_format(): Not yet implemented
|
|
|
|
def test_header_footer():
|
|
# Test the functionality of the header and footer keyword argument.
|
|
f = test_dir + "/text_11.txt"
|
|
a = np.array([(1, 2), (3, 4)], dtype=int)
|
|
test_header_footer = 'Test header / footer'
|
|
np.savetxt(f, a, header=test_header_footer)
|
|
with open(f, 'r') as fh:
|
|
content = fh.read()
|
|
assert content.startswith('# ' + test_header_footer)
|
|
|
|
# Test the footer keyword argument
|
|
f = test_dir + "/text_12.txt"
|
|
np.savetxt(f, a, footer=test_header_footer)
|
|
with open(f, 'r') as fh:
|
|
content = fh.read()
|
|
assert content.endswith('# ' + test_header_footer + '\n')
|
|
|
|
# Test the commentstr keyword argument used on the header
|
|
f = test_dir + "/text_13.txt"
|
|
commentstr = '% '
|
|
np.savetxt(f, a, header=test_header_footer, comments=commentstr)
|
|
with open(f, 'r') as fh:
|
|
content = fh.read()
|
|
assert content.startswith(commentstr + test_header_footer)
|
|
|
|
# Test the commentstr keyword argument used on the footer
|
|
f = test_dir + "/text_14.txt"
|
|
commentstr = '% '
|
|
np.savetxt(f, a, footer=test_header_footer, comments=commentstr)
|
|
with open(f, 'r') as fh:
|
|
content = fh.read()
|
|
assert content.endswith(commentstr + test_header_footer + '\n')
|
|
|
|
test_header_footer()
|
|
|
|
def test_file_roundtrip():
|
|
a = np.array([(1, 2), (3, 4)])
|
|
f = test_dir + "/text_15.txt"
|
|
np.savetxt(f, a)
|
|
b = np.loadtxt(f)
|
|
assert np.array_equal(a, b)
|
|
|
|
test_file_roundtrip()
|
|
|
|
def test_complex_arrays():
|
|
ncols = 2
|
|
nrows = 2
|
|
a = np.zeros((ncols, nrows), dtype=np.complex128)
|
|
re = np.pi
|
|
im = np.e
|
|
a[:] = re + 1.0j * im
|
|
|
|
f = test_dir + "/text_16.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=np.complex128)
|
|
assert l.all() == a.all()
|
|
|
|
test_complex_arrays()
|
|
|
|
def test_complex_negative_exponent():
|
|
ncols = 2
|
|
nrows = 2
|
|
a = np.zeros((ncols, nrows), dtype=np.complex128)
|
|
re = np.pi
|
|
im = np.e
|
|
a[:] = re - 1.0j * im
|
|
f = test_dir + "/text_17.txt"
|
|
np.savetxt(f, a)
|
|
l = np.loadtxt(f, dtype=np.complex128)
|
|
assert l.all() == a.all()
|
|
|
|
test_complex_negative_exponent()
|
|
|
|
# def test_custom_writer(): TODO
|
|
# def test_unicode(): TODO
|
|
# def test_unicode_roundtrip(): TODO
|
|
# def test_unicode_bytestream(): TODO
|
|
# def test_unicode_stringstream(): TODO
|
|
# def test_unicode_and_bytes_fmt(): Not yet implemented
|
|
# def test_large_zip(self): Not yet implemeted
|
|
|
|
# TestLoadtxt
|
|
|
|
# def test_record(): TODO
|
|
|
|
def test_loadtxt_array():
|
|
data = test_dir + "/data_1.txt"
|
|
TextIO = '1 2\n3 4'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int)
|
|
a = np.array([[1, 2], [3, 4]], int)
|
|
assert np.array_equal(x, a)
|
|
|
|
x = np.loadtxt(data, dtype=float)
|
|
a = np.array([[1, 2], [3, 4]], float)
|
|
assert np.array_equal(x, a)
|
|
|
|
test_loadtxt_array()
|
|
|
|
def test_loadtxt_1D():
|
|
data = test_dir + "/data_2.txt"
|
|
TextIO = '1\n2\n3\n4\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int)
|
|
a = np.array([1, 2, 3, 4], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
data = test_dir + "/data_3.txt"
|
|
TextIO = '1,2,3,4\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',')
|
|
a = np.array([1, 2, 3, 4], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_1D()
|
|
|
|
def test_loadtxt_missing():
|
|
data = test_dir + "/data_4.txt"
|
|
TextIO = '1,2,3,,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data,
|
|
dtype=int,
|
|
delimiter=',',
|
|
converters={3: lambda s: int(s) if s else -999})
|
|
a = np.array([1, 2, 3, -999, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_missing()
|
|
|
|
def test_loadtxt_converters_with_usecols():
|
|
data = test_dir + "/data_5.txt"
|
|
TextIO = '1,2,3,,5\n6,7,8,9,10\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data,
|
|
dtype=int,
|
|
delimiter=',',
|
|
converters={3: lambda s: int(s) if s else -999},
|
|
usecols=(
|
|
1,
|
|
3,
|
|
))
|
|
a = np.array([[2, -999], [7, 9]], int)
|
|
assert np.array_equal(x, a)
|
|
|
|
test_loadtxt_converters_with_usecols()
|
|
|
|
def test_loadtxt_comments_unicode():
|
|
data = test_dir + "/data_6.txt"
|
|
TextIO = '# comment\n1,2,3,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', comments='#')
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_comments_unicode()
|
|
|
|
def test_loadtxt_comments_byte():
|
|
data = test_dir + "/data_7.txt"
|
|
TextIO = '# comment\n1,2,3,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', comments=b'#')
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_comments_byte()
|
|
|
|
# Testcase Fails
|
|
def test_loadtxt_comments_multiple():
|
|
data = test_dir + "/data_8.txt"
|
|
TextIO = '# comment\n1,2,3\n@ comment2\n4,5,6 // comment3'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
# x = np.loadtxt(data, dtype=int, delimiter=',',
|
|
# comments=['#', '@', '//'])
|
|
# a = np.array([[1, 2, 3], [4, 5, 6]], int)
|
|
# assert np.array_equal(x, a)
|
|
|
|
# test_loadtxt_comments_multiple()
|
|
|
|
def test_loadtxt_comments_multi_chars():
|
|
data = test_dir + "/data_9.txt"
|
|
TextIO = '/* comment\n1,2,3,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', comments='/*')
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_comments_multi_chars()
|
|
|
|
def test_loadtxt_skiprows():
|
|
data = test_dir + "/data_10.txt"
|
|
TextIO = 'comment\n1,2,3,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', skiprows=1)
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
data = test_dir + "/data_11.txt"
|
|
TextIO = '# comment\n1,2,3,5\n'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', skiprows=1)
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_skiprows()
|
|
|
|
def test_loadtxt_usecols():
|
|
a = np.array([[1, 2], [3, 4]], float)
|
|
data = test_dir + "/data_12.txt"
|
|
np.savetxt(data, a)
|
|
x = np.loadtxt(data, dtype=float, usecols=(1, ))
|
|
assert np.array_equal(x, a[:, 1])
|
|
|
|
a = np.array([[1, 2, 3], [3, 4, 5]], float)
|
|
data = test_dir + "/data_13.txt"
|
|
np.savetxt(data, a)
|
|
x = np.loadtxt(data, dtype=float, usecols=(1, 2))
|
|
assert np.array_equal(x, a[:, 1:])
|
|
|
|
test_loadtxt_usecols()
|
|
|
|
# def test_bad_usecols(): TODO
|
|
# def test_fancy_dtype(self): TODO
|
|
# def test_shaped_dtype(self): TODO
|
|
# def test_3d_shaped_dtype(self): TODO
|
|
# def test_str_dtype(): TODO
|
|
# def test_empty_file(): TODO
|
|
# def test_unused_converter(self): TODO
|
|
# def test_dtype_with_object(self): Not yet implemented
|
|
# def test_uint64_type(self): TODO
|
|
# def test_int64_type(self): TODO
|
|
# def test_from_float_hex(self): TODO
|
|
# def test_default_float_converter_no_default_hex_conversion(self): TODO
|
|
# def test_default_float_converter_exception(self): TODO
|
|
# def test_from_complex(self): TODO
|
|
# def test_complex_misformatted(self): TODO
|
|
# def test_universal_newline(self): TODO
|
|
# def test_empty_field_after_tab(self): TODO
|
|
# def test_unpack_structured(self): TODO
|
|
# def test_ndmin_keyword(self): TODO
|
|
# def test_generator_source(self): TODO
|
|
# def test_bad_line(self): TODO
|
|
# def test_none_as_string(self): TODO
|
|
# def test_binary_load(self): TODO
|
|
|
|
def test_loadtxt_max_rows():
|
|
data = test_dir + "/data_36.txt"
|
|
TextIO = '1,2,3,5\n4,5,7,8\n2,1,4,5'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', max_rows=1)
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
test_loadtxt_max_rows()
|
|
|
|
def test_loadtxt_max_rows_with_skiprows():
|
|
data = test_dir + "/data_37.txt"
|
|
TextIO = 'comments\n1,2,3,5\n4,5,7,8\n2,1,4,5'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', skiprows=1, max_rows=1)
|
|
a = np.array([1, 2, 3, 5], int)
|
|
assert np.array_equal(x.reshape(-1), a)
|
|
|
|
data = test_dir + "/data_38.txt"
|
|
TextIO = 'comment\n1,2,3,5\n4,5,7,8\n2,1,4,5'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', skiprows=1, max_rows=2)
|
|
a = np.array([[1, 2, 3, 5], [4, 5, 7, 8]], int)
|
|
assert np.array_equal(x, a)
|
|
|
|
test_loadtxt_max_rows_with_skiprows()
|
|
|
|
# def test_max_rows_with_read_continuation(self): TODO
|
|
|
|
def test_loadtxt_max_rows_larger():
|
|
#test max_rows > num rows
|
|
data = test_dir + "/data_40.txt"
|
|
TextIO = 'comment\n1,2,3,5\n4,5,7,8\n2,1,4,5'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
x = np.loadtxt(data, dtype=int, delimiter=',', skiprows=1, max_rows=6)
|
|
a = np.array([[1, 2, 3, 5], [4, 5, 7, 8], [2, 1, 4, 5]], int)
|
|
assert np.array_equal(x, a)
|
|
|
|
test_loadtxt_max_rows_larger()
|
|
|
|
# def test_max_rows_empty_lines(self, skip, data): TODO
|
|
|
|
# TestGenFromTxt, TestSaveTxt, TestLoadTxt
|
|
|
|
# def test_record(self): TODO
|
|
|
|
def test_gft_array():
|
|
# Test outputting a standard ndarray
|
|
filename = test_dir + '/data_41.txt'
|
|
control = np.array([[1, 2], [3, 4]], dtype=int)
|
|
np.savetxt(filename, control)
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=' ')
|
|
assert np.array_equal(test, control)
|
|
|
|
control = np.array([[1, 2], [3, 4]], dtype=float)
|
|
np.savetxt(filename, control)
|
|
test = np.loadtxt(filename, dtype=float, delimiter=' ')
|
|
assert np.array_equal(test, control)
|
|
|
|
test_gft_array()
|
|
|
|
def test_gft_1D():
|
|
# Test squeezing to 1D
|
|
filename = test_dir + '/data_42.txt'
|
|
control = np.array([1, 2, 3, 4], dtype=int)
|
|
np.savetxt(filename, control, delimiter='\n')
|
|
test = np.genfromtxt(filename, dtype=int)
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
np.savetxt(filename, control, delimiter=',')
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=',')
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
test_gft_1D()
|
|
|
|
def test_gft_comments():
|
|
# Test the stripping of comments
|
|
filename = test_dir + '/data_43.txt'
|
|
control = np.array([1, 2, 3, 5], dtype=int)
|
|
content = "# comment\n1,2,3,5\n"
|
|
with open(filename, "w") as f:
|
|
f.write(content)
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=',', comments='#')
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
# Comment at the end of a line
|
|
content = "1,2,3,5# comment\n"
|
|
with open(filename, "w") as f:
|
|
f.write(content)
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=',', comments='#')
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
test_gft_comments()
|
|
|
|
def test_gft_skiprows():
|
|
# Test row skipping
|
|
filename = test_dir + '/data_44.txt'
|
|
control = np.array([1, 2, 3, 5], dtype=int)
|
|
content = 'comment\n1,2,3,5\n'
|
|
with open(filename, "w") as f:
|
|
f.write(content)
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=',', skip_header=1)
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
filename = test_dir + '/data_45.txt'
|
|
content = '# comment\n1,2,3,5\n'
|
|
with open(filename, "w") as f:
|
|
f.write(content)
|
|
test = np.loadtxt(filename,
|
|
dtype=int,
|
|
delimiter=',',
|
|
skiprows=1,
|
|
comments='#')
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
test_gft_skiprows()
|
|
|
|
def test_gft_skip_footer():
|
|
filename = test_dir + '/data_46.txt'
|
|
control = np.array([1, 2, 3, 5], dtype=int)
|
|
content = '1,2,3,5\n comment\n'
|
|
with open(filename, "w") as f:
|
|
f.write(content)
|
|
test = np.genfromtxt(filename, dtype=int, delimiter=',', skip_footer=1)
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
test_gft_skip_footer()
|
|
|
|
# def test_skip_footer_with_invalid(self): TODO
|
|
# def test_header(self): TODO
|
|
# def test_auto_dtype(self): TODO
|
|
|
|
def test_auto_dtype_uniform():
|
|
# Tests whether the output dtype can be uniformized
|
|
data = test_dir + '/data_50.txt'
|
|
TextIO = '1 2 3 4\n5 6 7 8\n'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
test = np.genfromtxt(data, dtype=None)
|
|
control = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=None)
|
|
assert np.array_equal(test, control)
|
|
|
|
# test_auto_dtype_uniform()
|
|
|
|
# def test_fancy_dtype(self): TODO
|
|
# def test_names_overwrite(self): TODO
|
|
# def test_bad_fname(self): TODO
|
|
# def test_commented_header(self): TODO
|
|
# def test_names_and_comments_none(self): TODO
|
|
# def test_file_is_closed_on_error(self): TODO
|
|
# def test_autonames_and_usecols(self): TODO
|
|
|
|
def test_converters_with_usecols():
|
|
# Test the combination user-defined converters and usecol
|
|
data = test_dir + '/data_58.txt'
|
|
TextIO = '1,2,3,,5\n6,7,8,9,10\n'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
test = np.genfromtxt(data,
|
|
dtype=int,
|
|
delimiter=',',
|
|
converters={3: lambda s: int(s) if s else -999},
|
|
usecols=(
|
|
1,
|
|
3,
|
|
))
|
|
control = np.array([[2, -999], [7, 9]], dtype=int)
|
|
assert np.array_equal(test, control)
|
|
|
|
test_converters_with_usecols()
|
|
|
|
# def test_converters_with_usecols_and_names(self): TODO
|
|
# def test_converters_cornercases(self): TODO
|
|
# def test_converters_cornercases2(self): TODO
|
|
|
|
def test_unused_converter():
|
|
TextIO = "1 21\n3 42\n"
|
|
data = test_dir + '/data_62.txt'
|
|
with open(data, "w") as fh:
|
|
fh.write(TextIO)
|
|
|
|
test = np.genfromtxt(data,
|
|
dtype=int,
|
|
usecols=(1, ),
|
|
converters={0: lambda s: int(s) if s else 16})
|
|
assert np.array_equal(test, [21, 42])
|
|
|
|
test_unused_converter()
|
|
|
|
# def test_invalid_converter(self): TODO
|
|
# def test_tricky_converter_bug1666(self): TODO
|
|
# def test_dtype_with_converters(self): TODO
|
|
# def test_dtype_with_converters_and_usecols(self): TODO
|
|
# def test_dtype_with_object(self): TODO
|
|
# def test_dtype_with_object_no_converter(self): TODO
|
|
# def test_userconverters_with_explicit_dtype(self): TODO
|
|
# def test_utf8_userconverters_with_explicit_dtype(self): TODO
|
|
|
|
def test_spacedelimiter():
|
|
# Test space delimiter
|
|
TextIO = "1 2 3 4 5\n6 7 8 9 10"
|
|
data = test_dir + '/data_71.txt'
|
|
with open(data, "w") as file:
|
|
file.write(TextIO)
|
|
test = np.genfromtxt(data)
|
|
control = np.array([[1., 2., 3., 4., 5.], [6., 7., 8., 9., 10.]])
|
|
assert np.array_equal(test, control)
|
|
|
|
test_spacedelimiter()
|
|
|
|
def test_integer_delimiter():
|
|
# Test using an integer for delimiter
|
|
TextIO = " 1 2 3\n 4 5 67\n890123 4"
|
|
data = test_dir + '/data_72.txt'
|
|
with open(data, "w") as file:
|
|
file.write(TextIO)
|
|
test = np.genfromtxt(data, delimiter=3)
|
|
control = np.array([[1, 2, 3], [4, 5, 67], [890, 123, 4]])
|
|
assert np.array_equal(test, control)
|
|
|
|
test_integer_delimiter()
|
|
|
|
def test_gft_missing():
|
|
TextIO = '1,2,3,,5\n'
|
|
data = test_dir + '/data_73.txt'
|
|
with open(data, "w") as file:
|
|
file.write(TextIO)
|
|
test = np.genfromtxt(data,
|
|
dtype=int,
|
|
delimiter=',',
|
|
converters={3: lambda s: int(s) if s else -999})
|
|
control = np.array([1, 2, 3, -999, 5], int)
|
|
assert np.array_equal(test.reshape(-1), control)
|
|
|
|
test_gft_missing()
|
|
|
|
# def test_missing_with_tabs(self): TODO
|
|
|
|
def test_gft_usecols():
|
|
# Test the selection of columns
|
|
# Select 1 column
|
|
control = np.array([[1, 2], [3, 4]], float)
|
|
data = test_dir + '/data_75.txt'
|
|
np.savetxt(data, control)
|
|
test = np.genfromtxt(data, dtype=float, usecols=(1, ))
|
|
assert np.array_equal(test, control[:, 1])
|
|
#
|
|
control = np.array([[1, 2, 3], [3, 4, 5]], float)
|
|
data = test_dir + '/data_76.txt'
|
|
np.savetxt(data, control)
|
|
test = np.genfromtxt(data, dtype=float, usecols=(1, 2))
|
|
assert np.array_equal(test, control[:, 1:])
|
|
|
|
test_gft_usecols()
|
|
|
|
# def test_usecols_as_css(self): TODO
|
|
# def test_usecols_with_structured_dtype(self): TODO
|
|
|
|
def test_usecols_with_integer():
|
|
# Test usecols with an integer
|
|
TextIO = b"1 2 3\n4 5 6"
|
|
data = test_dir + '/data_79.txt'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
test = np.genfromtxt(data, usecols=0)
|
|
assert np.array_equal(test, np.array([1., 4.]))
|
|
|
|
test_usecols_with_integer()
|
|
|
|
# def test_usecols_with_named_columns(self): TODO
|
|
# def test_empty_file(self): TODO
|
|
# def test_fancy_dtype_alt(self): TODO
|
|
# def test_shaped_dtype(self): TODO
|
|
# def test_withmissing(self): TODO
|
|
# def test_user_missing_values(self): TODO
|
|
# def test_user_filling_values(self): TODO
|
|
# def test_withmissing_float(self): TODO
|
|
# def test_with_masked_column_uniform(self): TODO
|
|
# def test_with_masked_column_various(self): TODO
|
|
# def test_invalid_raise(self): TODO
|
|
# def test_invalid_raise_with_usecols(self): TODO
|
|
# def test_inconsistent_dtype(self): TODO
|
|
# def test_default_field_format(self): TODO
|
|
# def test_single_dtype_wo_names(self): TODO
|
|
# def test_single_dtype_w_explicit_names(self): TODO
|
|
# def test_single_dtype_w_implicit_names(self): TODO
|
|
# def test_easy_structured_dtype(self): TODO
|
|
# def test_autostrip(self): TODO
|
|
# def test_replace_space(self): TODO
|
|
# def test_replace_space_known_dtype(self): TODO
|
|
# def test_incomplete_names(self): TODO
|
|
# def test_names_auto_completion(self): TODO
|
|
# def test_names_with_usecols_bug1636(self): TODO
|
|
# def test_fixed_width_names(self): TODO
|
|
# def test_filling_values(self): TODO
|
|
# def test_comments_is_none(self): TODO
|
|
# def test_latin1(self): TODO
|
|
# def test_binary_decode_autodtype(self): TODO
|
|
# def test_utf8_byte_encoding(self): TODO
|
|
# def test_utf8_file(self): TODO
|
|
# def test_utf8_file_nodtype_unicode(self): TODO
|
|
|
|
# def test_names_auto_completion(): TODO
|
|
|
|
# def test_names_with_usecols_bug1636(): TODO
|
|
|
|
def test_filling_values():
|
|
# Test missing values
|
|
TextIO = b"1, 2, 3\n1, , 5\n0, 6, \n"
|
|
data = test_dir + '/data_113.txt'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
ctrl = np.array([[1, 2, 3], [1, -999, 5], [0, 6, -999]], dtype=int)
|
|
test = np.genfromtxt(data, delimiter=",", dtype=int, filling_values=-999)
|
|
assert np.array_equal(test, ctrl)
|
|
|
|
test_filling_values()
|
|
|
|
def test_gft_max_rows():
|
|
# Test the `max_rows` keyword argument.
|
|
TextIO = '1 2\n3 4\n5 6\n7 8\n9 10\n'
|
|
data = test_dir + '/data_114.txt'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
a1 = np.genfromtxt(data, max_rows=3)
|
|
a2 = np.genfromtxt(data)
|
|
assert np.array_equal(a1, [[1, 2], [3, 4], [5, 6]])
|
|
assert np.array_equal(a2, [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]])
|
|
|
|
# max_rows must be at least 1.
|
|
try:
|
|
a3 = np.genfromtxt(data, max_rows=0)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
# An input with several invalid rows.
|
|
data = test_dir + '/data_115.txt'
|
|
TextIO = '1 1\n2 2\n0 \n3 3\n4 4\n5 \n6 \n7 \n'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
test = np.genfromtxt(data, max_rows=2)
|
|
control = np.array([[1., 1.], [2., 2.]])
|
|
assert np.array_equal(test, control)
|
|
|
|
# Test keywords conflict
|
|
try:
|
|
a4 = np.genfromtxt(data, skip_footer=1, max_rows=4)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
a5 = np.genfromtxt(data, max_rows=4)
|
|
assert False
|
|
except IOError:
|
|
pass
|
|
|
|
test_gft_max_rows()
|
|
|
|
def test_gft_using_filename():
|
|
# Test that we can load data from a filename as well as a file
|
|
# object
|
|
tgt = np.arange(6).reshape((2, 3))
|
|
linesep = ('\n', '\r\n', '\r')
|
|
i = 116
|
|
for sep in linesep:
|
|
f = f"{test_dir}/data_{i}.txt"
|
|
data = '0 1 2' + sep + '3 4 5'
|
|
with open(f, 'w') as g:
|
|
g.write(data)
|
|
i += 1
|
|
res = np.genfromtxt(f)
|
|
assert np.array_equal(res, tgt)
|
|
|
|
test_gft_using_filename()
|
|
|
|
def test_gft_from_gzip():
|
|
# Test that we can load data from a gzipped file
|
|
wanted = np.arange(6).reshape((2, 3))
|
|
linesep = ('\n', '\r\n', '\r\n')
|
|
i = 120
|
|
for sep in linesep:
|
|
f = f"{test_dir}/data_{i}.gz"
|
|
data = '0 1 2' + sep + '3 4 5'
|
|
with gzip.open(f, mode='w') as g:
|
|
g.write(data)
|
|
i += 1
|
|
|
|
l = np.genfromtxt(f, int)
|
|
assert np.array_equal(l, wanted)
|
|
|
|
test_gft_from_gzip()
|
|
|
|
# def test_auto_dtype_largeint(self):
|
|
|
|
def test_unpack_float_data():
|
|
TextIO = ("1,2,3\n4,5,6\n7,8,9\n0.0,1.0,2.0")
|
|
data = test_dir + '/data_124.txt'
|
|
with open(data, "w") as f:
|
|
f.write(TextIO)
|
|
a, b, c = np.loadtxt(data, delimiter=",", unpack=True)
|
|
assert np.array_equal(a, np.array([1.0, 4.0, 7.0, 0.0]))
|
|
assert np.array_equal(b, np.array([2.0, 5.0, 8.0, 1.0]))
|
|
assert np.array_equal(c, np.array([3.0, 6.0, 9.0, 2.0]))
|
|
|
|
test_unpack_float_data()
|
|
|
|
# def test_unpack_structured(): TODO
|
|
# def test_unpack_auto_dtype(): TODO
|
|
# def test_unpack_single_name(): TODO
|
|
# def test_squeeze_scalar(): TODO
|
|
|
|
@test
|
|
def test_ndmin_keyword(ndim: Static[int]):
|
|
"""Test ndmin keyword consistency between genfromtxt and loadtxt."""
|
|
txt = "42"
|
|
data = test_dir + '/temp.txt'
|
|
with open(data, "w") as f:
|
|
f.write(txt)
|
|
|
|
a = np.loadtxt(data, ndmin=ndim)
|
|
b = np.genfromtxt(data, ndmin=ndim)
|
|
assert np.array_equal(a, b)
|
|
|
|
test_ndmin_keyword(0)
|
|
test_ndmin_keyword(1)
|
|
test_ndmin_keyword(2)
|
|
|
|
# TestPathUsage
|
|
|
|
def test_loadtxt():
|
|
path = test_dir + '/data_125.txt'
|
|
a = np.array([[1.1, 2.1], [3.1, 4.1]], dtype=float)
|
|
np.savetxt(path, a)
|
|
x = np.loadtxt(path)
|
|
assert np.array_equal(x, a)
|
|
|
|
test_loadtxt()
|
|
|
|
def test_save_load():
|
|
path = test_dir + '/data_126.npy'
|
|
a = np.array([[1, 2], [3, 4]], int)
|
|
np.save(path, a)
|
|
data = np.load(path, dtype=int, ndim=2)
|
|
assert np.array_equal(data, a)
|
|
|
|
test_save_load()
|
|
|
|
def test_save_load_memmap():
|
|
path = test_dir + '/data_127.npy'
|
|
a = np.array([[1, 2], [3, 4]], int)
|
|
np.save(path, a)
|
|
data = np.load(path, dtype=int, mmap_mode='r', ndim=2)
|
|
assert np.array_equal(data, a)
|
|
|
|
test_save_load_memmap()
|
|
|
|
def test_save_load_memmap_readwrite():
|
|
path = test_dir + '/data_128.npy'
|
|
a = np.array([[1, 2], [3, 4]], int)
|
|
np.save(path, a)
|
|
b = np.load(path, dtype=int, ndim=2, mmap_mode='r+')
|
|
a[0][0] = 5
|
|
b[0][0] = 5
|
|
data = np.load(path)
|
|
assert np.array_equal(data, a)
|
|
|
|
# def test_savez_load(): Not yet implemented
|
|
|
|
# def test_savez_compressed_load(): Not yet implemented
|
|
|
|
def test_genfromtxt():
|
|
path = test_dir + '/data_129.txt'
|
|
a = np.array([(1, 2), (3, 4)])
|
|
np.savetxt(path, a)
|
|
data = np.genfromtxt(path)
|
|
assert np.array_equal(a, data)
|
|
|
|
test_genfromtxt()
|
|
|
|
# Testcase fails
|
|
def test_gzip_load():
|
|
values = np.array([1, 2, 3, 4, 5])
|
|
a = np.array(values, dtype=float)
|
|
|
|
s = test_dir + '/data_130.gz'
|
|
f = gzip.open(s, mode="w")
|
|
|
|
np.save(f, a)
|
|
f.close()
|
|
f = gzip.open(s, mode="r")
|
|
g = np.load(f, dtype=float, ndim=1)
|
|
assert np.array_equal(g, a)
|
|
|
|
# test_gzip_load()
|
|
|
|
# def test_gzip_loadtxt(): Not yet implemented
|
|
# def test_gzip_loadtxt_from_string(): Not yet implemented
|
|
# def test_npzfile_dict(): Not yet implemented
|
|
# def test_load_refcount(): Not yet implemented
|
|
# def test_load_multiple_arrays_until_eof()
|
|
|
|
# Additional tests
|
|
|
|
# Testcases related to bz2 files
|
|
|
|
# Testcase fails
|
|
def test_gft_from_bz2():
|
|
# Test that we can load data from a bz2 compressed file
|
|
wanted = np.arange(6).reshape((2, 3))
|
|
linesep = ('\n', '\r\n', '\r\n')
|
|
i = 136
|
|
for sep in linesep:
|
|
f = f"{test_dir}/data_{i}.bz2"
|
|
data = '0 1 2' + sep + '3 4 5'
|
|
with bz2.open(f, mode='w') as b:
|
|
b.write(data)
|
|
i += 1
|
|
|
|
l = np.genfromtxt(f, int)
|
|
assert np.array_equal(l, wanted)
|
|
|
|
test_gft_from_bz2()
|
|
|
|
# Testcase fails
|
|
def test_bz2_load():
|
|
values = np.array([1, 2, 3, 4, 5])
|
|
a = np.array(values, dtype=float)
|
|
|
|
s = test_dir + '/data_140.bz2'
|
|
f = bz2.open(s, mode="w")
|
|
np.save(f, a)
|
|
f.close()
|
|
f = bz2.open(s, mode="r")
|
|
g = np.load(f, dtype=float)
|
|
assert np.array_equal(g, a)
|
|
|
|
# test_bz2_load()
|
|
|
|
def test_save_load_int32_1d_v1():
|
|
array = np.array([1, 2, 3], dtype=np.int32)
|
|
filename = test_dir + "/binary_int32_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int32)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int32_1d_v1()
|
|
|
|
def test_save_load_int64_1d_v1():
|
|
array = np.array([1, 2, 3], dtype=np.int64)
|
|
filename = test_dir + "/binary_int64_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int64)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int64_1d_v1()
|
|
|
|
def test_save_load_float32_1d_v1():
|
|
array = np.array([1.0, 2.5, 3.7], dtype=np.float32)
|
|
filename = test_dir + "/binary_float32_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float32)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float32_1d_v1()
|
|
|
|
def test_save_load_float64_1d_v1():
|
|
array = np.array([1.0, 2.5, 3.7], dtype=np.float64)
|
|
filename = test_dir + "/binary_float64_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float64)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float64_1d_v1()
|
|
|
|
def test_save_load_complex64_1d_v1():
|
|
array = np.array([1.0 + 2.0j, 3.5 - 1.2j], dtype=np.complex64)
|
|
filename = test_dir + "/binary_complex64_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex64)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex64_1d_v1()
|
|
|
|
def test_save_load_complex128_1d_v1():
|
|
array = np.array([1.0 + 2.0j, 3.5 - 1.2j], dtype=np.complex128)
|
|
filename = test_dir + "/binary_complex128_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex128)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex128_1d_v1()
|
|
|
|
def test_save_load_bool_1d_v1():
|
|
array = np.array([True, False, True], dtype=bool)
|
|
filename = test_dir + "/binary_bool_1d_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=bool)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_bool_1d_v1()
|
|
|
|
def test_save_load_int32_2d_3x3_v1():
|
|
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int32)
|
|
filename = test_dir + "/binary_int32_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int32, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int32_2d_3x3_v1()
|
|
|
|
def test_save_load_int64_2d_3x3_v1():
|
|
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int64)
|
|
filename = test_dir + "/binary_int64_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int64, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int64_2d_3x3_v1()
|
|
|
|
def test_save_load_float32_2d_3x3_v1():
|
|
array = np.array([[1.0, 2.5, 3.7], [4.2, 5.3, 6.1], [7.0, 8.2, 9.5]],
|
|
dtype=np.float32)
|
|
filename = test_dir + "/binary_float32_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float32, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float32_2d_3x3_v1()
|
|
|
|
def test_save_load_float64_2d_3x3_v1():
|
|
array = np.array([[1.0, 2.5, 3.7], [4.2, 5.3, 6.1], [7.0, 8.2, 9.5]],
|
|
dtype=np.float64)
|
|
filename = test_dir + "/binary_float64_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float64, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float64_2d_3x3_v1()
|
|
|
|
def test_save_load_complex64_2d_3x3_v1():
|
|
array = np.array([[1.0 + 2.0j, 3.5 - 1.2j, 4.0 + 0.5j],
|
|
[5.0 - 2.1j, 6.7 + 1.2j, 7.3 - 0.8j],
|
|
[8.0 + 1.5j, 9.2 - 0.7j, 10.0 + 2.0j]],
|
|
dtype=np.complex64)
|
|
filename = test_dir + "/binary_complex64_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex64, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex64_2d_3x3_v1()
|
|
|
|
def test_save_load_complex128_2d_3x3_v1():
|
|
array = np.array([[1.0 + 2.0j, 3.5 - 1.2j, 4.0 + 0.5j],
|
|
[5.0 - 2.1j, 6.7 + 1.2j, 7.3 - 0.8j],
|
|
[8.0 + 1.5j, 9.2 - 0.7j, 10.0 + 2.0j]],
|
|
dtype=np.complex128)
|
|
filename = test_dir + "/binary_complex128_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex128, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex128_2d_3x3_v1()
|
|
|
|
def test_save_load_bool_2d_3x3_v1():
|
|
array = np.array(
|
|
[[True, False, True], [False, True, False], [True, True, False]],
|
|
dtype=bool)
|
|
filename = test_dir + "/binary_bool_2d_3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=bool, ndim=2)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_bool_2d_3x3_v1()
|
|
|
|
def test_save_load_int32_3d_3x3x3_v1():
|
|
array = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
|
|
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]],
|
|
dtype=np.int32)
|
|
filename = test_dir + "/binary_int32_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int32, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int32_3d_3x3x3_v1()
|
|
|
|
def test_save_load_int64_3d_3x3x3_v1():
|
|
array = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
|
|
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]],
|
|
dtype=np.int64)
|
|
filename = test_dir + "/binary_int64_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.int64, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_int64_3d_3x3x3_v1()
|
|
|
|
def test_save_load_float32_3d_3x3x3_v1():
|
|
array = np.array(
|
|
[[[1.0, 2.5, 3.7], [4.2, 5.3, 6.1], [7.0, 8.2, 9.5]],
|
|
[[10.1, 11.5, 12.7], [13.2, 14.8, 15.4], [16.0, 17.3, 18.9]],
|
|
[[19.5, 20.2, 21.8], [22.0, 23.7, 24.1], [25.3, 26.9, 27.4]]],
|
|
dtype=np.float32)
|
|
filename = test_dir + "/binary_float32_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float32, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float32_3d_3x3x3_v1()
|
|
|
|
def test_save_load_float64_3d_3x3x3_v1():
|
|
array = np.array(
|
|
[[[1.0, 2.5, 3.7], [4.2, 5.3, 6.1], [7.0, 8.2, 9.5]],
|
|
[[10.1, 11.5, 12.7], [13.2, 14.8, 15.4], [16.0, 17.3, 18.9]],
|
|
[[19.5, 20.2, 21.8], [22.0, 23.7, 24.1], [25.3, 26.9, 27.4]]],
|
|
dtype=np.float64)
|
|
filename = test_dir + "/binary_float64_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.float64, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_float64_3d_3x3x3_v1()
|
|
|
|
def test_save_load_complex64_3d_3x3x3_v1():
|
|
array = np.array([[[1.0 + 2.0j, 3.5 - 1.2j, 4.0 + 0.5j],
|
|
[5.0 - 2.1j, 6.7 + 1.2j, 7.3 - 0.8j],
|
|
[8.0 + 1.5j, 9.2 - 0.7j, 10.0 + 2.0j]],
|
|
[[11.0 - 1.0j, 12.5 + 2.3j, 13.7 - 0.9j],
|
|
[14.2 + 1.2j, 15.3 - 2.5j, 16.1 + 0.8j],
|
|
[17.0 - 1.5j, 18.2 + 0.7j, 19.5 - 2.0j]],
|
|
[[20.0 + 3.0j, 21.5 - 2.3j, 22.7 + 1.9j],
|
|
[23.2 - 1.2j, 24.8 + 2.5j, 25.4 - 0.8j],
|
|
[26.0 + 1.5j, 27.3 - 0.7j, 28.9 + 2.0j]]],
|
|
dtype=np.complex64)
|
|
filename = test_dir + "/binary_complex64_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex64, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex64_3d_3x3x3_v1()
|
|
|
|
def test_save_load_complex128_3d_3x3x3_v1():
|
|
array = np.array([[[1.0 + 2.0j, 3.5 - 1.2j, 4.0 + 0.5j],
|
|
[5.0 - 2.1j, 6.7 + 1.2j, 7.3 - 0.8j],
|
|
[8.0 + 1.5j, 9.2 - 0.7j, 10.0 + 2.0j]],
|
|
[[11.0 - 1.0j, 12.5 + 2.3j, 13.7 - 0.9j],
|
|
[14.2 + 1.2j, 15.3 - 2.5j, 16.1 + 0.8j],
|
|
[17.0 - 1.5j, 18.2 + 0.7j, 19.5 - 2.0j]],
|
|
[[20.0 + 3.0j, 21.5 - 2.3j, 22.7 + 1.9j],
|
|
[23.2 - 1.2j, 24.8 + 2.5j, 25.4 - 0.8j],
|
|
[26.0 + 1.5j, 27.3 - 0.7j, 28.9 + 2.0j]]],
|
|
dtype=np.complex128)
|
|
filename = test_dir + "/binary_complex128_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=np.complex128, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_complex128_3d_3x3x3_v1()
|
|
|
|
def test_save_load_bool_3d_3x3x3_v1():
|
|
array = np.array(
|
|
[[[True, False, True], [False, True, False], [True, True, False]],
|
|
[[False, False, True], [True, False, True], [False, True, False]],
|
|
[[True, False, False], [False, True, True], [True, True, False]]],
|
|
dtype=bool)
|
|
filename = test_dir + "/binary_bool_3d_3x3x3_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename, dtype=bool, ndim=3)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_save_load_bool_3d_3x3x3_v1()
|
|
|
|
# Negative Testcases
|
|
|
|
def test_load_invalid_path_v1():
|
|
filename = test_dir + "/binary_invalid_path_v1.npy"
|
|
try:
|
|
loaded_array = np.load(filename, dtype=int)
|
|
assert False
|
|
except IOError:
|
|
pass
|
|
|
|
test_load_invalid_path_v1()
|
|
|
|
def test_load_corrupted_file_v1():
|
|
filename = test_dir + "/binary_corrupted_file_v1.npy"
|
|
try:
|
|
with open(filename, 'wb') as f:
|
|
f.write('corrupted_data')
|
|
np.load(filename)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
test_load_corrupted_file_v1()
|
|
|
|
def test_load_version_mismatch_v1():
|
|
array = np.array([1, 2, 3])
|
|
filename = test_dir + "/binary_version_mismatch_v1.npy"
|
|
np.save(filename, array)
|
|
try:
|
|
with open(filename, 'rb+') as f:
|
|
f.seek(0, 6)
|
|
f.write('\x00\x00') # Change the version to 0
|
|
np.load(filename)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
test_load_version_mismatch_v1()
|
|
|
|
def test_load_mismatched_dtype_v1():
|
|
# Save with dtype int and load with other dtype
|
|
array = np.array([1, 2, 3], dtype=int)
|
|
filename = test_dir + "/binary_mismatched_dtype_v1.npy"
|
|
np.save(filename, array)
|
|
np.load(filename, dtype=int)
|
|
|
|
test_load_mismatched_dtype_v1()
|
|
|
|
def test_load_empty_array_v1():
|
|
# Save an empty array and load
|
|
array = np.array(np.empty((1, )), dtype=int)
|
|
filename = test_dir + "/binary_empty_array_v1.npy"
|
|
np.save(filename, array)
|
|
loaded_array = np.load(filename)
|
|
assert np.array_equal(array, loaded_array)
|
|
|
|
test_load_empty_array_v1()
|
|
|
|
def test_load_incorrect_filename_v1():
|
|
# Save using filename contains special character or too long
|
|
array = np.array([1, 2, 3])
|
|
filename = test_dir + "/binary_incorrect_filename-@!$%^&*()_+=~`{}[].np_v1.npy"
|
|
np.save(filename, array)
|
|
np.load(filename)
|
|
|
|
test_load_incorrect_filename_v1()
|
|
|
|
def test_load_incorrect_save_v1():
|
|
# Interrupt the saving process to create incomplete .npy file
|
|
array = np.array([1, 2, 3])
|
|
filename = test_dir + "/binary_incorrect_save_v1.npy"
|
|
# Save a partial array
|
|
with open(filename, 'wb') as f:
|
|
f.write("\x93NUMPY")
|
|
f.write("\x01\x00\x00\x00")
|
|
f.write("\x00\x00\x00\x00")
|
|
f.write("\x00\x00\x00\x00\x00\x00\x00\x00")
|
|
f.write("\x00")
|
|
f.write("\x00")
|
|
try:
|
|
np.load(filename)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
test_load_incorrect_save_v1()
|
|
|
|
def test_incorrect_extension_v1():
|
|
filename = test_dir + "/binary_incorrect_extension.npa"
|
|
np.save(filename, np.array([1, 2, 3]))
|
|
try:
|
|
np.load(filename, dtype=int)
|
|
assert False
|
|
except IOError:
|
|
pass
|
|
|
|
test_incorrect_extension_v1()
|