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()), [])
