def make_simple_table(cls, keys=None, vals=None, immutable=False): data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True) if keys is not None and vals is not None: assert len(keys) == len(vals) for i, k in enumerate(keys): data[k] = vals[i] return cls(data, immutable)
def sub(self,right): result = r_dict(dict_eq, dict_hash) for key, val in self.values.iteritems(): result[key] = val del result[right] return Dict(result)
def func(i): d = r_dict(eq, rhash, force_non_null=True) if not i: d[None] = i else: d[str(i)] = i return "12" in d, d
def get_key_to_index(self): from pypy.objspace.std.dictmultiobject import unicode_hash, unicode_eq key_to_index = self.key_to_index if key_to_index is None: key_to_index = self.key_to_index = objectmodel.r_dict( unicode_eq, unicode_hash, force_non_null=True, simple_hash_eq=True) # compute depth curr = self depth = 0 while True: depth += 1 curr = curr.prev if not isinstance(curr, JSONMap): break curr = self while depth: depth -= 1 key_to_index[curr.w_key] = depth curr = curr.prev if not isinstance(curr, JSONMap): break return key_to_index
def test_rtype_constant_r_dicts(self): d1 = r_dict(strange_key_eq, strange_key_hash) d1['hello'] = 666 d2 = r_dict(strange_key_eq, strange_key_hash) d2['hello'] = 777 d2['world'] = 888 def fn(i): if i == 1: d = d1 else: d = d2 return len(d) res = self.interpret(fn, [1]) assert res == 1 res = self.interpret(fn, [2]) assert res == 2
def sub(self, right): result = r_dict(dict_eq, dict_hash) for key, val in self.values.iteritems(): result[key] = val del result[right] return Dict(result)
def make_simple_mutable_table(cls, keys=None, vals=None): data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True) if keys is not None and vals is not None: assert len(keys) == len(vals) for i, k in enumerate(keys): data[k] = vals[i] return cls(data)
def f(n): dct = objectmodel.r_dict(eq, key) total = n while total: myjitdriver.jit_merge_point(total=total, dct=dct) dct[total] = dct.get(total, 0) + 1 total -= 1 return dct[0]
def f(): d1 = r_dict(eq, raising_hash) d1['xxx'] = 1 try: x = d1["blabla"] except Exception: return 42 return x
def intersection(self, other): new_map = r_dict(my_eq, my_hash) for e in other.hashmap: if e in self.hashmap: new_map[e] = True result = frozenset() result.hashmap = new_map return result
def test_r_dict_move_to_end(): d = r_dict(strange_key_eq, strange_key_hash) d['1key'] = 'val1' d['2key'] = 'val2' d['3key'] = 'val3' # does not crash, we can't check that it actually moves to end on CPython move_to_end(d, '1key') move_to_end(d, '1key', last=False)
def f(): d1 = r_dict(eq, raising_hash) d1['xxx'] = 1 try: d1["blabla"] = 2 except TypeError: return 42 return 0
def __init__(self, space): self.ctvoid = None # There can be only one self.ctvoidp = None # Cache for self.pointers[self.ctvoid] self.ctchara = None # Cache for self.arrays[charp, -1] self.primitives = {} # Keys: name self.pointers = {} # Keys: base_ctype self.arrays = {} # Keys: (ptr_ctype, length_or_-1) self.functions = r_dict(# Keys: (fargs, w_fresult, ellipsis) _func_key_eq, _func_key_hash)
def __init__(self, space): self.ctvoid = None # There can be only one self.ctvoidp = None # Cache for self.pointers[self.ctvoid] self.ctchara = None # Cache for self.arrays[charp, -1] self.primitives = {} # Keys: name self.pointers = {} # Keys: base_ctype self.arrays = {} # Keys: (ptr_ctype, length_or_-1) self.functions = r_dict( # Keys: (fargs, w_fresult, ellipsis) _func_key_eq, _func_key_hash)
def __init__(self, arity, default=null, doc=null): self.arity = arity self.multimethod_table = r_dict(eq_fn, hash_fn, force_non_null=True) self.version = VersionTag( ) # The version tag is required because the result 'None' # from the get_impl/get_method can be very useful due # to the .default -function call behavior. self.default = default self.doc = doc
def f(n): d = None while n > 0: myjitdriver.jit_merge_point(n=n, d=d) d = objectmodel.r_dict(eq_func, hash_func) y = Wrapper(str(n)) d[y] = n - 1 n = d[y] return d[Wrapper(str(n + 1))]
def test_rtype_r_dict_singlefrozen_func_pbc(self): class FreezingClass(Strange): def _freeze_(self): return True obj = FreezingClass() pbc_d = r_dict(obj.key_eq, obj.key_hash) def fn(): return play_with_r_dict(pbc_d) assert self.interpret(fn, []) is True
def f(n): dct = objectmodel.r_dict(eq, key) total = n while total: myjitdriver.jit_merge_point(total=total, dct=dct) if total not in dct: dct[total] = [] dct[total].append(total) total -= 1 return len(dct[0])
def __init__(self, kvs=[], w_meta=w_nil): assert len(kvs) % 2 == 0 W_Obj.__init__(self, w_meta) self.dict = r_dict( lambda this, other: this.equals(other), lambda obj: obj.hash() ) idx = 0 while idx < len(kvs): self.dict[kvs[idx]] = kvs[idx + 1] idx += 2
def __init__(self, space, s): self.space = space self.s = s # we put our string in a raw buffer so: # 1) we automatically get the '\0' sentinel at the end of the string, # which means that we never have to check for the "end of string" # 2) we can pass the buffer directly to strtod self.ll_chars = rffi.str2charp(s) self.end_ptr = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') self.pos = 0 self.cache = r_dict(slice_eq, slice_hash, simple_hash_eq=True)
def _gcref_index(self, gcref): if self.gcrefs_map is None: self.gcrefs_map = r_dict(rd_eq, rd_hash) try: return self.gcrefs_map[gcref] except KeyError: pass index = len(self.gcrefs_output_list) self.gcrefs_map[gcref] = index self.gcrefs_output_list.append(gcref) return index
def add(self, right): if isinstance(right, Dict): result = Dict(r_dict(dict_eq, dict_hash)) for key, val in self.values.iteritems(): result.values[key] = val for key, val in right.values.iteritems(): result.values[key] = val return result raise LogicError("Cannot add that to dict")
def make_simple_mutable_table_assocs(cls, assocs, who): if not assocs.is_proper_list(): raise SchemeException("%s: not given proper list" % who) data = r_dict(cls.cmp_value, cls.hash_value, force_non_null=True) while isinstance(assocs, values.W_Cons): entry, assocs = assocs.car(), assocs.cdr() if not isinstance(entry, values.W_Cons): raise SchemeException("%s: expected list of pairs" % who) key, val = entry.car(), entry.cdr() data[key] = val return cls(data)
def __init__(self, state, next_varno): self.sofar = [] self.state = state self.next_varno = next_varno self.backtrack = 0 self.next_chrid = 0 self.chr_by_id = {} self.chr_by_fsym = {} self.chr_history_set = r_dict(hist_eq, hist_hash, force_non_null=True) self.chr_occur = {} self.chr_debug = False self.chr_lock = False
def Set_intersection_update(self, argv): for arg in argv: it = arg.iter() common = r_dict(eq_fn, hash_fn, force_non_null=True) try: while True: item = it.callattr(u"next", []) if item in self._set: common[item] = None except StopIteration as stop: pass self._set = common return null
def f(i): d = r_dict(strange_key_eq, strange_key_hash) h = strange_key_hash("abc") assert h == strange_key_hash("aXX") and strange_key_eq("abc", "aXX") setitem_with_hash(d, "abc", h, i) assert getitem_with_hash(d, "aXX", h) == i try: getitem_with_hash(d, "bYY", strange_key_hash("bYY")) except KeyError: pass else: raise AssertionError return 0
def __init__(self, L=None): W_Object.__init__(self) if L is None: L = [] self.hashmap = r_dict(my_eq, my_hash) # frozenset([1,1,2])==frozenset([1,2]) # TODO: maybe the performance improves if cases like frozenset([1,1,2]) # are not used by any pyB code. (only enumerated sets and the repl. needs this check then) assert isinstance(L, list) for e in L: self.hashmap[e] = True self.repr_string = None self.hash_computed = False self.my_hash = 0
def f(n): dct = objectmodel.r_dict(eq, key) total = n x = 44444 y = 55555 z = 66666 while total: myjitdriver.jit_merge_point(total=total, dct=dct) dct[total] = total x = dct[total] y = dct[total] z = dct[total] total -= 1 return len(dct) + x + y + z
def func(): d = r_dict(deq, dhash) d[5] = 2 d[6] = 3 k1, v1 = d.popitem() assert len(d) == 1 k2, v2 = d.popitem() try: d.popitem() except KeyError: pass else: assert 0, "should have raised KeyError" assert len(d) == 0 return k1*1000 + v1*100 + k2*10 + v2
def get_next(self, w_key, string, start, stop, terminator): """ Returns the next map, given a wrapped key w_key, the json input string with positions start and stop, as well as a terminator. Returns None if the key already appears somewhere in the map chain. """ from pypy.objspace.std.dictmultiobject import unicode_hash, unicode_eq if isinstance(self, JSONMap): assert not self.state == MapBase.BLOCKED nextmap_first = self.nextmap_first if (nextmap_first is not None and nextmap_first.w_key.eq_w(w_key)): return nextmap_first assert stop >= 0 assert start >= 0 if nextmap_first is None: # first transition ever seen, don't initialize nextmap_all next = self._make_next_map(w_key, string[start:stop]) if next is None: return None self.nextmap_first = next else: if self.nextmap_all is None: # 2nd transition ever seen self.nextmap_all = objectmodel.r_dict(unicode_eq, unicode_hash, force_non_null=True, simple_hash_eq=True) self.nextmap_all[nextmap_first.w_key] = nextmap_first else: next = self.nextmap_all.get(w_key, None) if next is not None: return next # if we are at this point we didn't find the transition yet, so # create a new one next = self._make_next_map(w_key, string[start:stop]) if next is None: return None self.nextmap_all[w_key] = next # one new leaf has been created self.change_number_of_leaves(1) terminator.register_potential_fringe(next) return next
def test_customdict_circular(self): from rpython.rlib.objectmodel import r_dict def key_eq(a, b): return a.x[0] == b.x[0] def key_hash(a): return ord(a.x[0]) class A: def __init__(self, x): self.x = x a = A('foo') a.dict = r_dict(key_eq, key_hash) a.dict[a] = 42 def fn(b): if b: s = A('foo') else: s = A('bar') return a.dict[s] assert self.interpret(fn, [True]) == 42
def test_constant_r_dict(self): def strange_key_eq(key1, key2): return key1[0] == key2[0] # only the 1st character is relevant def strange_key_hash(key): return ord(key[0]) d = r_dict(strange_key_eq, strange_key_hash) d['hello'] = 42 d['world'] = 43 for x in range(65, 91): d[chr(x)] = x * x def func(i): return d[chr(i)] res = self.interpret(func, [ord('h')]) assert res == 42 res = self.interpret(func, [ord('w')]) assert res == 43 for x in range(65, 91): res = self.interpret(func, [x]) assert res == x * x
def f(n): d = r_dict(myeq, myhash) for i in range(10): d[i] = i*i try: value1 = d[n] except FooError: value1 = 99 try: value2 = n in d except FooError: value2 = 99 try: value3 = d[-n] except FooError: value3 = 99 try: value4 = (-n) in d except FooError: value4 = 99 return (value1 * 1000000 + value2 * 10000 + value3 * 100 + value4)
def func_r_dict_bm(): # NB. this test function is also annotated by the next tests strange = Strange() d = r_dict(strange.key_eq, strange.key_hash) return play_with_r_dict(d)
def func_r_dict(): # NB. this test function is also annotated/rtyped by the next tests d = r_dict(strange_key_eq, strange_key_hash) return play_with_r_dict(d)
def test_recursive_r_dict_repr(): import operator rdic = r_dict(operator.eq, hash) rdic['x'] = rdic assert str(rdic) == "r_dict({'x': r_dict({...})})" assert repr(rdic) == "r_dict({'x': r_dict({...})})"
def g(n): d = r_dict(eq, h) d[1] = n f(d) return d[2]
def g(n): d = r_dict(eq, h) d[1] = n d[2] = 2 * n return f(d)
def fn(): d = r_dict(obj.key_eq, obj.key_hash) return play_with_r_dict(d)
def __init__(self): self.data = r_dict(eq_fn, hash_fn, force_non_null=True)
def new_ref_dict_3(self): return r_dict(rd_eq, rd_hash)
def _create_empty_dict(self): return r_dict(cmp_immutable_bytes, hash_immutable_bytes)
def _create_empty_dict(self): return r_dict(cmp_strings, hash_strings)
def _create_empty_dict(self): return r_dict(cmp_bytes, hash_bytes)