class Arcs:
def __init__(self, Q):
self.coincidences = Hashtable(Q * 10)
self.arcsByPoint = Hashtable(Q * 10)
self.pointsByPoint = Hashtable(Q * 10)
#self.arc_db_path=mkdtemp()+'/arc_db'
#self.arcs= shelve.open(self.arc_db_path)
self.arcs = {}
self.length = 0
#self.storage_path = mkdtemp()+'/db'
#self.db = shelve.open(self.storage_path)
self.db = {}
def get_index(self, point):
return self.pointsByPoint.get(point)
def get_point_arcs(self, point):
return self.arcsByPoint.get(point)
def coincidence_lines(self, point):
return self.coincidences.get(point)
def peak(self, point):
return self.coincidences.peak(point)
def push(self, arc):
self.arcs[str(self.length)] = arc
self.length += 1
return self.length
def map(self, func):
#self.db.close()
#remove(self.storage_path)
out = []
for num in range(0, self.length):
out.append(func(self.arcs[str(num)]))
#self.arcs.close()
#remove(self.arc_db_path)
return out
def get_hash(self, arc):
ourhash = sha1()
ourhash.update(str(arc))
return ourhash.hexdigest()
def check(self, arcs):
a0 = arcs[0]
a1 = arcs[-1]
point = a0 if point_compare(a0, a1) < 0 else a1
point_arcs = self.get_point_arcs(point)
h = self.get_hash(arcs)
if h in self.db:
return int(self.db[h])
else:
index = self.length
point_arcs.append(arcs)
self.db[h] = index
self.db[self.get_hash(list(reversed(arcs)))] = ~index
self.push(arcs)
return index
class Arcs:
def __init__(self, Q):
self.coincidences = Hashtable(Q * 10)
self.arcsByPoint = Hashtable(Q * 10)
self.pointsByPoint = Hashtable(Q * 10)
self.arcs = {}
self.length = 0
self.db = {}
def get_index(self, point):
return self.pointsByPoint.get(point)
def get_point_arcs(self, point):
return self.arcsByPoint.get(point)
def coincidence_lines(self, point):
return self.coincidences.get(point)
def peak(self, point):
return self.coincidences.peak(point)
def push(self, arc):
self.arcs[str(self.length)] = arc
self.length += 1
return self.length
def map(self, func):
out = []
for num in range(0, self.length):
out.append(func(self.arcs[str(num)]))
return out
def get_hash(self, arc):
ourhash = sha1()
ourhash.update(str(arc))
return ourhash.hexdigest()
def check(self, arcs):
a0 = arcs[0]
a1 = arcs[-1]
point = a0 if point_compare(a0, a1) < 0 else a1
point_arcs = self.get_point_arcs(point)
h = self.get_hash(arcs)
if h in self.db:
return int(self.db[h])
else:
index = self.length
point_arcs.append(arcs)
self.db[h] = index
self.db[self.get_hash(list(reversed(arcs)))] = ~index
self.push(arcs)
return index
class Arcs:
def __init__(self,Q):
self.coincidences = Hashtable(Q * 10)
self.arcsByPoint = Hashtable(Q * 10)
self.pointsByPoint = Hashtable(Q * 10)
self.arc_db_path=mkdtemp()+'/arc_db'
self.arcs= shelve.open(self.arc_db_path)
#self.arcs={}
self.length=0
self.storage_path = mkdtemp()+'/db'
self.db = shelve.open(self.storage_path)
#self.db={}
def get_index(self,point):
return self.pointsByPoint.get(point)
def get_point_arcs(self,point):
return self.arcsByPoint.get(point)
def coincidence_lines(self,point):
return self.coincidences.get(point)
def peak(self,point):
return self.coincidences.peak(point)
def push(self,arc):
self.arcs[str(self.length)]=arc
self.length+=1
return self.length
def close(self):
#pass
self.db.close()
remove(self.storage_path)
self.arcs.close()
remove(self.arc_db_path)
def get_hash(self,arc):
ourhash = sha1()
ourhash.update(str(arc))
return ourhash.hexdigest()
def check(self,arcs):
a0 = arcs[0]
a1 = arcs[-1]
point = a0 if point_compare(a0, a1) < 0 else a1
point_arcs = self.get_point_arcs(point)
h = self.get_hash(arcs)
if h in self.db:
return int(self.db[h])
else:
index = self.length
point_arcs.append(arcs)
self.db[h]=index
self.db[self.get_hash(list(reversed(arcs)))]=~index
self.push(arcs)
return index
def test_unknown_key():
ht = Hashtable()
ht.add("banana", 9)
actual = ht.get("cucumber")
expected = None
assert actual == expected
def test_get_silent_and_listen():
hashtable = Hashtable()
hashtable.set('listen', 'to me')
hashtable.set('silent', 'so quiet')
assert hashtable.get('listen') == 'to me'
assert hashtable.get('silent') == 'so quiet'
def test_hashtable_add():
hashtable = Hashtable()
hashtable.set('glisten',3)
actual = hashtable.get('glisten')
expected = 3
assert actual == expected
def twoSumWithHash(self, nums, target):
hashtable = Hashtable()
for i in range(len(nums)):
# Check if complement exists.
if hashtable.contains(target - nums[i]):
# Return it if it does.
return [hashtable.get(target - nums[i]), i]
else:
hashtable.put(nums[i], i)
def test_hashtable_returns_null():
hashtable = Hashtable()
hashtable.set('glisten',3)
actual = hashtable.get('cat')
expected = False
assert actual == expected
def test_hashtable_lookup_collision():
hashtable = Hashtable()
hashtable.set('listen', 1)
hashtable.set('silent', 2)
actual = hashtable.get('listen')
expected = 1
assert actual == expected
class TestHashtable(unittest.TestCase):
def setUp(self):
self.ht = Hashtable()
def test_put(self):
self.assertEqual(self.ht._size(), 0)
self.ht.put('foo', 100)
self.assertEqual(self.ht._size(), 1)
def test_put_with_str_and_int(self):
self.ht.put('foo', 100)
self.ht.put(5, 'bar')
self.assertEqual(self.ht.get('foo'), 100)
self.assertEqual(self.ht.get(5), 'bar')
def test_put_type_checking(self):
self.assertRaises(TypeError, self.ht.put, [], 100)
def test_put_overwrite(self):
self.ht.put('foo', 100)
self.ht.put('foo', 200)
self.assertEqual(self.ht._size(), 1)
val = self.ht.get('foo')
self.assertEqual(val, 200)
def test_put_resize(self):
self.ht._resize = MagicMock()
self.ht.put('foo', 100)
self.ht.put('bar', 200)
self.assertTrue(self.ht._resize.called)
def test_get(self):
self.ht.put('foo', 100)
val = self.ht.get('foo')
self.assertEqual(val, 100)
def test_add():
test_table = Hashtable()
test_table.add('Home', 'Kansas City')
assert test_table.get('Home') == 'Kansas City'
def test_get_empty():
hashtable = Hashtable()
assert hashtable.get(None) == KeyError
def test_get_in_list():
new_hashtable = Hashtable()
new_hashtable.add('Candy', 'Crunch')
assert new_hashtable.get('Candy') == 'Crunch'
def test_get_three_of_same_key():
ht = Hashtable()
ht.add('test', 'object')
ht.add('test', 'thingy')
ht.add('test', 'bobcat')
assert ht.get('test') == 'object | thingy | bobcat'
def test_get_three_of_same_key_integer_values():
ht = Hashtable()
ht.add('test', 1)
ht.add('test', 2)
ht.add('test', 3)
assert ht.get('test') == '1 | 2 | 3'
def test_get_apple():
ht = Hashtable()
ht.add("apple", 42)
actual = ht.get("apple")
expected = 42
assert actual == expected
def test_single_hash_fail():
hashtable = Hashtable()
hashtable.add('roger', 45)
actual = hashtable.get('roger')
expected = 44
assert actual != expected
def test_single_hash_pass():
hashtable = Hashtable()
hashtable.add('roger', 45)
actual = hashtable.get('roger')
expected = 45
assert actual == expected
def test_get_banana():
ht = Hashtable()
ht.add("banana", 9)
actual = ht.get("banana")
expected = 9
assert actual == expected
def test_get_one_key():
ht = Hashtable()
ht.add('test', 'object')
assert ht.get('test') == 'object'
def test_get_apple():
hashtable = Hashtable()
hashtable.set("apple", "Used for apple sauce")
actual = hashtable.get("apple")
expected = "Used for apple sauce"
assert actual == expected
