def print_versions():
"""Print all the versions of software that PyTables relies on."""
print('-=' * 38)
print("PyTables version: %s" % tables.__version__)
print("HDF5 version: %s" % tables.which_lib_version("hdf5")[1])
print("NumPy version: %s" % numpy.__version__)
tinfo = tables.which_lib_version("zlib")
if numexpr.use_vml:
# Get only the main version number and strip out all the rest
vml_version = numexpr.get_vml_version()
vml_version = re.findall("[0-9.]+", vml_version)[0]
vml_avail = "using VML/MKL %s" % vml_version
else:
vml_avail = "not using Intel's VML/MKL"
print("Numexpr version: %s (%s)" % (numexpr.__version__, vml_avail))
if tinfo is not None:
print("Zlib version: %s (%s)" % (tinfo[1],
"in Python interpreter"))
tinfo = tables.which_lib_version("lzo")
if tinfo is not None:
print("LZO version: %s (%s)" % (tinfo[1], tinfo[2]))
tinfo = tables.which_lib_version("bzip2")
if tinfo is not None:
print("BZIP2 version: %s (%s)" % (tinfo[1], tinfo[2]))
tinfo = tables.which_lib_version("blosc")
if tinfo is not None:
blosc_date = tinfo[2].split()[1]
print("Blosc version: %s (%s)" % (tinfo[1], blosc_date))
blosc_cinfo = tables.blosc_get_complib_info()
blosc_cinfo = [
"%s (%s)" % (k, v[1]) for k, v in sorted(blosc_cinfo.items())
]
print("Blosc compressors: %s" % ', '.join(blosc_cinfo))
blosc_finfo = ['shuffle']
if tinfo[1] >= min_blosc_bitshuffle_version:
blosc_finfo.append('bitshuffle')
print("Blosc filters: %s" % ', '.join(blosc_finfo))
try:
from Cython import __version__ as cython_version
print('Cython version: %s' % cython_version)
except:
pass
print('Python version: %s' % sys.version)
print('Platform: %s' % platform.platform())
#if os.name == 'posix':
# (sysname, nodename, release, version, machine) = os.uname()
# print('Platform: %s-%s' % (sys.platform, machine))
print('Byte-ordering: %s' % sys.byteorder)
print('Detected cores: %s' % detect_number_of_cores())
print('Default encoding: %s' % sys.getdefaultencoding())
print('Default FS encoding: %s' % sys.getfilesystemencoding())
print('Default locale: (%s, %s)' % locale.getdefaultlocale())
print('-=' * 38)
# This should improve readability whan tests are run by CI tools
sys.stdout.flush()
def print_versions():
"""Print all the versions of software that PyTables relies on."""
print '-=' * 38
print "PyTables version: %s" % tables.__version__
print "HDF5 version: %s" % tables.which_lib_version("hdf5")[1]
print "NumPy version: %s" % numpy.__version__
tinfo = tables.which_lib_version("zlib")
if numexpr.use_vml:
# Get only the main version number and strip out all the rest
vml_version = numexpr.get_vml_version()
vml_version = re.findall("[0-9.]+", vml_version)[0]
vml_avail = "using VML/MKL %s" % vml_version
else:
vml_avail = "not using Intel's VML/MKL"
print "Numexpr version: %s (%s)" % (numexpr.__version__, vml_avail)
if tinfo is not None:
print "Zlib version: %s (%s)" % (tinfo[1], "in Python interpreter")
tinfo = tables.which_lib_version("lzo")
if tinfo is not None:
print "LZO version: %s (%s)" % (tinfo[1], tinfo[2])
tinfo = tables.which_lib_version("bzip2")
if tinfo is not None:
print "BZIP2 version: %s (%s)" % (tinfo[1], tinfo[2])
tinfo = tables.which_lib_version("blosc")
if tinfo is not None:
blosc_date = tinfo[2].split()[1]
print "Blosc version: %s (%s)" % (tinfo[1], blosc_date)
try:
from Cython.Compiler.Main import Version as Cython_Version
print 'Cython version: %s' % Cython_Version.version
except:
pass
print 'Python version: %s' % sys.version
if os.name == 'posix':
(sysname, nodename, release, version, machine) = os.uname()
print 'Platform: %s-%s' % (sys.platform, machine)
print 'Byte-ordering: %s' % sys.byteorder
print 'Detected cores: %s' % detect_number_of_cores()
print 'Default encoding: %s' % sys.getdefaultencoding()
print '-=' * 38
import sys
import tables
import tables._comp_bzip2
# We don't build this one on Windows.
if not sys.platform == "win32":
import tables._comp_lzo
import tables.hdf5extension
import tables.indexesextension
import tables.linkextension
import tables.lrucacheextension
import tables.tableextension
import tables.utilsextension
tables.print_versions()
if sys.platform.startswith('linux'):
lzo_ver = tables.which_lib_version("lzo")[1]
assert lzo_ver == '2.06', lzo_ver
from multiprocessing import freeze_support
freeze_support()
tables.test()
try:
result = unittest.TextTestRunner(verbosity=1+int(verbose)).run(suite())
if result.wasSuccessful():
return 0
else:
return 1
finally:
#common.verbose = oldverbose
common.heavy = oldheavy # there are pretty young heavies, too ;)
if __name__ == '__main__':
common.parse_argv(sys.argv)
hdf5_version = get_tuple_version(tables.which_lib_version("hdf5")[0])
if hdf5_version < min_hdf5_version:
print("*Warning*: HDF5 version is lower than recommended: %s < %s" %
(hdf5_version, min_hdf5_version))
if numpy.__version__ < min_numpy_version:
print("*Warning*: NumPy version is lower than recommended: %s < %s" %
(numpy.__version__, min_numpy_version))
# Handle some global flags (i.e. only useful for test_all.py)
only_versions = 0
args = sys.argv[:]
for arg in args:
# Remove 'show-versions' for PyTables 2.3 or higher
if arg in ['--print-versions', '--show-versions']:
only_versions = True
f.close()
print_filesize(h5fname, clib, clevel)
if __name__ == '__main__':
tb.print_versions()
print "Total size for datasets:", round(2*N*dtype.itemsize/MB, 1), "MB"
# Get the compression libraries supported
#supported_clibs = [clib for clib in ("zlib", "lzo", "bzip2", "blosc")
#supported_clibs = [clib for clib in ("zlib", "lzo", "blosc")
supported_clibs = [clib for clib in ("blosc",)
if tb.which_lib_version(clib)]
# Initialization code
#for what in ["numpy", "numpy.memmap", "numexpr"]:
for what in ["numpy", "numexpr"]:
#break
print "Populating x using %s with %d points..." % (what, N)
t0 = time()
if what == "numpy":
populate_x_numpy()
compute = compute_numpy
elif what == "numexpr":
populate_x_numpy()
compute = compute_numexpr
elif what == "numpy.memmap":
populate_x_memmap()
from __future__ import absolute_import
# Imports
# =======
import warnings
import numpy
from . import utilsextension, blosc_compressor_list, blosc_compcode_to_compname
from .exceptions import FiltersWarning
import six
from distutils.version import LooseVersion
import tables
from tables.req_versions import min_blosc_bitshuffle_version
blosc_version = LooseVersion(tables.which_lib_version("blosc")[1])
# Public variables
# ================
__docformat__ = 'reStructuredText'
"""The format of documentation strings in this module."""
all_complibs = ['zlib', 'lzo', 'bzip2', 'blosc']
all_complibs += ['blosc:%s' % cname for cname in blosc_compressor_list()]
"""List of all compression libraries."""
foreign_complibs = ['szip']
"""List of known but unsupported compression libraries."""
try:
result = unittest.TextTestRunner(verbosity=1+int(verbose)).run(suite())
if result.wasSuccessful():
return 0
else:
return 1
finally:
#common.verbose = oldverbose
common.heavy = oldheavy # there are pretty young heavies, too ;)
if __name__ == '__main__':
common.parse_argv(sys.argv)
hdf5_version = get_tuple_version(tables.which_lib_version("hdf5")[0])
if hdf5_version < min_hdf5_version:
print("*Warning*: HDF5 version is lower than recommended: %s < %s" %
(hdf5_version, min_hdf5_version))
if numpy.__version__ < min_numpy_version:
print("*Warning*: NumPy version is lower than recommended: %s < %s" %
(numpy.__version__, min_numpy_version))
# Handle some global flags (i.e. only useful for test_all.py)
only_versions = 0
args = sys.argv[:]
for arg in args:
# Remove 'show-versions' for PyTables 2.3 or higher
if arg in ['--print-versions', '--show-versions']:
only_versions = True
import tempfile
import warnings
from time import perf_counter as clock
from distutils.version import LooseVersion
import unittest
import numpy
import numexpr
import tables
from tables.utils import detect_number_of_cores
from tables.req_versions import min_blosc_bitshuffle_version
hdf5_version = LooseVersion(tables.hdf5_version)
blosc_version = LooseVersion(tables.which_lib_version("blosc")[1])
verbose = False
"""Show detailed output of the testing process."""
heavy = False
"""Run all tests even when they take long to complete."""
show_memory = False
"""Show the progress of memory consumption."""
def parse_argv(argv):
global verbose, heavy
if 'verbose' in argv:
f.close()
print_filesize(h5fname, clib, clevel)
if __name__ == '__main__':
tb.print_versions()
print(f"Total size for datasets: {2 * N * dtype.itemsize / MB:.1f} MB")
# Get the compression libraries supported
# supported_clibs = [clib for clib in ("zlib", "lzo", "bzip2", "blosc")
# supported_clibs = [clib for clib in ("zlib", "lzo", "blosc")
supported_clibs = [
clib for clib in ("blosc", ) if tb.which_lib_version(clib)
]
# Initialization code
# for what in ["numpy", "numpy.memmap", "numexpr"]:
for what in ["numpy", "numexpr"]:
# break
print("Populating x using %s with %d points..." % (what, N))
t0 = clock()
if what == "numpy":
populate_x_numpy()
compute = compute_numpy
elif what == "numexpr":
populate_x_numpy()
compute = compute_numexpr
elif what == "numpy.memmap":
import sys
import os
import tables
import tables._comp_bzip2
# We don't build this one on Windows.
if not sys.platform == "win32":
import tables._comp_lzo
import tables.hdf5extension
import tables.indexesextension
import tables.linkextension
import tables.lrucacheextension
import tables.tableextension
import tables.utilsextension
tables.print_versions()
if sys.platform.startswith('linux'):
lzo_ver = tables.which_lib_version("lzo")[1]
assert lzo_ver == '2.06', lzo_ver
if __name__ == "__main__":
# Skip tests on python 3 for windows.
if not (os.name == "nt" and sys.version_info[0] == 3):
from multiprocessing import freeze_support
freeze_support()
tables.test()
f.close()
print_filesize(h5fname, clib, clevel)
if __name__ == '__main__':
tb.print_versions()
print("Total size for datasets:",
round(2 * N * dtype.itemsize / MB, 1), "MB")
# Get the compression libraries supported
# supported_clibs = [clib for clib in ("zlib", "lzo", "bzip2", "blosc")
# supported_clibs = [clib for clib in ("zlib", "lzo", "blosc")
supported_clibs = [clib for clib in ("blosc",)
if tb.which_lib_version(clib)]
# Initialization code
# for what in ["numpy", "numpy.memmap", "numexpr"]:
for what in ["numpy", "numexpr"]:
# break
print("Populating x using %s with %d points..." % (what, N))
t0 = time()
if what == "numpy":
populate_x_numpy()
compute = compute_numpy
elif what == "numexpr":
populate_x_numpy()
compute = compute_numexpr
elif what == "numpy.memmap":
populate_x_memmap()
ex.eval() # evaluate!
f.close()
print_filesize(h5fname, clib, clevel)
if __name__ == "__main__":
tb.print_versions()
print("Total size for datasets:", round(2 * N * dtype.itemsize / MB, 1), "MB")
# Get the compression libraries supported
# supported_clibs = [clib for clib in ("zlib", "lzo", "bzip2", "blosc")
# supported_clibs = [clib for clib in ("zlib", "lzo", "blosc")
supported_clibs = [clib for clib in ("blosc",) if tb.which_lib_version(clib)]
# Initialization code
# for what in ["numpy", "numpy.memmap", "numexpr"]:
for what in ["numpy", "numexpr"]:
# break
print("Populating x using %s with %d points..." % (what, N))
t0 = time()
if what == "numpy":
populate_x_numpy()
compute = compute_numpy
elif what == "numexpr":
populate_x_numpy()
compute = compute_numexpr
elif what == "numpy.memmap":
populate_x_memmap()
f.create_carray(f.root,
'carray',
filters=filters,
obj=arr,
chunkshape=chunkshape)
return None
def read_hdf5(fname):
with tables.open_file(fname, "r") as f:
return f.root.carray[:]
print("-=" * 38)
print("PyTables version: %s" % tables.__version__)
print("HDF5 version: %s" % tables.which_lib_version("hdf5")[1])
tinfo = tables.which_lib_version("blosc")
blosc_date = tinfo[2].split()[1]
print("Blosc version: %s (%s)" % (tinfo[1], blosc_date))
blosc_cinfo = tables.blosc_get_complib_info()
blosc_cinfo = ["%s (%s)" % (k, v[1]) for k, v in sorted(blosc_cinfo.items())]
print("-=" * 38)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"-r",
"--read-only",
action="store_true",
help="Read only bench.",
)
if "verbose" in argv:
verbose = True
argv.remove("verbose")
if "silent" in argv: # take care of old flag, just in case
verbose = False
argv.remove("silent")
if "--heavy" in argv:
heavy = True
argv.remove("--heavy")
return argv
zlib_avail = tables.which_lib_version("zlib") is not None
lzo_avail = tables.which_lib_version("lzo") is not None
bzip2_avail = tables.which_lib_version("bzip2") is not None
blosc_avail = tables.which_lib_version("blosc") is not None
def print_heavy(heavy):
if heavy:
print("""Performing the complete test suite!""")
else:
print(
"""\
Performing only a light (yet comprehensive) subset of the test suite.
If you want a more complete test, try passing the --heavy flag to this script
(or set the 'heavy' parameter in case you are using tables.test() call).
The whole suite will take more than 4 hours to complete on a relatively
