def test_map_delete_3(self): A = HashKey(100, 'A') B = HashKey(101, 'B') C = HashKey(100100, 'C') D = HashKey(100100, 'D') E = HashKey(104, 'E') h = Map() h = h.set(A, 'a') h = h.set(B, 'b') h = h.set(C, 'c') h = h.set(D, 'd') h = h.set(E, 'e') orig_len = len(h) # BitmapNode(size=6 bitmap=0b100110000): # NULL: # BitmapNode(size=4 bitmap=0b1000000000000000000001000): # <Key name:A hash:100>: 'a' # NULL: # CollisionNode(size=4 id=0x108572410): # <Key name:C hash:100100>: 'c' # <Key name:D hash:100100>: 'd' # <Key name:B hash:101>: 'b' # <Key name:E hash:104>: 'e' h = h.delete(A) self.assertEqual(len(h), orig_len - 1) h = h.delete(E) self.assertEqual(len(h), orig_len - 2) self.assertEqual(h.get(C), 'c') self.assertEqual(h.get(B), 'b')
def test_hash_1(self): h = Map() self.assertNotEqual(hash(h), -1) self.assertEqual(hash(h), hash(h)) h = h.set(1, 2).set('a', 'b') self.assertNotEqual(hash(h), -1) self.assertEqual(hash(h), hash(h)) self.assertEqual(hash(h.set(1, 2).set('a', 'b')), hash(h.set('a', 'b').set(1, 2)))
def test_repr_2(self): h = Map() A = HashKey(100, 'A') with self.assertRaises(ReprError): with HaskKeyCrasher(error_on_repr=True): repr(h.set(1, 2).set(A, 3).set(3, 4)) with self.assertRaises(ReprError): with HaskKeyCrasher(error_on_repr=True): repr(h.set(1, 2).set(2, A).set(3, 4))
def test_hash_2(self): h = Map() A = HashKey(100, 'A') m = h.set(1, 2).set(A, 3).set(3, 4) with self.assertRaises(HashingError): with HaskKeyCrasher(error_on_hash=True): hash(m) m = h.set(1, 2).set(2, A).set(3, 4) with self.assertRaises(HashingError): with HaskKeyCrasher(error_on_hash=True): hash(m)
def test_map_delete_2(self): A = HashKey(100, 'A') B = HashKey(201001, 'B') C = HashKey(101001, 'C') D = HashKey(103, 'D') E = HashKey(104, 'E') Z = HashKey(-100, 'Z') Er = HashKey(201001, 'Er', error_on_eq_to=B) h = Map() h = h.set(A, 'a') h = h.set(B, 'b') h = h.set(C, 'c') h = h.set(D, 'd') h = h.set(E, 'e') orig_len = len(h) # BitmapNode(size=8 bitmap=0b1110010000): # <Key name:A hash:100>: 'a' # <Key name:D hash:103>: 'd' # <Key name:E hash:104>: 'e' # NULL: # BitmapNode(size=4 bitmap=0b100000000001000000000): # <Key name:B hash:201001>: 'b' # <Key name:C hash:101001>: 'c' with self.assertRaisesRegex(ValueError, 'cannot compare'): h.delete(Er) h = h.delete(Z) self.assertEqual(len(h), orig_len) h = h.delete(C) self.assertEqual(len(h), orig_len - 1) h = h.delete(B) self.assertEqual(len(h), orig_len - 2) h = h.delete(A) self.assertEqual(len(h), orig_len - 3) self.assertEqual(h.get(D), 'd') self.assertEqual(h.get(E), 'e') h = h.delete(A) h = h.delete(B) h = h.delete(D) h = h.delete(E) self.assertEqual(len(h), 0)
def test_map_eq_2(self): A = HashKey(100, 'A') Er = HashKey(100, 'Er', error_on_eq_to=A) h1 = Map() h1 = h1.set(A, 'a') h2 = Map() h2 = h2.set(Er, 'a') with self.assertRaisesRegex(ValueError, 'cannot compare'): h1 == h2 with self.assertRaisesRegex(ValueError, 'cannot compare'): h1 != h2
def test_map_delete_5(self): h = Map() keys = [] for i in range(17): key = HashKey(i, str(i)) keys.append(key) h = h.set(key, 'val-{}'.format(i)) collision_key16 = HashKey(16, '18') h = h.set(collision_key16, 'collision') # ArrayNode(id=0x10f8b9318): # 0:: # BitmapNode(size=2 count=1 bitmap=0b1): # <Key name:0 hash:0>: 'val-0' # # ... 14 more BitmapNodes ... # # 15:: # BitmapNode(size=2 count=1 bitmap=0b1): # <Key name:15 hash:15>: 'val-15' # # 16:: # BitmapNode(size=2 count=1 bitmap=0b1): # NULL: # CollisionNode(size=4 id=0x10f2f5af8): # <Key name:16 hash:16>: 'val-16' # <Key name:18 hash:16>: 'collision' self.assertEqual(len(h), 18) h = h.delete(keys[2]) self.assertEqual(len(h), 17) h = h.delete(collision_key16) self.assertEqual(len(h), 16) h = h.delete(keys[16]) self.assertEqual(len(h), 15) h = h.delete(keys[1]) self.assertEqual(len(h), 14) h = h.delete(keys[1]) self.assertEqual(len(h), 14) for key in keys: h = h.delete(key) self.assertEqual(len(h), 0)
def __new__(mcs, name, bases, namespace, **kwargs): if name != 'Model': table_name = namespace.get('__table_name__', name) namespace['__table_name__'] = camel_case_to_snake_case(table_name).replace(' ', '_') fields = Map() property_fields = {} MetaModel._set_id(namespace) annotations = {} for attr, field in namespace.items(): if isinstance(field, Field): if not attr.startswith('_'): raise PrivateField('Fields name must be private') fields = fields.set(attr, field) property_name = attr.replace('_', '', 1) if field.name is None: field.name = property_name property_fields[property_name] = MetaModel._resolve_getters_and_setters( attr, namespace, property_fields, field ) annotations[property_name] = field.internal_type MetaModel._set_foreignkey_field(annotations, attr, property_fields, property_name, field) namespace['_fields'] = fields namespace.update(property_fields) namespace['__annotations__'] = annotations return super().__new__(mcs, name, bases, namespace)
def test_repr_1(self): h = Map() self.assertTrue(repr(h).startswith('<immutables.Map({}) at 0x')) h = h.set(1, 2).set(2, 3).set(3, 4) self.assertTrue( repr(h).startswith('<immutables.Map({1: 2, 2: 3, 3: 4}) at 0x'))
def test_map_basics_2(self): h = Map() self.assertEqual(len(h), 0) h2 = h.set('a', 'b') self.assertIsNot(h, h2) self.assertEqual(len(h), 0) self.assertEqual(len(h2), 1) self.assertIsNone(h.get('a')) self.assertEqual(h.get('a', 42), 42) self.assertEqual(h2.get('a'), 'b') h3 = h2.set('b', 10) self.assertIsNot(h2, h3) self.assertEqual(len(h), 0) self.assertEqual(len(h2), 1) self.assertEqual(len(h3), 2) self.assertEqual(h3.get('a'), 'b') self.assertEqual(h3.get('b'), 10) self.assertIsNone(h.get('b')) self.assertIsNone(h2.get('b')) self.assertIsNone(h.get('a')) self.assertEqual(h2.get('a'), 'b') h = h2 = h3 = None
def test_map_basics_4(self): h = Map() h1 = h.set('key', []) h2 = h1.set('key', []) self.assertIsNot(h1, h2) self.assertEqual(len(h1), 1) self.assertEqual(len(h2), 1) self.assertIsNot(h1.get('key'), h2.get('key'))
def test_map_keys_1(self): A = HashKey(100, 'A') B = HashKey(101, 'B') C = HashKey(100100, 'C') D = HashKey(100100, 'D') E = HashKey(100100, 'E') F = HashKey(110, 'F') h = Map() h = h.set(A, 'a') h = h.set(B, 'b') h = h.set(C, 'c') h = h.set(D, 'd') h = h.set(E, 'e') h = h.set(F, 'f') self.assertEqual(set(list(h.keys())), {A, B, C, D, E, F}) self.assertEqual(set(list(h)), {A, B, C, D, E, F})
def test_map_gc_2(self): A = HashKey(100, 'A') h = Map() h = h.set(A, 'a') h = h.set(A, h) ref = weakref.ref(h) hi = h.items() next(hi) del h, hi gc.collect() gc.collect() gc.collect() self.assertIsNone(ref())
def Mapit_mutate(): a = Map({"key_one": ("val_one", )}) b = a.set("key_one", ("sweets", "great")) with a.mutate() as mm: mm['key_one'] = ("sweets", "great") b = mm.finish() return b
def test_map_delete_1(self): A = HashKey(100, 'A') B = HashKey(101, 'B') C = HashKey(102, 'C') D = HashKey(103, 'D') E = HashKey(104, 'E') Z = HashKey(-100, 'Z') Er = HashKey(103, 'Er', error_on_eq_to=D) h = Map() h = h.set(A, 'a') h = h.set(B, 'b') h = h.set(C, 'c') h = h.set(D, 'd') h = h.set(E, 'e') orig_len = len(h) # BitmapNode(size=10 bitmap=0b111110000 id=0x10eadc618): # <Key name:A hash:100>: 'a' # <Key name:B hash:101>: 'b' # <Key name:C hash:102>: 'c' # <Key name:D hash:103>: 'd' # <Key name:E hash:104>: 'e' h = h.delete(C) self.assertEqual(len(h), orig_len - 1) with self.assertRaisesRegex(ValueError, 'cannot compare'): h.delete(Er) h = h.delete(D) self.assertEqual(len(h), orig_len - 2) h2 = h.delete(Z) self.assertIs(h2, h) h = h.delete(A) self.assertEqual(len(h), orig_len - 3) self.assertEqual(h.get(A, 42), 42) self.assertEqual(h.get(B), 'b') self.assertEqual(h.get(E), 'e')
def test_map_items_2(self): A = HashKey(100, 'A') B = HashKey(101, 'B') C = HashKey(100100, 'C') D = HashKey(100100, 'D') E = HashKey(100100, 'E') F = HashKey(110, 'F') h = Map() h = h.set(A, 'a') h = h.set(B, 'b') h = h.set(C, 'c') h = h.set(D, 'd') h = h.set(E, 'e') h = h.set(F, 'f') it = h.items() self.assertEqual(set(list(it)), {(A, 'a'), (B, 'b'), (C, 'c'), (D, 'd'), (E, 'e'), (F, 'f')})
def test_map_eq_1(self): A = HashKey(100, 'A') B = HashKey(101, 'B') C = HashKey(100100, 'C') D = HashKey(100100, 'D') E = HashKey(120, 'E') h1 = Map() h1 = h1.set(A, 'a') h1 = h1.set(B, 'b') h1 = h1.set(C, 'c') h1 = h1.set(D, 'd') h2 = Map() h2 = h2.set(A, 'a') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.set(B, 'b') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.set(C, 'c') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.set(D, 'd2') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.set(D, 'd') self.assertTrue(h1 == h2) self.assertFalse(h1 != h2) h2 = h2.set(E, 'e') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.delete(D) self.assertFalse(h1 == h2) self.assertTrue(h1 != h2) h2 = h2.set(E, 'd') self.assertFalse(h1 == h2) self.assertTrue(h1 != h2)
def set_context(self, context: immutables.Map) -> immutables.Map: if type(context) is not immutables.Map: raise ImmutableContextError( "Context must be a type of 'immutables.Map'") if not all(key in context for key in CONTEXT_REQUIRED_FIELDS): raise ContextError("Context must contain required arguments: " + ", ".join(CONTEXT_REQUIRED_FIELDS)) context = context.set("log_level", self.log_level_int(context["log_level"])) self._context = context self.level = self._context.get("log_level") return self._context
def test_map_gc_1(self): A = HashKey(100, 'A') h = Map() h = h.set(0, 0) # empty Map node is memoized in _map.c ref = weakref.ref(h) a = [] a.append(a) a.append(h) b = [] a.append(b) b.append(a) h = h.set(A, b) del h, a, b gc.collect() gc.collect() gc.collect() self.assertIsNone(ref())
def test_repr_3(self): class Key: def __init__(self): self.val = None def __hash__(self): return 123 def __repr__(self): return repr(self.val) h = Map() k = Key() h = h.set(k, 1) k.val = h self.assertTrue( repr(h).startswith('<immutables.Map({{...}: 1}) at 0x'))
def test_map_in_1(self): A = HashKey(100, 'A') AA = HashKey(100, 'A') B = HashKey(101, 'B') h = Map() h = h.set(A, 1) self.assertTrue(A in h) self.assertFalse(B in h) with self.assertRaises(EqError): with HaskKeyCrasher(error_on_eq=True): AA in h with self.assertRaises(HashingError): with HaskKeyCrasher(error_on_hash=True): AA in h
def test_map_getitem_1(self): A = HashKey(100, 'A') AA = HashKey(100, 'A') B = HashKey(101, 'B') h = Map() h = h.set(A, 1) self.assertEqual(h[A], 1) self.assertEqual(h[AA], 1) with self.assertRaises(KeyError): h[B] with self.assertRaises(EqError): with HaskKeyCrasher(error_on_eq=True): h[AA] with self.assertRaises(HashingError): with HaskKeyCrasher(error_on_hash=True): h[AA]
def test_map_collision_1(self): k1 = HashKey(10, 'aaa') k2 = HashKey(10, 'bbb') k3 = HashKey(10, 'ccc') h = Map() h2 = h.set(k1, 'a') h3 = h2.set(k2, 'b') self.assertEqual(h.get(k1), None) self.assertEqual(h.get(k2), None) self.assertEqual(h2.get(k1), 'a') self.assertEqual(h2.get(k2), None) self.assertEqual(h3.get(k1), 'a') self.assertEqual(h3.get(k2), 'b') h4 = h3.set(k2, 'cc') h5 = h4.set(k3, 'aa') self.assertEqual(h3.get(k1), 'a') self.assertEqual(h3.get(k2), 'b') self.assertEqual(h4.get(k1), 'a') self.assertEqual(h4.get(k2), 'cc') self.assertEqual(h4.get(k3), None) self.assertEqual(h5.get(k1), 'a') self.assertEqual(h5.get(k2), 'cc') self.assertEqual(h5.get(k2), 'cc') self.assertEqual(h5.get(k3), 'aa') self.assertEqual(len(h), 0) self.assertEqual(len(h2), 1) self.assertEqual(len(h3), 2) self.assertEqual(len(h4), 2) self.assertEqual(len(h5), 3)
async def where(self, tr, pattern, *patterns): # seed bindings vars = tuple((isinstance(item, var) for item in pattern)) if vars == (True, False, False): subject, predicate, object = pattern subjects = await self._lookup_pos_subjects(tr, predicate, object) name = subject.name bindings = [Map().set(name, subject) for subject in subjects] elif vars == (False, True, True): # TODO: extract to a method subject = pattern[0] start = found.pack((self._prefix, PREFIX_SPO, subject)) end = found.strinc(start) items = await tr.get_range(start, end) bindings = [] for key, _ in items: _, _, _, predicate, object = found.unpack(key) predicate = self._predicates[predicate] object = predicate.unpack(object) binding = Map() binding = binding.set(pattern[1].name, predicate.name) binding = binding.set(pattern[2].name, object) bindings.append(binding) elif vars == (False, False, True): # TODO: extract to a method subject = pattern[0] predicate = pattern[1] start = found.pack((self._prefix, PREFIX_SPO, subject, predicate)) end = found.strinc(start) items = await tr.get_range(start, end) bindings = [] for key, _ in items: _, _, _, _, object = found.unpack(key) predicate = self._predicates[predicate] object = predicate.unpack(object) binding = Map() binding = binding.set(pattern[2].name, object) bindings.append(binding) else: raise PatternException(pattern) log.debug("seed bindings: %r", bindings) # contine matching other patterns, if any. for pattern in patterns: # one log.debug("matching pattern: %r", pattern) next_bindings = [] for binding in bindings: # two bound_pattern = pattern_bind(pattern, binding) log.debug("bound pattern: %r", bound_pattern) vars = tuple((isinstance(item, var) for item in bound_pattern)) if vars == (False, False, False): log.debug("clause: False, False, False") ok = await self.exists(tr, *bound_pattern) if ok: # this binding is valid against this bound_pattern, # proceed with this binding and continue with # the next pattern. next_bindings.append(binding) elif vars == (False, False, True): # TODO: extract to a method log.debug("clause: False, False, True") subject, predicate, object = bound_pattern predicate = self._predicates[predicate] start = found.pack( (self._prefix, PREFIX_SPO, subject, predicate.name)) end = found.strinc(start) items = await tr.get_range(start, end) for key, _ in items: _, _, _, _, value = found.unpack(key) value = predicate.pack(value) new = binding.set(object.name, value) next_bindings.append(new) elif vars == (True, False, False): log.debug("clause: True, False, False") subject, predicate, object = bound_pattern predicate = self._predicates[predicate] object = predicate.pack(object) values = await self._lookup_pos_subjects( tr, predicate.name, object) for value in values: new = binding.set(subject.name, value) next_bindings.append(new) else: raise PatternException(pattern) bindings = next_bindings return bindings
def Mapit(): a = Map({"key_one": ("val_one", )}) b = a.set("key_one", ("sweets", "great")) return b
# # thing = ImmutableThing(42, 'hello world') # print(f'Created an ImmutableThing: {thing}') # try: # thing.x = 99 # except Exception as e: # print(f'Caught an error trying to assign to ImmutableThing! {type(e)}') # # print(f'hash(thing): {hash(thing)}') # print(f"ImmutableThing respects logical equality: {thing == ImmutableThing(42, 'hello world')}") # print(f"ImmutableThing as a dictionary key: {dict(thing='thing is a key')}") from immutables import Map d = {'a': 1, 'b': 2, 'c': 3} try: hash(d) except TypeError as e: print(f'Exception when trying to hash a dict! {e}') m = Map(d) print(f'hash(m): {hash(m)}') print(f"Map as a dictionary key: {dict(m='map is a key!')}") try: m['a'] = 42 except TypeError as e: print(e) # Assignment creates a _new_ map! m_prime = m.set('a', 42) print(f'm after assignment: {m}') print(f'm_prime after assignment: {m_prime}')
def test_map_basics_3(self): h = Map() o = object() h1 = h.set('1', o) h2 = h1.set('1', o) self.assertIs(h1, h2)
def test_map_stress(self): COLLECTION_SIZE = 7000 TEST_ITERS_EVERY = 647 CRASH_HASH_EVERY = 97 CRASH_EQ_EVERY = 11 RUN_XTIMES = 3 for _ in range(RUN_XTIMES): h = Map() d = dict() for i in range(COLLECTION_SIZE): key = KeyStr(i) if not (i % CRASH_HASH_EVERY): with HaskKeyCrasher(error_on_hash=True): with self.assertRaises(HashingError): h.set(key, i) h = h.set(key, i) if not (i % CRASH_EQ_EVERY): with HaskKeyCrasher(error_on_eq=True): with self.assertRaises(EqError): h.get(KeyStr(i)) # really trigger __eq__ d[key] = i self.assertEqual(len(d), len(h)) if not (i % TEST_ITERS_EVERY): self.assertEqual(set(h.items()), set(d.items())) self.assertEqual(len(h.items()), len(d.items())) self.assertEqual(len(h), COLLECTION_SIZE) for key in range(COLLECTION_SIZE): self.assertEqual(h.get(KeyStr(key), 'not found'), key) keys_to_delete = list(range(COLLECTION_SIZE)) random.shuffle(keys_to_delete) for iter_i, i in enumerate(keys_to_delete): key = KeyStr(i) if not (iter_i % CRASH_HASH_EVERY): with HaskKeyCrasher(error_on_hash=True): with self.assertRaises(HashingError): h.delete(key) if not (iter_i % CRASH_EQ_EVERY): with HaskKeyCrasher(error_on_eq=True): with self.assertRaises(EqError): h.delete(KeyStr(i)) h = h.delete(key) self.assertEqual(h.get(key, 'not found'), 'not found') del d[key] self.assertEqual(len(d), len(h)) if iter_i == COLLECTION_SIZE // 2: hm = h dm = d.copy() if not (iter_i % TEST_ITERS_EVERY): self.assertEqual(set(h.keys()), set(d.keys())) self.assertEqual(len(h.keys()), len(d.keys())) self.assertEqual(len(d), 0) self.assertEqual(len(h), 0) # ============ for key in dm: self.assertEqual(hm.get(str(key)), dm[key]) self.assertEqual(len(dm), len(hm)) for i, key in enumerate(keys_to_delete): hm = hm.delete(str(key)) self.assertEqual(hm.get(str(key), 'not found'), 'not found') dm.pop(str(key), None) self.assertEqual(len(d), len(h)) if not (i % TEST_ITERS_EVERY): self.assertEqual(set(h.values()), set(d.values())) self.assertEqual(len(h.values()), len(d.values())) self.assertEqual(len(d), 0) self.assertEqual(len(h), 0) self.assertEqual(list(h.items()), [])