def test_numpy(self): np1 = np.zeros(10) np2 = np.zeros(11) np3 = np.zeros(10) self.assertEqual(get_hash(np1), get_hash(np3)) self.assertNotEqual(get_hash(np1), get_hash(np2))
def test_pandas(self): df1 = pd.DataFrame({'foo': [12]}) df2 = pd.DataFrame({'foo': [42]}) df3 = pd.DataFrame({'foo': [12]}) self.assertEqual(get_hash(df1), get_hash(df3)) self.assertNotEqual(get_hash(df1), get_hash(df2))
def test_partial(self): p1 = functools.partial(int, base=2) p2 = functools.partial(int, base=3) p3 = functools.partial(int, base=2) self.assertEqual(get_hash(p1), get_hash(p3)) self.assertNotEqual(get_hash(p1), get_hash(p2))
def test_file_position(self): with open(__file__, 'r') as f: h1 = get_hash(f) self.assertEqual(h1, get_hash(f)) f.readline() self.assertNotEqual(h1, get_hash(f)) f.seek(0) self.assertEqual(h1, get_hash(f))
def test_builtins(self): """Tes code with builtins.""" def code_with_print(): print(12) def code_with_type(): type(12) self.assertNotEqual(get_hash(code_with_print), get_hash(code_with_type))
def test_external_module(self): """Test code that references an external module.""" def call_altair_concat(): return alt.vegalite.v3.api.concat() def call_altair_layer(): return alt.vegalite.v3.api.layer() self.assertNotEqual(get_hash(call_altair_concat), get_hash(call_altair_layer))
def test_lambdas(self): """Test code with different lambdas produces different hashes.""" v42 = 42 v123 = 123 def f1(): lambda x: v42 def f2(): lambda x: v123 self.assertNotEqual(get_hash(f1), get_hash(f2))
def test_streamlit(self): """Test hashing streamlit functions.""" def f(): st.write("Hello") def g(): st.write("World") def h(): st.write("Hello") self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_defaults(self): """Test the hash of functions with defaults.""" def f(x=42): return x def g(x=12): return x def h(x=42): return x self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_rename(self): """Test the hash of function with renamed variables.""" def f(x, y): return x + y def g(x, y): return y + x def h(y, x): return y + x self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_simple(self): """Test the hash of simple functions.""" def f(x): return x * x def g(x): return x + x def h(x): return x*x self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_lambdas_calls(self): """Test code with lambdas that call functions.""" def f_lower(): lambda x: x.lower() def f_upper(): lambda x: x.upper() def f_lower2(): lambda x: x.lower() self.assertNotEqual(get_hash(f_lower), get_hash(f_upper)) self.assertEqual(get_hash(f_lower), get_hash(f_lower2))
def test_coref(self): """Test code that references itself.""" def f(x): return f(x) def g(x): return g(x) + 1 def h(x): return h(x) self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_value(self): """Test the hash of functions with values.""" def f(): x = 42 return x def g(): x = 12 return x def h(): y = 42 return y self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def _write_to_mem_cache(key, value, allow_output_mutation, hash_funcs): if allow_output_mutation: hash = None else: hash = get_hash(value, hash_funcs=hash_funcs) _mem_cache[key] = CacheEntry(value=value, hash=hash)
def hash_prog_3(): o = Foo() def f(): return o.get_x() return get_hash(f)
def test_cached(self): """Test decorated functions.""" @st.cache def f(): return 42 @st.cache def g(): return 12 @st.cache def h(): return 42 self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def hash_prog_2(): o = Foo() def f(): return o.get_y() return get_hash(f)
def test_referenced(self): """Test the hash of functions that reference values.""" x = 42 y = 123 def f(): return x def g(): return y def h(): return x self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_import(self): """Test code that imports module.""" def f(): import numpy return numpy def g(): import pandas return pandas def n(): import foobar return foobar self.assertNotEqual(get_hash(f), get_hash(g)) self.assertNotEqual(get_hash(f), get_hash(n))
def test_multiple(self): """Test code that references multiple objects.""" x = 12 y = 13 z = 14 def f(): return x + z def g(): return y + z def h(): return x + z self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def test_files(self): temp1 = tempfile.NamedTemporaryFile() temp2 = tempfile.NamedTemporaryFile() with open(__file__, 'r') as f: with open(__file__, 'r') as g: self.assertEqual(get_hash(f), get_hash(g)) self.assertNotEqual(get_hash(f), get_hash(temp1)) self.assertEqual(get_hash(temp1), get_hash(temp1)) self.assertNotEqual(get_hash(temp1), get_hash(temp2))
def test_higher_order(self): """Test hashing higher order functions.""" def f(x): def func(v): return v**x return func def g(x): def func(v): return v*x return func def h(x): def func(v): return v**x return func self.assertNotEqual(get_hash(f), get_hash(g))
def hash_prog_1(): x = 12 def g(): return x def f(): return g() return get_hash(f)
def hash_prog_2(): x = 42 def g(): return x def f(): return g() return get_hash(f)
def test_dict_reference(self): """Test code with lambdas that call a dictionary.""" a = { 'foo': 42, 'bar': { 'baz': 12 } } def f(): return a['bar']['baz'] def g(): return a['foo'] def h(): return a['bar']['baz'] self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))
def _read_from_mem_cache(key, ignore_hash): if key in _mem_cache: entry = _mem_cache[key] if ignore_hash or get_hash(entry.value) == entry.hash: LOGGER.debug('Memory cache HIT: %s', type(entry.value)) return entry.value, entry.args_mutated else: LOGGER.debug('Cache object was mutated: %s', key) raise CachedObjectWasMutatedError() else: LOGGER.debug('Memory cache MISS: %s', key) raise CacheKeyNotFoundError('Key not found in mem cache')
def _read_from_mem_cache(key, allow_output_mutation): if key in _mem_cache: entry = _mem_cache[key] if allow_output_mutation or get_hash(entry.value) == entry.hash: LOGGER.debug("Memory cache HIT: %s", type(entry.value)) return entry.value, entry.args_mutated else: LOGGER.debug("Cache object was mutated: %s", key) raise CachedObjectWasMutatedError() else: LOGGER.debug("Memory cache MISS: %s", key) raise CacheKeyNotFoundError("Key not found in mem cache")
def hash_prog_2(): class Foo(): x = 42 def get_x(self): return self.x o = Foo() def f(): return o.get_x() return get_hash(f)
def test_decorated(self): """Test decorated functions.""" def do(func): @functools.wraps(func) def wrapper_do(*args, **kwargs): return func(*args, **kwargs) return wrapper_do @do def f(): return 42 @do def g(): return 12 @do def h(): return 42 self.assertNotEqual(get_hash(f), get_hash(g)) self.assertEqual(get_hash(f), get_hash(h))