import base64 import io import os import pathlib import tarfile import numpy as np import pytest from hypothesis import given, settings from hypothesis import strategies as st from hypothesis.extra import numpy as st_np import tiledb from .common import DiskTestCase, assert_captured MIN_INT = np.iinfo(np.int64).min MAX_INT = np.iinfo(np.int64).max st_int = st.integers(min_value=MIN_INT, max_value=MAX_INT) st_float = st.floats(allow_nan=False) st_metadata = st.fixed_dictionaries( { "int": st_int, "double": st_float, "bytes": st.binary(), "str": st.text(), "list_int": st.lists(st_int), "tuple_int": st.lists(st_int).map(tuple), "list_float": st.lists(st_float), "tuple_float": st.lists(st_float).map(tuple), } ) st_ndarray = st_np.arrays( dtype=st.one_of( st_np.integer_dtypes(endianness="<"), st_np.unsigned_integer_dtypes(endianness="<"), st_np.floating_dtypes(endianness="<", sizes=(32, 64)), st_np.byte_string_dtypes(max_len=1), st_np.unicode_string_dtypes(endianness="<", max_len=1), st_np.datetime64_dtypes(endianness="<"), ), shape=st_np.array_shapes(min_dims=0, max_dims=3, min_side=0, max_side=10), ) class GroupTestCase(DiskTestCase): def setup_method(self): super().setup_method() self.group1 = self.path("group1") self.group2 = self.path("group1/group2") self.group3 = self.path("group1/group3") self.group4 = self.path("group1/group3/group4") tiledb.group_create(self.group1) tiledb.group_create(self.group2) tiledb.group_create(self.group3) tiledb.group_create(self.group4) def is_group(self, uri): return tiledb.object_type(uri) == "group" class GroupTest(GroupTestCase): def test_is_group(self): self.assertTrue(self.is_group(self.group1)) self.assertTrue(self.is_group(self.group2)) self.assertTrue(self.is_group(self.group3)) self.assertTrue(self.is_group(self.group4)) def test_walk_group(self): if pytest.tiledb_vfs == "s3": pytest.skip("S3 does not have empty directories") groups = [] def append_to_groups(path, obj): groups.append((os.path.normpath(path), obj)) tiledb.walk(self.path(""), append_to_groups, order="preorder") groups.sort() self.assertTrue(groups[0][0].endswith(self.group1) and groups[0][1] == "group") self.assertTrue(groups[1][0].endswith(self.group2) and groups[1][1] == "group") self.assertTrue(groups[2][0].endswith(self.group3) and groups[2][1] == "group") self.assertTrue(groups[3][0].endswith(self.group4) and groups[3][1] == "group") groups = [] tiledb.walk(self.path(""), append_to_groups, order="postorder") self.assertTrue(groups[0][0].endswith(self.group2) and groups[0][1] == "group") self.assertTrue(groups[1][0].endswith(self.group4) and groups[1][1] == "group") self.assertTrue(groups[2][0].endswith(self.group3) and groups[2][1] == "group") self.assertTrue(groups[3][0].endswith(self.group1) and groups[3][1] == "group") def test_remove_group(self): tiledb.remove(self.group3) self.assertFalse(self.is_group(self.group3)) self.assertFalse(self.is_group(self.group4)) def test_move_group(self): self.assertTrue(self.is_group(self.group2)) tiledb.move(self.group2, self.group2 + "_moved") self.assertFalse(self.is_group(self.group2)) self.assertTrue(self.is_group(self.group2 + "_moved")) @pytest.mark.parametrize( "int_data,flt_data,str_data,str_type", ( (-1, -1.5, "asdf", "STRING_UTF8"), ([1, 2, 3], [1.5, 2.5, 3.5], b"asdf", "BLOB"), ( np.array([1, 2, 3]), np.array([1.5, 2.5, 3.5]), np.array(["x"]), "STRING_UTF8", ), ), ) @pytest.mark.parametrize("use_timestamps", [True, False]) def test_group_metadata( self, int_data, flt_data, str_data, str_type, capfd, use_timestamps ): def values_equal(lhs, rhs): if isinstance(lhs, np.ndarray): if not isinstance(rhs, np.ndarray): return False return np.array_equal(lhs, rhs) elif isinstance(lhs, (list, tuple)): if not isinstance(rhs, (list, tuple)): return False return tuple(lhs) == tuple(rhs) else: return lhs == rhs grp_path = self.path("test_group_metadata") tiledb.Group.create(grp_path) cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {}) with tiledb.Group(grp_path, "w", cfg) as grp: grp.meta["int"] = int_data grp.meta["flt"] = flt_data grp.meta["str"] = str_data cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {}) with tiledb.Group(grp_path, "r", cfg) as grp: assert len(grp.meta) == 3 assert "int" in grp.meta assert values_equal(grp.meta["int"], int_data) assert "flt" in grp.meta assert values_equal(grp.meta["flt"], flt_data) assert "str" in grp.meta assert values_equal(grp.meta["str"], str_data) grp.meta.dump() metadata_dump = capfd.readouterr().out assert "Type: DataType.FLOAT" in metadata_dump assert "Type: DataType.INT" in metadata_dump assert f"Type: DataType.{str_type}" in metadata_dump cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {}) with tiledb.Group(grp_path, "w", cfg) as grp: del grp.meta["int"] cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {}) with tiledb.Group(grp_path, "r", cfg) as grp: assert len(grp.meta) == 2 assert "int" not in grp.meta def test_group_members(self): grp_path = self.path("test_group_members") tiledb.Group.create(grp_path) grp = tiledb.Group(grp_path, "w") assert os.path.basename(grp.uri) == os.path.basename(grp_path) array_path = self.path("test_group_members_array") domain = tiledb.Domain(tiledb.Dim(domain=(1, 8), tile=2)) a1 = tiledb.Attr("val", dtype="f8") schema = tiledb.ArraySchema(domain=domain, attrs=(a1,)) tiledb.Array.create(array_path, schema) grp0_path = self.path("test_group_0") tiledb.Group.create(grp0_path) grp.add(grp0_path) grp.add(array_path) grp.close() assert not grp.isopen grp.open("r") assert grp.mode == "r" assert grp.isopen assert len(grp) == 2 type_to_basename = { tiledb.Array: os.path.basename(array_path), tiledb.Group: os.path.basename(grp0_path), } assert grp[0].type in type_to_basename assert type_to_basename[grp[0].type] == os.path.basename(grp[0].uri) assert grp[0].name is None assert grp[1].type in type_to_basename assert type_to_basename[grp[1].type] == os.path.basename(grp[1].uri) assert grp[1].name is None assert "test_group_members GROUP" in repr(grp) assert "|-- test_group_members_array ARRAY" in repr(grp) assert "|-- test_group_0 GROUP" in repr(grp) grp.close() grp.open("w") assert grp.mode == "w" grp.remove(grp0_path) grp.close() grp = tiledb.Group(grp_path, "r") assert len(grp) == 1 for mbr in grp: assert os.path.basename(mbr.uri) == os.path.basename(array_path) assert mbr.type == tiledb.Array grp.close() def test_group_named_members(self): grp_path = self.path("test_group_named_members") tiledb.Group.create(grp_path) subgrp_path = self.path("subgroup") tiledb.Group.create(subgrp_path) array_path = self.path("subarray") domain = tiledb.Domain(tiledb.Dim(domain=(1, 8), tile=2)) a1 = tiledb.Attr("val", dtype="f8") schema = tiledb.ArraySchema(domain=domain, attrs=(a1,)) tiledb.Array.create(array_path, schema) grp = tiledb.Group(grp_path, "w") grp.add(subgrp_path, "subgroup") grp.add(array_path, "subarray") grp.close() grp.open("r") assert os.path.basename(grp["subarray"].uri) == os.path.basename(array_path) assert os.path.basename(grp["subgroup"].uri) == os.path.basename(subgrp_path) assert "dne" not in grp assert "subarray" in grp assert grp["subarray"].type == tiledb.Array assert "subgroup" in grp assert grp["subgroup"].type == tiledb.Group for mbr in grp: if "subarray" in mbr.uri: assert mbr.name == "subarray" elif "subgroup" in mbr.uri: assert mbr.name == "subgroup" grp.close() with tiledb.Group(grp_path, "w") as grp: # test __enter__ and __exit__ del grp["subarray"] grp.remove("subgroup") grp.open("r") assert len(grp) == 0 grp.close() def test_pass_context(self): foo = self.path("foo") bar = self.path("foo/bar") tiledb.group_create(foo) tiledb.group_create(bar) ctx = tiledb.Ctx() with tiledb.Group(foo, mode="w", ctx=ctx) as G: G.add(bar, name="bar") with tiledb.Group(foo, mode="r", ctx=ctx) as G: assert "bar" in G def test_relative(self): group1 = self.path("group1") group2_1 = self.path("group1/group2_1") group2_2 = self.path("group1/group2_2") tiledb.group_create(group2_1) tiledb.group_create(group2_2) with tiledb.Group(group1, mode="w") as G: G.add(group2_1, name="group2_1", relative=False) G.add("group2_2", name="group2_2", relative=True) with tiledb.Group(group1, mode="r") as G: assert G.is_relative("group2_1") is False assert G.is_relative("group2_2") is True def test_set_config(self): group_uri = self.path("foo") array_uri_1 = self.path("foo/a") array_uri_2 = self.path("foo/b") tiledb.group_create(group_uri) dom = tiledb.Domain(tiledb.Dim("id", dtype="ascii")) attr = tiledb.Attr("value", dtype=np.int64) sch = tiledb.ArraySchema(domain=dom, attrs=(attr,), sparse=True) tiledb.Array.create(array_uri_1, sch) tiledb.Array.create(array_uri_2, sch) cfg = tiledb.Config({"sm.group.timestamp_end": 2000}) with tiledb.Group(group_uri, "w", cfg) as G: G.add(name="a", uri="a", relative=True) cfg = tiledb.Config({"sm.group.timestamp_end": 3000}) with tiledb.Group(group_uri, "w", cfg) as G: G.add(name="b", uri="b", relative=True) ms = np.arange(1000, 4000, 1000, dtype=np.int64) for sz, m in enumerate(ms): cfg = tiledb.Config({"sm.group.timestamp_end": m}) G = tiledb.Group(group_uri) # Cannot set config on open group with self.assertRaises(ValueError): G.set_config(cfg) G.close() G.set_config(cfg) G.open() assert len(G) == sz G.close() for sz, m in enumerate(ms): cfg = tiledb.Config({"sm.group.timestamp_end": m}) with tiledb.Group(group_uri, config=cfg) as G: assert len(G) == sz def test_invalid_object_type(self): path = self.path() schema = tiledb.ArraySchema( domain=tiledb.Domain(tiledb.Dim("id", dtype="ascii")), attrs=(tiledb.Attr("value", dtype=np.int64),), sparse=True, ) tiledb.Array.create(path, schema) with self.assertRaises(tiledb.TileDBError): tiledb.Group(uri=path, mode="w") def test_group_does_not_exist(self): with self.assertRaises(tiledb.TileDBError): tiledb.Group("does-not-exist") class GroupMetadataTest(GroupTestCase): @pytest.mark.parametrize( "int_data,flt_data,str_data", ( (-1, -1.5, "asdf"), ([1, 2, 3], [1.5, 2.5, 3.5], b"asdf"), (np.array([1, 2, 3]), np.array([1.5, 2.5, 3.5]), np.array(["x"])), ), ) @pytest.mark.parametrize("use_timestamps", [True, False]) def test_group_metadata(self, int_data, flt_data, str_data, use_timestamps): def values_equal(lhs, rhs): if isinstance(lhs, np.ndarray): if not isinstance(rhs, np.ndarray): return False return np.array_equal(lhs, rhs) elif isinstance(lhs, (list, tuple)): if not isinstance(rhs, (list, tuple)): return False return tuple(lhs) == tuple(rhs) else: return lhs == rhs grp_path = self.path("test_group_metadata") tiledb.Group.create(grp_path) cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {}) with tiledb.Group(grp_path, "w", cfg) as grp: grp.meta["int"] = int_data grp.meta["flt"] = flt_data grp.meta["str"] = str_data cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {}) with tiledb.Group(grp_path, "r", cfg) as grp: assert grp.meta.keys() == {"int", "flt", "str"} assert len(grp.meta) == 3 assert "int" in grp.meta assert values_equal(grp.meta["int"], int_data) assert "flt" in grp.meta assert values_equal(grp.meta["flt"], flt_data) assert "str" in grp.meta assert values_equal(grp.meta["str"], str_data) cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {}) with tiledb.Group(grp_path, "w", cfg) as grp: del grp.meta["int"] cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {}) with tiledb.Group(grp_path, "r", cfg) as grp: assert len(grp.meta) == 2 assert "int" not in grp.meta def assert_equal_md_values(self, written_value, read_value): if isinstance(written_value, np.ndarray): self.assertIsInstance(read_value, np.ndarray) self.assertEqual(read_value.dtype, written_value.dtype) np.testing.assert_array_equal(read_value, written_value) elif not isinstance(written_value, (list, tuple)): assert read_value == written_value # we don't round-trip perfectly sequences elif len(written_value) == 1: # sequences of length 1 are read as a single scalar element self.assertEqual(read_value, written_value[0]) else: # sequences of length != 1 are read as tuples self.assertEqual(read_value, tuple(written_value)) def assert_metadata_roundtrip(self, tdb_meta, dict_meta): for k, v in dict_meta.items(): # test __contains__ self.assertTrue(k in tdb_meta) # test __getitem__ self.assert_equal_md_values(v, tdb_meta[k]) # test get self.assert_equal_md_values(v, tdb_meta.get(k)) # test __contains__, __getitem__, get for non-key non_key = str(object()) self.assertFalse(non_key in tdb_meta) with self.assertRaises(KeyError): tdb_meta[non_key] self.assertIsNone(tdb_meta.get(non_key)) self.assertEqual(tdb_meta.get(non_key, 42), 42) # test __len__ self.assertEqual(len(tdb_meta), len(dict_meta)) # test __iter__() self.assertEqual(set(tdb_meta), set(tdb_meta.keys())) # test keys() self.assertSetEqual(set(tdb_meta.keys()), set(dict_meta.keys())) # test values() and items() read_values = list(tdb_meta.values()) read_items = list(tdb_meta.items()) self.assertEqual(len(read_values), len(read_items)) for (item_key, item_value), value in zip(read_items, read_values): self.assertTrue(item_key in dict_meta) self.assert_equal_md_values(dict_meta[item_key], item_value) self.assert_equal_md_values(dict_meta[item_key], value) def assert_not_implemented_methods(self, tdb_meta): with self.assertRaises(NotImplementedError): tdb_meta.setdefault("nokey", "hello!") with self.assertRaises(NotImplementedError): tdb_meta.pop("nokey", "hello!") with self.assertRaises(NotImplementedError): tdb_meta.popitem() with self.assertRaises(NotImplementedError): tdb_meta.clear() def test_errors(self): path = self.path("test_errors") tiledb.Group.create(path) grp = tiledb.Group(path, "w") grp.close() # can't read from a closed array grp.open("r") grp.close() with self.assertRaises(tiledb.TileDBError): grp.meta["x"] grp.open("r") # can't write to a mode='r' array with self.assertRaises(tiledb.TileDBError): grp.meta["invalid_write"] = 1 # missing key raises KeyError with self.assertRaises(KeyError): grp.meta["xyz123nokey"] self.assert_not_implemented_methods(grp.meta) grp.close() # test invalid input grp.open("w") # keys must be strings with self.assertRaises(TypeError): grp.meta[123] = 1 # # can't write an int > typemax(Int64) with self.assertRaises(OverflowError): grp.meta["bigint"] = MAX_INT + 1 # can't write str list with self.assertRaises(TypeError): grp.meta["str_list"] = ["1", "2.1"] # can't write str tuple with self.assertRaises(TypeError): grp.meta["mixed_list"] = ("1", "2.1") # can't write objects with self.assertRaises(TypeError): grp.meta["object"] = object() self.assert_not_implemented_methods(grp.meta) grp.close() def test_null(self): path = self.path() tiledb.Group.create(path) grp = tiledb.Group(path, "w") grp.meta["empty_byte"] = b"" grp.meta["null_byte"] = b"\x00" grp.meta["zero"] = "xxx" grp.close() grp = tiledb.Group(path, "r") assert grp.meta["empty_byte"] == b"" assert grp.meta["null_byte"] == b"\x00" assert grp.meta["zero"] == "xxx" grp.close() @given(st_metadata) @settings(deadline=None) def test_basic(self, test_vals): path = self.path() tiledb.Group.create(path) grp = tiledb.Group(path, "w") grp.meta.update(test_vals) grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() # test a 1 MB blob blob = np.random.rand(int((1024**2) / 8)).tobytes() grp = tiledb.Group(path, "w") test_vals["bigblob"] = blob grp.meta["bigblob"] = blob grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() # test del key grp = tiledb.Group(path, "w") del test_vals["bigblob"] del grp.meta["bigblob"] grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() # test update grp = tiledb.Group(path, "w") test_vals.update(foo="bar", double=3.14) grp.meta.update(foo="bar", double=3.14) grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() @given(st_metadata, st_ndarray) @settings(deadline=None) def test_numpy(self, test_vals, ndarray): test_vals["ndarray"] = ndarray path = self.path() tiledb.Group.create(path) grp = tiledb.Group(path, "w") grp.meta.update(test_vals) grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() grp = tiledb.Group(path, "w") grp.meta["ndarray"] = 42 test_vals["ndarray"] = 42 grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() # test resetting a key with a non-ndarray value to a ndarray value grp = tiledb.Group(path, "w") grp.meta["bytes"] = ndarray test_vals["bytes"] = ndarray grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() grp = tiledb.Group(path, "w") del grp.meta["ndarray"] del test_vals["ndarray"] grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() grp = tiledb.Group(path, "w") test_vals.update(ndarray=np.stack([ndarray, ndarray]), transp=ndarray.T) grp.meta.update(ndarray=np.stack([ndarray, ndarray]), transp=ndarray.T) grp.close() grp = tiledb.Group(path, "r") self.assert_metadata_roundtrip(grp.meta, test_vals) grp.close() @pytest.mark.parametrize("use_timestamps", [True, False]) def test_consolidation_and_vac(self, use_timestamps): vfs = tiledb.VFS() path = self.path("test_consolidation_and_vac") tiledb.Group.create(path) cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {}) with tiledb.Group(path, "w", cfg) as grp: grp.meta["meta"] = 1 cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {}) with tiledb.Group(path, "w", cfg) as grp: grp.meta["meta"] = 2 cfg = tiledb.Config({"sm.group.timestamp_end": 3} if use_timestamps else {}) with tiledb.Group(path, "w", cfg) as grp: grp.meta["meta"] = 3 meta_path = pathlib.Path(path) / "__meta" assert len(vfs.ls(meta_path)) == 3 tiledb.Group.consolidate_metadata(path, cfg) tiledb.Group.vacuum_metadata(path, cfg) assert len(vfs.ls(meta_path)) == 1 @pytest.mark.skipif( tiledb.libtiledb.version() < (2, 18, 0), reason="Group consolidation and vacuuming not available < 2.18", ) def test_consolidation_and_vac_no_config(self): vfs = tiledb.VFS() path = self.path("test_consolidation_and_vac") tiledb.Group.create(path) with tiledb.Group(path, "w") as grp: grp.meta["meta"] = 1 with tiledb.Group(path, "w") as grp: grp.meta["meta"] = 2 with tiledb.Group(path, "w") as grp: grp.meta["meta"] = 3 meta_path = pathlib.Path(path) / "__meta" assert len(vfs.ls(meta_path)) == 3 tiledb.Group.consolidate_metadata(path) tiledb.Group.vacuum_metadata(path) assert len(vfs.ls(meta_path)) == 1 def test_string_metadata(self, capfd): # this test ensures that string metadata is correctly stored and # retrieved from the metadata store. It also tests that the metadata # dump method works correctly for string metadata. uri = self.path("test_ascii_metadata") tiledb.Group.create(uri) grp = tiledb.Group(uri, "w") grp.meta["abc"] = "xyz" grp.close() grp = tiledb.Group(uri, "r") assert grp.meta["abc"] == "xyz" grp.meta.dump() assert_captured(capfd, "Type: DataType.STRING_UTF8") grp.close() def test_array_or_list_of_strings_metadata_error(self): # this test ensures that an error is raised when trying to store # an array or list of strings as metadata in a group. # numpy arrays of single characters are supported since we don't need # any extra offset information to retrieve them. uri = self.path("test_ascii_metadata") tiledb.Group.create(uri) grp = tiledb.Group(uri, "w") with pytest.raises(TypeError) as exc: grp.meta["abc"] = ["x", "1"] assert "Unsupported item type" in str(exc.value) with pytest.raises(TypeError) as exc: grp.meta["abc"] = ["foo", "foofoo"] with pytest.raises(TypeError) as exc: grp.meta["abc"] = np.array(["foo", "12345"]) grp.meta["abc"] = np.array(["1", "2", "3", "f", "o", "o"], dtype="U1") grp.close() grp = tiledb.Group(uri, "r") self.assert_metadata_roundtrip( grp.meta, {"abc": np.array(["1", "2", "3", "f", "o", "o"], dtype="U1")} ) grp.close() grp = tiledb.Group(uri, "w") grp.meta["abc"] = np.array(["T", "i", "l", "e", "D", "B", "!"], dtype="S1") grp.close() grp = tiledb.Group(uri, "r") self.assert_metadata_roundtrip( grp.meta, {"abc": np.array([b"T", b"i", b"l", b"e", b"D", b"B", b"!"], dtype="S1")}, ) grp.close() def test_bytes_metadata(self, capfd): # this test ensures that bytes metadata is correctly stored and # retrieved from the metadata store. It also tests that the metadata # dump method works correctly for bytes metadata. path = self.path() tiledb.Group.create(path) grp = tiledb.Group(path, "w") grp.meta["bytes"] = b"blob" grp.close() grp = tiledb.Group(path, "r") assert grp.meta["bytes"] == b"blob" grp.meta.dump() assert_captured(capfd, "Type: DataType.BLOB") grp.close() def test_group_metadata_backwards_compat(self): # This test ensures that metadata written with the TileDB-Py 0.32.3 # will be read correctly in the future versions. # === The following code creates a group with metadata using the current version of TileDB-Py === path_new = self.path("new_group") tiledb.Group.create(path_new) group = tiledb.Group(path_new, "w") # python primitive types group.meta["python_int"] = -1234 group.meta["python_float"] = 3.14 group.meta["python_str"] = "hello" group.meta["python_bytes"] = b"hello" group.meta["python_bool"] = False # numpy primitive types group.meta["numpy_int"] = np.int64(-93) group.meta["numpy_uint"] = np.uint64(42) group.meta["numpy_float64"] = np.float64(3.14) group.meta["numpy_bytes"] = np.bytes_("hello") group.meta["numpy_str"] = np.str_("hello") group.meta["numpy_bool"] = np.bool_(False) # lists/tuples group.meta["list_int"] = [7] group.meta["tuple_int"] = (7,) group.meta["list_ints"] = [1, -2, 3] group.meta["tuple_ints"] = (1, 2, 3) group.meta["list_float"] = [1.1] group.meta["tuple_float"] = (1.1,) group.meta["list_floats"] = [1.1, 2.2, 3.3] group.meta["tuple_floats"] = (1.1, 2.2, 3.3) group.meta["list_empty"] = [] group.meta["tuple_empty"] = () # numpy arrays group.meta["numpy_int"] = np.array([-11], dtype=np.int64) group.meta["numpy_ints"] = np.array([1, -2, 3], dtype=np.int64) group.meta["numpy_uint"] = np.array([22], dtype=np.uint64) group.meta["numpy_uints"] = np.array([1, 2, 3], dtype=np.uint64) group.meta["numpy_float"] = np.array([3.14], dtype=np.float64) group.meta["numpy_floats"] = np.array([1.1, 2.2, 3.3], dtype=np.float64) group.meta["numpy_byte"] = np.array([b"hello"], dtype="S5") group.meta["numpy_str"] = np.array(["hello"], dtype="U5") group.meta["numpy_bool"] = np.array([True, False, True]) group.close() # === End of the code that creates the group with metadata === # The following commented out code was used to generate the base64 encoded string of the group # from the TileDB-Py 0.32.3 after creating the group with metadata in the exact same way as above. ''' # Compress the contents of the group folder to tgz with tarfile.open("test.tar.gz", "w:gz") as tar: with os.scandir(path_new) as entries: for entry in entries: tar.add(entry.path, arcname=entry.name) # Read the .tgz file and encode it to base64 with open("test.tar.gz", 'rb') as f: s = base64.encodebytes(f.read()) # Print the base64 encoded string group_tgz = f"""{s.decode():>32}""" print(group_tgz) ''' # The following base64 encoded string is the contents of the group folder compressed # to a tgz file using TileDB-Py 0.32.3. group_tgz = b"""H4sICO/+G2cC/3Rlc3QudGFyANPT19N3CEis8EhNTEktYqAJMIAAXLSBgbEJgg0SNzQwMjRiUKhg oAMoLS5JLAJazzAygZGFQm5JZm6qraG5kaWFhbmlhbGekaGphbGlJRfDKBj2ID4+N7UkUZ+mdoAy tbmpKYQ2g9AGRqh53tDE3MDM3Nzc2NQcmP8NDc3NGRRM6Zn/E9Mzi/GpAypLSxt+8a83KMp/Y8zy 33C0/KdL+W+Otfy3NBot/kdS+R8fj4h/YPSj8UxTktOSjQxMjNPMzS0MDCxTjVLNTUwS01IMzMxM zJMTicj/ZiYmuMp/QwNjM9Ty38jQAFhdKBjQM/+P0PJfDIhfMULYV1khNAsjTFYITDIygAQYQbKM YBYDQv0xIEcAymdEEqtgbA1x9DtsIBATrJgRpRfwgC18R8GqqqXxD1gDJwZtnTTb5YbtE0YbprhD 8y0KH7SwVJTnps9d9sorMOX8Met7M8+yMHzas+bz0rgbMet7z3b75kqb3mSdtisqonQnu8GrGvHI 6WGxX/Jm+7UW7V45+8/OVSZ3+O+Ic/0Sloo+8OKG6hqutaun9NgfXjqDz9ftBZNBwLvXt6+fX94/ ++EfK0X1S2nBpVv5jQ0cut7nS8T3/wn7rOpq5q9/Jn2XW8OhQ/frZTLrkycxHt1evlKvrtbsXeIX 2dw33D0fd0yt5vqe8T/k3d3wtO4UI5Vm8yMvspXTJE+ozFY+13ZA7e+avDertDwP+b1mcjq0JPar QLS26mvFLQH6D97dDbyZlx1b8X/ZHYmHWpqMjTP6QiVvrZX/3nsqxv3WwofHjtgmbk+YGnhC/U1D v5+z0SvXZ5YfmXhYiw4Ynmi727rZteXvpZULJ/jvNikQV1/tuiM73XDytc2ZVu6PRcy4NN3Cuze9 0GJc1KHr+mXOAxexJaUFAv/kVgi/K+FaI+2wZfqOxoYWocQPGzNeG9h9edh+3DfBJMYzOKL2l+em ezc0Hyq98xaQ8eT40PDoxpYX60KKnogs7Ht2d+cf9lm5m9pGy8fhDvRG+/+j/X+M9p+JqYGJ+WgD cES0/0oyc1JTkuLTi/JLC/RKUpJok//xtP+w9P+NTUD9v9H232j5P1r+D0j5b2ZoYDZa/o+I8h9c 8NN0AJiM8V8TA9PR8d9RMApGwSgYBaNgFIyCUTAKRsEooCYAAP1+F2wAKAAA""" # Ceate a new group by extracting the contents of the tgz file path_original = self.path("original_group") with tarfile.open(fileobj=io.BytesIO(base64.b64decode(group_tgz))) as tf: try: tf.extractall(path_original, filter="fully_trusted") except TypeError: tf.extractall(path_original) # Open both the original and the new group and compare the metadata both in values and types group_original = tiledb.Group(path_original, "r") group_new = tiledb.Group(path_new, "r") self.assert_metadata_roundtrip(group_new.meta, group_original.meta) group_original.close() group_new.close() def test_group_metadata_new_types(self): # This kind of data was not supported for TileDB-Py <= 0.32.3 path_new = self.path("new_group") tiledb.Group.create(path_new) group = tiledb.Group(path_new, "w") test_vals = { "int64": np.array(-1111, dtype=np.int64), "uint64": np.array(2, dtype=np.uint64), "float64": np.array(3.14, dtype=np.float64), "bool": np.array(True, dtype=bool), "str": np.array(["a", "b", "c"], dtype="S"), "unicode": np.array(["a", "b", "c"], dtype="U"), "bytes": np.array([b"a", b"b", b"c"]), "datetime": np.array( [np.datetime64("2021-01-01"), np.datetime64("2021-01-02")] ), } group.meta.update(test_vals) group.close() group = tiledb.Group(path_new, "r") self.assert_metadata_roundtrip(group.meta, test_vals) group.close()