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))