def _tablefunc(table_name, description, columns):
t = DynamicTable(table_name, description)
for c in columns:
if isinstance(c, tuple):
t.add_column(c[0], c[1])
elif isinstance(c, str):
t.add_column(c)
else:
raise ValueError("Elements of 'columns' must be str or tuple")
return t
def test_add_ref_nested(self):
table = DynamicTable(name='table', description='table')
table.add_column(name='col1', description="column")
table.add_row(id=0, col1='data')
er = ExternalResources(name='example')
er.add_ref(container=table,
attribute='description',
key='key1',
resource_name='resource0',
resource_uri='resource0_uri',
entity_id='entity_0',
entity_uri='entity_0_uri')
self.assertEqual(er.keys.data, [('key1', )])
self.assertEqual(er.resources.data, [('resource0', 'resource0_uri')])
self.assertEqual(er.entities.data,
[(0, 0, 'entity_0', 'entity_0_uri')])
self.assertEqual(er.objects.data,
[(table.object_id, 'DynamicTable/description', '')])
def test_add_ref_column_as_attribute(self):
# Test to make sure the attribute object is being used for the id
# for the external reference.
table = DynamicTable(name='table', description='table')
table.add_column(name='col1', description="column")
table.add_row(id=0, col1='data')
er = ExternalResources(name='example')
er.add_ref(container=table,
attribute='col1',
key='key1',
resource_name='resource0',
resource_uri='resource0_uri',
entity_id='entity_0',
entity_uri='entity_0_uri')
self.assertEqual(er.keys.data, [('key1', )])
self.assertEqual(er.resources.data, [('resource0', 'resource0_uri')])
self.assertEqual(er.entities.data,
[(0, 0, 'entity_0', 'entity_0_uri')])
self.assertEqual(er.objects.data, [(table['col1'].object_id, '', '')])
table.add_row(
col1=4,
col2='d',
)
###############################################################################
# Adding columns
# --------------
# You can add columns to a :py:class:`~hdmf.common.table.DynamicTable` using
# :py:meth:`DynamicTable.add_column <hdmf.common.table.DynamicTable.add_column>`.
# If the table already has rows, then the ``data`` argument must be supplied
# as a list of values, one for each row already in the table.
table.add_column(
name='col3',
description='column #3',
data=[True, True, False, True], # specify data for the 4 rows in the table
)
###############################################################################
# Enumerated (categorical) data
# -----------------------------
# :py:class:`~hdmf.common.table.EnumData` is a special type of column for storing
# an enumerated data type. This way each unique value is stored once, and the data
# references those values by index. Using this method is more efficient than storing
# a single value many times, and has the advantage of communicating to downstream
# tools that the data is categorical in nature.
from hdmf.common.table import EnumData
# this column has a length of 5, not 3. the first row has value "aa"
from hdmf.common import DynamicTable
users_table = DynamicTable(
name='users',
description=
'a table containing data/metadata about users, one user per row',
)
###############################################################################
# Adding columns
# --------------
# You can add columns to a :py:class:`~hdmf.common.table.DynamicTable` using
# :py:meth:`DynamicTable.add_column <hdmf.common.table.DynamicTable.add_column>`.
users_table.add_column(
name='first_name',
description='the first name of the user',
)
users_table.add_column(
name='last_name',
description='the last name of the user',
)
###############################################################################
# Adding ragged array columns
# ---------------------------
# You may want to add columns to your table that have a different number of entries per row.
# This is called a "ragged array column". To do this, pass ``index=True`` to
# :py:meth:`DynamicTable.add_column <hdmf.common.table.DynamicTable.add_column>`.
users_table.add_column(
#
# Row IDs are not required to be unique. However, if ``enforce_unique_id=True``
# is passed, then adding a row with an ID that already exists in the table will
# raise an error.
###############################################################################
# Adding columns
# --------------
# You can add columns to a :py:class:`~hdmf.common.table.DynamicTable` using
# :py:meth:`DynamicTable.add_column <hdmf.common.table.DynamicTable.add_column>`.
# If the table already has rows, then the ``data`` argument must be supplied
# as a list of values, one for each row in the table.
table.add_column(
name='col3',
description='column #3',
data=[True, True, False, True], # specify data for the 4 rows in the table
)
###############################################################################
# Ragged array columns
# ^^^^^^^^^^^^^^^^^^^^
# A table column with a different number of elements for each row is called a
# ragged array. To initialize a :py:class:`~hdmf.common.table.DynamicTable`
# with a ragged array column, pass both
# the :py:class:`~hdmf.common.table.VectorIndex` and its target
# :py:class:`~hdmf.common.table.VectorData` object in for the ``columns``
# argument in the constructor.
col1 = VectorData(
name='col1',
# the :py:class:~hdmf.common.resources.ObjectTable, the parent object identified by
# :py:class:~hdmf.common.resources.Object.object_id must be the closest parent to the target object
# (i.e., :py:class:~hdmf.common.resources.Object.relative_pathmust be the shortest possible path and
# as such cannot contain any objects with adata_typeand associatedobject_id`).
# A common example would be with the :py:class:`~hdmf.common.table.DynamicTable` class, which holds
# :py:class:`~hdmf.common.table.VectorData` objects as columns. If we wanted to add an external
# reference on a column from a :py:class:`~hdmf.common.table.DynamicTable`, then we would use the
# column as the object and not the :py:class:`~hdmf.common.table.DynamicTable` (Refer to rule 9).
# Note: :py:func:`~hdmf.common.resources.ExternalResources.add_ref` internally resolves the object
# to the closest parent, so that er.add_ref(container=genotypes, attribute='genotype_name') and
# er.add_ref(container=genotypes.genotype_name, attribute=None) will ultimatly both use the object_id
# of the genotypes.genotype_name VectorData column and not the object_id of the genotypes table.
genotypes = DynamicTable(name='genotypes', description='My genotypes')
genotypes.add_column(name='genotype_name', description="Name of genotypes")
genotypes.add_row(id=0, genotype_name='Rorb')
er.add_ref(
container=genotypes,
attribute='genotype_name',
key='Rorb',
resource_name='MGI Database',
resource_uri='http://www.informatics.jax.org/',
entity_id='MGI:1346434',
entity_uri='http://www.informatics.jax.org/marker/MGI:1343464'
)
###############################################################################
# Using the get_keys method
# ------------------------------------------------------
# The :py:func:`~hdmf.common.resources.ExternalResources.get_keys` method
