def test_has(self) -> None:
i = MemoryDescriptorSet()
descrs = [random_descriptor() for _ in range(10)]
i.add_many_descriptors(descrs)
self.assertTrue(i.has_descriptor(descrs[4].uuid()))
self.assertFalse(i.has_descriptor('not_an_int'))
def test_natural_iter(self) -> None:
"""Test that iterating over the descriptor set appropriately
yields the descriptor element contents."""
i = MemoryDescriptorSet()
descrs = [random_descriptor() for _ in range(100)]
i.add_many_descriptors(descrs)
self.assertEqual(set(i), set(descrs))
def test_added_descriptor_table_caching(self) -> None:
cache_elem = DataMemoryElement(readonly=False)
descrs = [random_descriptor() for _ in range(3)]
expected_table = dict((r.uuid(), r) for r in descrs)
i = MemoryDescriptorSet(cache_elem)
assert i.cache_element is not None
self.assertTrue(cache_elem.is_empty())
# Should add descriptors to table, caching to writable element.
i.add_many_descriptors(descrs)
self.assertFalse(cache_elem.is_empty())
self.assertEqual(pickle.loads(i.cache_element.get_bytes()),
expected_table)
# Changing the internal table (remove, add) it should reflect in
# cache
new_d = random_descriptor()
expected_table[new_d.uuid()] = new_d
i.add_descriptor(new_d)
self.assertEqual(pickle.loads(i.cache_element.get_bytes()),
expected_table)
rm_d = list(expected_table.values())[0]
del expected_table[rm_d.uuid()]
i.remove_descriptor(rm_d.uuid())
self.assertEqual(pickle.loads(i.cache_element.get_bytes()),
expected_table)
def test_clear(self) -> None:
i = MemoryDescriptorSet()
n = 10
descrs = [random_descriptor() for _ in range(n)]
i.add_many_descriptors(descrs)
self.assertEqual(len(i), n)
i.clear()
self.assertEqual(len(i), 0)
self.assertEqual(i._table, {})
def test_get_descriptors(self) -> None:
descrs = [
random_descriptor(), # [0]
random_descriptor(), # [1]
random_descriptor(), # [2]
random_descriptor(), # [3]
random_descriptor(), # [4]
]
index = MemoryDescriptorSet()
index.add_many_descriptors(descrs)
# single descriptor reference
r = index.get_descriptor(descrs[1].uuid())
self.assertEqual(r, descrs[1])
def test_update_index_existing_descriptors_frozenset(self) -> None:
"""
Same as ``test_update_index_similar_descriptors`` but testing that
we can update the index when seeded with structures with existing
values.
"""
# Similar Descriptors to build and update on (different instances)
descriptors1 = [
DescriptorMemoryElement('t', 0).set_vector([0]),
DescriptorMemoryElement('t', 1).set_vector([1]),
DescriptorMemoryElement('t', 2).set_vector([2]),
DescriptorMemoryElement('t', 3).set_vector([3]),
DescriptorMemoryElement('t', 4).set_vector([4]),
]
descriptors2 = [
DescriptorMemoryElement('t', 5).set_vector([0]),
DescriptorMemoryElement('t', 6).set_vector([1]),
DescriptorMemoryElement('t', 7).set_vector([2]),
DescriptorMemoryElement('t', 8).set_vector([3]),
DescriptorMemoryElement('t', 9).set_vector([4]),
]
descr_set = MemoryDescriptorSet()
descr_set.add_many_descriptors(descriptors1)
hash_kvs = MemoryKeyValueStore()
hash_kvs.add(0, frozenset({0}))
hash_kvs.add(1, frozenset({1}))
hash_kvs.add(2, frozenset({2}))
hash_kvs.add(3, frozenset({3}))
hash_kvs.add(4, frozenset({4}))
index = LSHNearestNeighborIndex(DummyHashFunctor(), descr_set,
hash_kvs)
index.update_index(descriptors2)
assert descr_set.count() == 10
# Above descriptors should be considered "in" the descriptor set now.
for d in descriptors1:
assert d in descr_set
for d in descriptors2:
assert d in descr_set
# Known hashes of the above descriptors should be in the KVS
assert set(hash_kvs.keys()) == {0, 1, 2, 3, 4}
assert hash_kvs.get(0) == {0, 5}
assert hash_kvs.get(1) == {1, 6}
assert hash_kvs.get(2) == {2, 7}
assert hash_kvs.get(3) == {3, 8}
assert hash_kvs.get(4) == {4, 9}
def test_get_many_descriptor(self) -> None:
descrs = [
random_descriptor(), # [0]
random_descriptor(), # [1]
random_descriptor(), # [2]
random_descriptor(), # [3]
random_descriptor(), # [4]
]
index = MemoryDescriptorSet()
index.add_many_descriptors(descrs)
# multiple descriptor reference
r = list(
index.get_many_descriptors([descrs[0].uuid(), descrs[3].uuid()]))
self.assertEqual(len(r), 2)
self.assertEqual(set(r), {descrs[0], descrs[3]})
def test_count(self) -> None:
index = MemoryDescriptorSet()
self.assertEqual(index.count(), 0)
d1 = random_descriptor()
index.add_descriptor(d1)
self.assertEqual(index.count(), 1)
d2, d3, d4 = (random_descriptor(), random_descriptor(),
random_descriptor())
index.add_many_descriptors([d2, d3, d4])
self.assertEqual(index.count(), 4)
d5 = random_descriptor()
index.add_descriptor(d5)
self.assertEqual(index.count(), 5)
def test_remove(self) -> None:
i = MemoryDescriptorSet()
descrs = [random_descriptor() for _ in range(100)]
i.add_many_descriptors(descrs)
self.assertEqual(len(i), 100)
self.assertEqual(list(i.iterdescriptors()), descrs)
# remove singles
i.remove_descriptor(descrs[0].uuid())
self.assertEqual(len(i), 99)
self.assertEqual(set(i.iterdescriptors()), set(descrs[1:]))
# remove many
rm_d = descrs[slice(45, 80, 3)]
i.remove_many_descriptors((d.uuid() for d in rm_d))
self.assertEqual(len(i), 99 - len(rm_d))
self.assertEqual(set(i.iterdescriptors()),
set(descrs[1:]).difference(rm_d))
def test_add_many(self) -> None:
descrs = [
random_descriptor(),
random_descriptor(),
random_descriptor(),
random_descriptor(),
random_descriptor(),
]
index = MemoryDescriptorSet()
index.add_many_descriptors(descrs)
# Compare code keys of input to code keys in internal table
self.assertEqual(set(index._table.keys()),
set([e.uuid() for e in descrs]))
# Get the set of descriptors in the internal table and compare it with
# the set of generated random descriptors.
r_set = set(index._table.values())
self.assertEqual(set([e for e in descrs]), r_set)
def test_iteritems(self) -> None:
i = MemoryDescriptorSet()
descrs = [random_descriptor() for _ in range(100)]
i.add_many_descriptors(descrs)
self.assertEqual(set(i.items()), set((d.uuid(), d) for d in descrs))
def test_descrs(self) -> None:
i = MemoryDescriptorSet()
descrs = [random_descriptor() for _ in range(100)]
i.add_many_descriptors(descrs)
self.assertEqual(set(i.descriptors()), set(descrs))
