def setUpManager(self, specs):
spec_catalog = SpecCatalog()
schema_file = 'test.yaml'
for s in specs:
spec_catalog.register_spec(s, schema_file)
namespace = SpecNamespace(doc='a test namespace',
name=CORE_NAMESPACE,
schema=[{
'source': schema_file
}],
version='0.1.0',
catalog=spec_catalog)
namespace_catalog = NamespaceCatalog()
namespace_catalog.add_namespace(CORE_NAMESPACE, namespace)
type_map = TypeMap(namespace_catalog)
type_map.register_container_type(CORE_NAMESPACE, 'SimpleFoo',
SimpleFoo)
type_map.register_container_type(CORE_NAMESPACE, 'NotSimpleFoo',
NotSimpleFoo)
type_map.register_container_type(CORE_NAMESPACE, 'SimpleQux',
SimpleQux)
type_map.register_container_type(CORE_NAMESPACE, 'NotSimpleQux',
NotSimpleQux)
type_map.register_container_type(CORE_NAMESPACE, 'SimpleBucket',
SimpleBucket)
type_map.register_map(SimpleBucket, self.setUpBucketMapper())
self.manager = BuildManager(type_map)
def create_test_type_map(specs, container_classes, mappers=None):
"""
Create a TypeMap with the specs registered under a test namespace, and classes and mappers registered to type names.
:param specs: list of specs
:param container_classes: dict of type name to container class
:param mappers: (optional) dict of type name to mapper class
:return: the constructed TypeMap
"""
spec_catalog = SpecCatalog()
schema_file = 'test.yaml'
for s in specs:
spec_catalog.register_spec(s, schema_file)
namespace = SpecNamespace(doc='a test namespace',
name=CORE_NAMESPACE,
schema=[{
'source': schema_file
}],
version='0.1.0',
catalog=spec_catalog)
namespace_catalog = NamespaceCatalog()
namespace_catalog.add_namespace(CORE_NAMESPACE, namespace)
type_map = TypeMap(namespace_catalog)
for type_name, container_cls in container_classes.items():
type_map.register_container_type(CORE_NAMESPACE, type_name,
container_cls)
if mappers:
for type_name, mapper_cls in mappers.items():
container_cls = container_classes[type_name]
type_map.register_map(container_cls, mapper_cls)
return type_map
class TestObjectMapper(with_metaclass(ABCMeta, unittest.TestCase)):
def setUp(self):
self.setUpBarSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_map(Bar, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.bar_spec)
def setUpBarSpec(self):
raise unittest.SkipTest('setUpBarSpec not implemented')
def test_default_mapping(self):
attr_map = self.mapper.get_attr_names(self.bar_spec)
keys = set(attr_map.keys())
for key in keys:
with self.subTest(key=key):
self.assertIs(attr_map[key], self.mapper.get_attr_spec(key))
self.assertIs(attr_map[key], self.mapper.get_carg_spec(key))
class TestBase(unittest.TestCase):
def setUp(self):
self.foo_spec = GroupSpec(
'A test group specification with a data type',
data_type_def='Foo',
datasets=[
DatasetSpec('an example dataset',
'int',
name='my_data',
attributes=[
AttributeSpec('attr2',
'an example integer attribute',
'int')
])
],
attributes=[
AttributeSpec('attr1', 'an example string attribute', 'text')
])
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.foo_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
self.type_map.register_map(Foo, ObjectMapper)
self.manager = BuildManager(self.type_map)
class TestDataIOEdgeCases(TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(
doc='an Baz type',
dtype=None,
name='MyBaz',
data_type_def='Baz',
shape=[None],
attributes=[
AttributeSpec('baz_attr', 'an example string attribute',
'text')
])
def test_build_dataio(self):
"""Test building of a dataset with data_type and no dtype with value DataIO."""
container = Baz('my_baz', H5DataIO(['a', 'b', 'c', 'd'], chunks=True),
'value1')
builder = self.type_map.build(container)
self.assertIsInstance(builder.get('data'), H5DataIO)
def test_build_datachunkiterator(self):
"""Test building of a dataset with data_type and no dtype with value DataChunkIterator."""
container = Baz('my_baz', DataChunkIterator(['a', 'b', 'c', 'd']),
'value1')
builder = self.type_map.build(container)
self.assertIsInstance(builder.get('data'), DataChunkIterator)
def test_build_dataio_datachunkiterator(self): # hdmf#512
"""Test building of a dataset with no dtype and no data_type with value DataIO wrapping a DCI."""
container = Baz(
'my_baz',
H5DataIO(DataChunkIterator(['a', 'b', 'c', 'd']), chunks=True),
'value1')
builder = self.type_map.build(container)
self.assertIsInstance(builder.get('data'), H5DataIO)
self.assertIsInstance(builder.get('data').data, DataChunkIterator)
class TestDataMapScalar(TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'BazScalar',
BazScalar)
self.type_map.register_map(BazScalar, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(doc='a BazScalar type',
dtype='int',
name='MyBaz',
data_type_def='BazScalar')
def test_construct_scalar_dataset(self):
"""Test constructing a Data object with an h5py.Dataset with shape (1, ) for scalar spec."""
with h5py.File('test.h5', 'w') as file:
test_ds = file.create_dataset('test_ds', data=[1])
expected = BazScalar(
name='MyBaz',
data=1,
)
builder = DatasetBuilder(
name='MyBaz',
data=test_ds,
attributes={
'data_type': 'BazScalar',
'namespace': CORE_NAMESPACE,
'object_id': expected.object_id
},
)
container = self.mapper.construct(builder, self.manager)
self.assertTrue(np.issubdtype(type(
container.data), np.integer)) # as opposed to h5py.Dataset
self.assertContainerEqual(container, expected)
os.remove('test.h5')
class TestTypeMap(TestCase):
def setUp(self):
self.bar_spec = GroupSpec(
'A test group specification with a data type', data_type_def='Bar')
self.foo_spec = GroupSpec(
'A test group specification with data type Foo',
data_type_def='Foo')
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.spec_catalog.register_spec(self.foo_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
def test_get_map_unique_mappers(self):
bar_inst = Bar('my_bar', list(range(10)), 'value1', 10)
foo_inst = Foo(name='my_foo')
bar_mapper = self.type_map.get_map(bar_inst)
foo_mapper = self.type_map.get_map(foo_inst)
self.assertIsNot(bar_mapper, foo_mapper)
def test_get_map(self):
container_inst = Bar('my_bar', list(range(10)), 'value1', 10)
mapper = self.type_map.get_map(container_inst)
self.assertIsInstance(mapper, ObjectMapper)
self.assertIs(mapper.spec, self.bar_spec)
mapper2 = self.type_map.get_map(container_inst)
self.assertIs(mapper, mapper2)
def test_get_map_register(self):
class MyMap(ObjectMapper):
pass
self.type_map.register_map(Bar, MyMap)
container_inst = Bar('my_bar', list(range(10)), 'value1', 10)
mapper = self.type_map.get_map(container_inst)
self.assertIs(mapper.spec, self.bar_spec)
self.assertIsInstance(mapper, MyMap)
class BazSpecMixin:
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
raise NotImplementedError('Test must implement this method.')
def setUp(self):
self.set_up_specs()
spec_catalog = SpecCatalog()
spec_catalog.register_spec(self.bar_data_spec, 'test.yaml')
spec_catalog.register_spec(self.bar_data_holder_spec, 'test.yaml')
namespace = SpecNamespace(doc='a test namespace',
name=CORE_NAMESPACE,
schema=[{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=spec_catalog)
namespace_catalog = NamespaceCatalog()
namespace_catalog.add_namespace(CORE_NAMESPACE, namespace)
type_map = TypeMap(namespace_catalog)
type_map.register_container_type(CORE_NAMESPACE, 'BarData', BarData)
type_map.register_container_type(CORE_NAMESPACE, 'BarDataHolder',
BarDataHolder)
type_map.register_map(BarData, ExtBarDataMapper)
type_map.register_map(BarDataHolder, ObjectMapper)
self.manager = BuildManager(type_map)
class TestDataMap(unittest.TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(
'an Baz type',
'int',
name='MyBaz',
data_type_def='Baz',
attributes=[
AttributeSpec('baz_attr', 'an example string attribute',
'text')
])
def test_build(self):
''' Test default mapping functionality when no attributes are nested '''
container = Baz('my_baz', list(range(10)),
'abcdefghijklmnopqrstuvwxyz')
builder = self.mapper.build(container, self.manager)
expected = DatasetBuilder(
'my_baz',
list(range(10)),
attributes={'baz_attr': 'abcdefghijklmnopqrstuvwxyz'})
self.assertDictEqual(builder, expected)
class BuildDatasetOfReferencesMixin:
def setUp(self):
self.setUpBazSpec()
self.foo_spec = GroupSpec(
doc='A test group specification with a data type',
data_type_def='Foo',
datasets=[
DatasetSpec(name='my_data',
doc='an example dataset',
dtype='int')
],
attributes=[
AttributeSpec(name='attr1',
doc='an example string attribute',
dtype='text'),
AttributeSpec(name='attr2',
doc='an example int attribute',
dtype='int'),
AttributeSpec(name='attr3',
doc='an example float attribute',
dtype='float')
])
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.spec_catalog.register_spec(self.foo_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
self.type_map.register_map(Baz, ObjectMapper)
self.type_map.register_map(Foo, ObjectMapper)
self.manager = BuildManager(self.type_map)
def _get_manager():
foo_spec = GroupSpec('A test group specification with a data type',
data_type_def='Foo',
datasets=[DatasetSpec('an example dataset',
'int',
name='my_data',
attributes=[AttributeSpec('attr2',
'an example integer attribute',
'int')])],
attributes=[AttributeSpec('attr1', 'an example string attribute', 'text')])
tmp_spec = GroupSpec('A subgroup for Foos',
name='foo_holder',
groups=[GroupSpec('the Foos in this bucket', data_type_inc='Foo', quantity=ZERO_OR_MANY)])
bucket_spec = GroupSpec('A test group specification for a data type containing data type',
data_type_def='FooBucket',
groups=[tmp_spec])
class BucketMapper(ObjectMapper):
def __init__(self, spec):
super(BucketMapper, self).__init__(spec)
foo_spec = spec.get_group('foo_holder').get_data_type('Foo')
self.map_spec('foos', foo_spec)
file_spec = GroupSpec("A file of Foos contained in FooBuckets",
name='root',
data_type_def='FooFile',
groups=[GroupSpec('Holds the FooBuckets',
name='buckets',
groups=[GroupSpec("One ore more FooBuckets",
data_type_inc='FooBucket',
quantity=ONE_OR_MANY)])])
class FileMapper(ObjectMapper):
def __init__(self, spec):
super(FileMapper, self).__init__(spec)
bucket_spec = spec.get_group('buckets').get_data_type('FooBucket')
self.map_spec('buckets', bucket_spec)
spec_catalog = SpecCatalog()
spec_catalog.register_spec(foo_spec, 'test.yaml')
spec_catalog.register_spec(bucket_spec, 'test.yaml')
spec_catalog.register_spec(file_spec, 'test.yaml')
namespace = SpecNamespace(
'a test namespace',
CORE_NAMESPACE,
[{'source': 'test.yaml'}],
catalog=spec_catalog)
namespace_catalog = NamespaceCatalog()
namespace_catalog.add_namespace(CORE_NAMESPACE, namespace)
type_map = TypeMap(namespace_catalog)
type_map.register_container_type(CORE_NAMESPACE, 'Foo', Foo)
type_map.register_container_type(CORE_NAMESPACE, 'FooBucket', FooBucket)
type_map.register_container_type(CORE_NAMESPACE, 'FooFile', FooFile)
type_map.register_map(FooBucket, BucketMapper)
type_map.register_map(FooFile, FileMapper)
manager = BuildManager(type_map)
return manager
class TestDataMap(BazSpecMixin, TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(
doc='an Baz type',
dtype='int',
name='MyBaz',
data_type_def='Baz',
shape=[None],
attributes=[
AttributeSpec('baz_attr', 'an example string attribute',
'text')
])
def test_build(self):
''' Test default mapping functionality when no attributes are nested '''
container = Baz('MyBaz', list(range(10)), 'abcdefghijklmnopqrstuvwxyz')
builder = self.mapper.build(container, self.manager)
expected = DatasetBuilder(
'MyBaz',
list(range(10)),
attributes={'baz_attr': 'abcdefghijklmnopqrstuvwxyz'})
self.assertBuilderEqual(builder, expected)
def test_build_empty_data(self):
"""Test building of a Data object with empty data."""
baz_inc_spec = DatasetSpec(doc='doc',
data_type_inc='Baz',
quantity=ZERO_OR_MANY)
baz_holder_spec = GroupSpec(doc='doc',
data_type_def='BazHolder',
datasets=[baz_inc_spec])
self.spec_catalog.register_spec(baz_holder_spec, 'test.yaml')
self.type_map.register_container_type(CORE_NAMESPACE, 'BazHolder',
BazHolder)
self.holder_mapper = ObjectMapper(baz_holder_spec)
baz = Baz('MyBaz', [], 'abcdefghijklmnopqrstuvwxyz')
holder = BazHolder('holder', [baz])
builder = self.holder_mapper.build(holder, self.manager)
expected = GroupBuilder(
name='holder',
datasets=[
DatasetBuilder(name='MyBaz',
data=[],
attributes={
'baz_attr': 'abcdefghijklmnopqrstuvwxyz',
'data_type': 'Baz',
'namespace': 'test_core',
'object_id': baz.object_id
})
])
self.assertBuilderEqual(builder, expected)
def test_append(self):
with h5py.File('test.h5', 'w') as file:
test_ds = file.create_dataset('test_ds',
data=[1, 2, 3],
chunks=True,
maxshape=(None, ))
container = Baz('MyBaz', test_ds, 'abcdefghijklmnopqrstuvwxyz')
container.append(4)
np.testing.assert_array_equal(container[:], [1, 2, 3, 4])
os.remove('test.h5')
def test_extend(self):
with h5py.File('test.h5', 'w') as file:
test_ds = file.create_dataset('test_ds',
data=[1, 2, 3],
chunks=True,
maxshape=(None, ))
container = Baz('MyBaz', test_ds, 'abcdefghijklmnopqrstuvwxyz')
container.extend([4, 5])
np.testing.assert_array_equal(container[:], [1, 2, 3, 4, 5])
os.remove('test.h5')
class TestDataMapScalarCompound(TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE,
'BazScalarCompound',
BazScalarCompound)
self.type_map.register_map(BazScalarCompound, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(
doc='a BazScalarCompound type',
dtype=[
DtypeSpec(name='id',
dtype='uint64',
doc='The unique identifier in this table.'),
DtypeSpec(name='attr1', dtype='text', doc='A text attribute.'),
],
name='MyBaz',
data_type_def='BazScalarCompound',
)
def test_construct_scalar_compound_dataset(self):
"""Test construct on a compound h5py.Dataset with shape (1, ) for scalar spec does not resolve the data."""
with h5py.File('test.h5', 'w') as file:
comp_type = np.dtype([('id', np.uint64),
('attr1', h5py.special_dtype(vlen=str))])
test_ds = file.create_dataset(name='test_ds',
data=np.array((1, 'text'),
dtype=comp_type),
shape=(1, ),
dtype=comp_type)
expected = BazScalarCompound(
name='MyBaz',
data=(1, 'text'),
)
builder = DatasetBuilder(
name='MyBaz',
data=test_ds,
attributes={
'data_type': 'BazScalarCompound',
'namespace': CORE_NAMESPACE,
'object_id': expected.object_id
},
)
container = self.mapper.construct(builder, self.manager)
self.assertEqual(type(container.data), h5py.Dataset)
self.assertContainerEqual(container, expected)
os.remove('test.h5')
class TestDynamicContainer(unittest.TestCase):
def setUp(self):
self.bar_spec = GroupSpec(
'A test group specification with a data type',
data_type_def='Bar',
datasets=[
DatasetSpec('an example dataset',
'int',
name='data',
attributes=[
AttributeSpec('attr2',
'an example integer attribute',
'int')
])
],
attributes=[
AttributeSpec('attr1', 'an example string attribute', 'text')
])
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.bar_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Bar', Bar)
self.type_map.register_map(Bar, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.bar_spec)
def test_dynamic_container_creation(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
expected_args = {'name', 'data', 'attr1', 'attr2', 'attr3', 'attr4'}
received_args = set()
for x in get_docval(cls.__init__):
received_args.add(x['name'])
with self.subTest(name=x['name']):
self.assertNotIn('default', x)
self.assertSetEqual(expected_args, received_args)
self.assertEqual(cls.__name__, 'Baz')
self.assertTrue(issubclass(cls, Bar))
def test_dynamic_container_creation_defaults(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
expected_args = {'name', 'data', 'attr1', 'attr2', 'attr3', 'attr4'}
received_args = set(map(lambda x: x['name'], get_docval(cls.__init__)))
self.assertSetEqual(expected_args, received_args)
self.assertEqual(cls.__name__, 'Baz')
self.assertTrue(issubclass(cls, Bar))
def test_dynamic_container_constructor(self):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
# TODO: test that constructor works!
inst = cls('My Baz', [1, 2, 3, 4],
'string attribute',
1000,
attr3=98.6,
attr4=1.0)
self.assertEqual(inst.name, 'My Baz')
self.assertEqual(inst.data, [1, 2, 3, 4])
self.assertEqual(inst.attr1, 'string attribute')
self.assertEqual(inst.attr2, 1000)
self.assertEqual(inst.attr3, 98.6)
self.assertEqual(inst.attr4, 1.0)
def test_dynamic_container_constructor_name(self):
# name is specified in spec and cannot be changed
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
name='A fixed name',
attributes=[
AttributeSpec('attr3', 'an example float attribute', 'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
with self.assertRaises(TypeError):
inst = cls('My Baz', [1, 2, 3, 4],
'string attribute',
1000,
attr3=98.6,
attr4=1.0)
inst = cls([1, 2, 3, 4],
'string attribute',
1000,
attr3=98.6,
attr4=1.0)
self.assertEqual(inst.name, 'A fixed name')
self.assertEqual(inst.data, [1, 2, 3, 4])
self.assertEqual(inst.attr1, 'string attribute')
self.assertEqual(inst.attr2, 1000)
self.assertEqual(inst.attr3, 98.6)
self.assertEqual(inst.attr4, 1.0)
def test_dynamic_container_constructor_name_default_name(self):
# if both name and default_name are specified, name should be used
with self.assertWarns(Warning):
baz_spec = GroupSpec(
'A test extension with no Container class',
data_type_def='Baz',
data_type_inc=self.bar_spec,
name='A fixed name',
default_name='A default name',
attributes=[
AttributeSpec('attr3', 'an example float attribute',
'float'),
AttributeSpec('attr4', 'another example float attribute',
'float')
])
self.spec_catalog.register_spec(baz_spec, 'extension.yaml')
cls = self.type_map.get_container_cls(CORE_NAMESPACE, 'Baz')
inst = cls([1, 2, 3, 4],
'string attribute',
1000,
attr3=98.6,
attr4=1.0)
self.assertEqual(inst.name, 'A fixed name')
class TestDataMap(TestCase):
def setUp(self):
self.setUpBazSpec()
self.spec_catalog = SpecCatalog()
self.spec_catalog.register_spec(self.baz_spec, 'test.yaml')
self.namespace = SpecNamespace('a test namespace',
CORE_NAMESPACE, [{
'source': 'test.yaml'
}],
version='0.1.0',
catalog=self.spec_catalog)
self.namespace_catalog = NamespaceCatalog()
self.namespace_catalog.add_namespace(CORE_NAMESPACE, self.namespace)
self.type_map = TypeMap(self.namespace_catalog)
self.type_map.register_container_type(CORE_NAMESPACE, 'Baz', Baz)
self.type_map.register_map(Baz, ObjectMapper)
self.manager = BuildManager(self.type_map)
self.mapper = ObjectMapper(self.baz_spec)
def setUpBazSpec(self):
self.baz_spec = DatasetSpec(
'an Baz type',
'int',
name='MyBaz',
data_type_def='Baz',
shape=[None],
attributes=[
AttributeSpec('baz_attr', 'an example string attribute',
'text')
])
def test_build(self):
''' Test default mapping functionality when no attributes are nested '''
container = Baz('my_baz', list(range(10)),
'abcdefghijklmnopqrstuvwxyz')
builder = self.mapper.build(container, self.manager)
expected = DatasetBuilder(
'my_baz',
list(range(10)),
attributes={'baz_attr': 'abcdefghijklmnopqrstuvwxyz'})
self.assertDictEqual(builder, expected)
def test_append(self):
with h5py.File('test.h5', 'w') as file:
test_ds = file.create_dataset('test_ds',
data=[1, 2, 3],
chunks=True,
maxshape=(None, ))
container = Baz('my_baz', test_ds, 'abcdefghijklmnopqrstuvwxyz')
container.append(4)
np.testing.assert_array_equal(container[:], [1, 2, 3, 4])
os.remove('test.h5')
def test_extend(self):
with h5py.File('test.h5', 'w') as file:
test_ds = file.create_dataset('test_ds',
data=[1, 2, 3],
chunks=True,
maxshape=(None, ))
container = Baz('my_baz', test_ds, 'abcdefghijklmnopqrstuvwxyz')
container.extend([4, 5])
np.testing.assert_array_equal(container[:], [1, 2, 3, 4, 5])
os.remove('test.h5')
