def test_save_item(self, tmpdir):
schema_node = schema.Bool()
storage_path = str(tmpdir.join('test_save_item.npz'))
npz_file = npz.Storage(storage_path=storage_path,
schema_node=schema_node)
npz_file.data.value = True
npz_file.save()
with np.load(storage_path) as file_:
assert '_schema' in file_
assert file_['_schema'][()] == json.dumps(schema_node.to_dict(),
sort_keys=True)
assert 'data' in file_
assert file_['data'].dtype == 'bool'
assert file_['data'][0]
def test_load_compilation(self, tmpdir):
schema_node = schema.Compilation({
'spam': schema.Bool(),
'eggs': schema.Bool()
})
schema_data = json.dumps(schema_node.to_dict(), sort_keys=True)
storage_path = str(tmpdir.join('test_load_compilation.mat'))
test_data = {
'data': {
'spam': np.array([True]),
'eggs': np.array([False])
},
'schema': schema_data
}
sio.savemat(storage_path, test_data)
mat_file = mat.Storage(storage_path=storage_path)
assert hasattr(mat_file, 'data')
assert hasattr(mat_file.data, 'spam')
assert hasattr(mat_file.data, 'eggs')
assert isinstance(mat_file.data.spam, mat.Bool)
assert isinstance(mat_file.data.eggs, mat.Bool)
assert mat_file.data.spam.value is True
assert mat_file.data.eggs.value is False
def test_save_item(self, tmpdir):
schema_node = schema.Bool()
file_name = str(tmpdir.join('test_save_item.h5'))
hdf5_file = hdf5.Storage(storage_path=file_name,
schema_node=schema_node)
hdf5_file.data.value = True
hdf5_file.save()
del hdf5_file
file_ = h5py.File(file_name, 'r')
assert 'dsch_schema' in file_.attrs
assert file_.attrs['dsch_schema'] == json.dumps(schema_node.to_dict(),
sort_keys=True)
assert 'dsch_data' in file_
assert file_['dsch_data'].dtype == 'bool'
assert file_['dsch_data'][()]
def test_save_list(self, tmpdir):
schema_node = schema.List(schema.Bool())
storage_path = str(tmpdir.join('test_save_list.mat'))
mat_file = mat.Storage(storage_path=storage_path,
schema_node=schema_node)
mat_file.data.replace([True, False])
mat_file.save()
file_ = sio.loadmat(storage_path, squeeze_me=True)
assert 'schema' in file_
assert file_['schema'] == json.dumps(schema_node.to_dict(),
sort_keys=True)
assert 'data' in file_
assert len(file_['data']) == 2
assert file_['data'][0]
assert not file_['data'][1]
def test_load_list(self, tmpdir):
schema_node = schema.List(schema.Bool())
schema_data = json.dumps(schema_node.to_dict(), sort_keys=True)
file_name = str(tmpdir.join('test_load_list.hdf5'))
raw_file = h5py.File(file_name, 'x')
raw_file.attrs['dsch_schema'] = schema_data
data = raw_file.create_group('dsch_data')
data.create_dataset('item_0', data=True)
data.create_dataset('item_1', data=False)
raw_file.flush()
del raw_file
hdf5_file = hdf5.Storage(storage_path=file_name)
assert hasattr(hdf5_file, 'data')
assert isinstance(hdf5_file.data, hdf5.List)
assert hdf5_file.data[0].value is True
assert hdf5_file.data[1].value is False
def test_save_list(self, tmpdir):
schema_node = schema.List(schema.Bool())
storage_path = str(tmpdir.join('test_save_list.npz'))
npz_file = npz.Storage(storage_path=storage_path,
schema_node=schema_node)
npz_file.data.replace([True, False])
npz_file.save()
with np.load(storage_path) as file_:
assert '_schema' in file_
assert file_['_schema'][()] == json.dumps(schema_node.to_dict(),
sort_keys=True)
assert 'data.item_0' in file_
assert file_['data.item_0'].dtype == 'bool'
assert file_['data.item_0'][0]
assert 'data.item_1' in file_
assert file_['data.item_1'].dtype == 'bool'
assert not file_['data.item_1'][0]
def test_save_list(self, tmpdir):
schema_node = schema.List(schema.Bool())
file_name = str(tmpdir.join('test_save_list.h5'))
hdf5_file = hdf5.Storage(storage_path=file_name,
schema_node=schema_node)
hdf5_file.data.replace([True, False])
hdf5_file.save()
file_ = h5py.File(file_name, 'r')
assert 'dsch_schema' in file_.attrs
assert file_.attrs['dsch_schema'] == json.dumps(schema_node.to_dict(),
sort_keys=True)
assert 'dsch_data' in file_
assert 'item_0' in file_['dsch_data']
assert file_['dsch_data']['item_0'].dtype == 'bool'
assert file_['dsch_data']['item_0'][()]
assert 'item_1' in file_['dsch_data']
assert file_['dsch_data']['item_1'].dtype == 'bool'
assert not file_['dsch_data']['item_1'][()]
def storage_path(self, request, tmpdir):
"""Prepare storage path for all valid variants.
Variants are tuples ``(backend, existing)``, where ``existing``
indicates whether a storage should be created before the test.
"""
backend, existing = request.param
if backend in ('hdf5', 'npz', 'mat'):
# File backends
storage_path = str(tmpdir.join('test_pseudo.' + backend))
elif backend == '::inmem::':
storage_path = '::inmem::'
if existing:
storage = frontend.create(storage_path, schema.Bool())
storage.data.value = True
if hasattr(storage, 'save') and callable(storage.save):
storage.save()
del storage
return storage_path
def test_init(self, storage_path):
pseudo = frontend.PseudoStorage(storage_path, schema.Bool(), False)
assert pseudo.data is not None
assert pseudo.storage is not None
assert pseudo.storage.storage_path == storage_path
assert pseudo.schema_node is not None
def test_schema_alternative(self, storage):
pseudo = frontend.PseudoStorage(storage.data.spam, schema.Bytes(),
True, (schema.Bool(), ))
pseudo.open()
assert pseudo.schema_node == storage.data.spam.schema_node
def storage(self, foreign_backend):
schema_node = schema.Compilation({
'spam': schema.Bool(),
'eggs': schema.Bytes(),
})
return frontend.create(foreign_backend.storage_path, schema_node)
def test_init(self, storage):
pseudo = frontend.PseudoStorage(storage.data.spam, schema.Bool(),
False)
assert pseudo.data is not None
assert pseudo.storage is None
assert pseudo.schema_node is not None
def test_init(self):
node = schema.List(schema.Bool(), max_length=3, min_length=1)
assert isinstance(node.subnode, schema.Bool)
assert node.max_length == 3
assert node.min_length == 1
def test_init_defaults(self):
node = schema.Compilation({
'spam': schema.Bool(),
'eggs': schema.Bool()
})
assert node.optionals == []
def test_create(backend):
schema_node = schema.Bool()
storage = frontend.create(backend.storage_path, schema_node)
assert isinstance(storage, backend.module.Storage)
assert storage.schema_node == schema_node
def test_init_deferred(self, storage_path):
pseudo = frontend.PseudoStorage(storage_path, schema.Bool(), True)
assert pseudo.data is None
assert pseudo.storage is None
assert pseudo.schema_node is None
def test_init_defaults(self):
node = schema.List(schema.Bool())
assert node.max_length is None
assert node.min_length is None
def test_validate(self):
subnode = schema.Bool()
node = schema.List(subnode, max_length=3, min_length=1)
node.validate([23, 42])
class TestBool(ItemNodeTestBase):
class_name = 'Bool'
schema_node = schema.Bool()
valid_data = True
def test_schema_alternative(self, storage_path_existing):
pseudo = frontend.PseudoStorage(storage_path_existing, schema.Bytes(),
True, (schema.Bool(), ))
pseudo.open()
assert pseudo.schema_node == pseudo.storage.data.schema_node
import datetime
import json
import numpy as np
import pytest
from dsch import data, schema
from dsch.backends import npz
@pytest.mark.parametrize('schema_node,valid_data', (
(schema.Array(dtype='int32'), np.array([23, 42], dtype='int32')),
(schema.Bool(), True),
(schema.Date(), datetime.date.today()),
(schema.DateTime(), datetime.datetime.now()),
(schema.Scalar(dtype='int32'), np.int32(42)),
(schema.String(), 'spam'),
(schema.Time(), datetime.datetime.now().time()),
))
def test_save_item_node(schema_node, valid_data):
data_node = data.data_node_from_schema(schema_node,
module_name='dsch.backends.npz',
parent=None)
data_node.value = valid_data
assert np.all(data_node.save() == data_node._storage)
class TestCompilation:
def test_init_from_storage(self):
schema_node = schema.Compilation({'spam': schema.Bool(),
'eggs': schema.Bool()})
def test_create_inmem():
schema_node = schema.Bool()
storage = frontend.create('::inmem::', schema_node)
assert isinstance(storage, inmem.Storage)
assert storage.schema_node == schema_node
def test_validate(self, test_data):
node = schema.Bool()
node.validate(test_data)
import datetime
import json
import numpy as np
import pytest
from dsch import schema
from dsch.exceptions import ValidationError
@pytest.mark.parametrize(
'node', (schema.Array(dtype='int32'), schema.Bool(), schema.Bytes(),
schema.Compilation({'spam': schema.Bool()}), schema.Date(),
schema.DateTime(), schema.List(schema.Bool()),
schema.Scalar(dtype='int32'), schema.String(), schema.Time()))
class TestGenericSchemaNode:
def test_to_json(self, node):
json_str = node.to_json()
node_dict = json.loads(json_str)
assert isinstance(node_dict, dict)
def test_hash(self, node):
hash = node.hash()
assert len(hash) == 64
@pytest.mark.parametrize('node1, node2', (
(schema.Array(dtype='float'), schema.Array(dtype='float')),
(schema.Bool(), schema.Bool()),
(schema.Bytes(), schema.Bytes()),
(schema.Compilation({'spam': schema.Bool()
def test_validate_fail(self, test_data):
node = schema.Bool()
with pytest.raises(ValidationError):
node.validate(test_data)
