def main(a):
if a == 1:
least_recently_used = LRU(3)
least_recently_used.put("A", 0)
least_recently_used.put("B", 1)
least_recently_used.put("C", 2)
least_recently_used.print_cache_dictionary()
least_recently_used.print_cache_doubly()
print()
least_recently_used.get("A")
least_recently_used.print_cache_dictionary()
least_recently_used.print_cache_doubly()
print()
else:
word_list = []
with open("WORDS") as file:
line = file.readline().split()
while line:
word_list.extend(line)
line = file.readline().split()
most_frequent_elements(word_list)
def main():
lru_obj = LRU(3)
#tc1
assert lru_obj.get('a')==-1
#tc2
lru_obj.put('a',1)
lru_obj.put('b',2)
lru_obj.put('c',3)
assert lru_obj.get('a')==1, 'Wrong Value'
#tc3
assert lru_obj.get_cache()== {'a':1, 'b':2, 'c':3}, 'Cache is not updated properly'
#tc4
lru_obj.put('d',4)
#tc5
assert len(lru_obj.get_cache())==3, 'capacity crossed'
#tc6
assert lru_obj.get('b')==-1, 'Least Recently Used is not being removed when capacity is crossed'
print("All test cases passed!!")
def selectRangeAndInterval(self, startTime, endTime, interval, keyword):
stime = time.time()
print "start time in select range and interval", stime
print "start time in select range and interval process", time.clock()
interval = interval / 300000
tick = interval * 60
numBuckets = interval / 5
bucketMod = self.setWindow(interval)
[startFileNumber, startBucket] = self.getNames(startTime) #convert bucket to string
[endFileNumber, endBucket] = self.getNames(endTime)
print startFileNumber, endFileNumber
#If timestamps span more than a day, we need to ensure that we get all the buckets in the range
t = startTime
finalList = []
for fileNumber in range(startFileNumber, endFileNumber+1):
if LRU.get(str(fileNumber)) == -1:
with open(str(fileNumber)+'.txt') as data_file:
try:
dataMap = json.load(data_file)
LRU.set(str(fileNumber), dataMap)
except:
for i in range(t, endTime+tick, tick):
finalList.append((str(i), str(0), keyword))
print "end time", time.time()
print "end time", time.clock()
dataMap = LRU.get(str(fileNumber))
if fileNumber == startFileNumber:
startB = startBucket
if startFileNumber==endFileNumber:
endB = endBucket
else:
endB = bucketMod-1
elif fileNumber == endFileNumber+1:
startB = 0
endB = endBucket
else:
startB = 0
endB = bucketMod -1
for bucketNumber in range(startB, endB+1, numBuckets):
bucketNumber = str(bucketNumber)
total_count = 0
for bucket in range(int(bucketNumber), int(bucketNumber) + numBuckets):
if str(bucket) in dataMap and str(keyword) in dataMap[str(bucket)]:
count=dataMap[str(bucket)][str(keyword)]
total_count += count
finalList.append((str(t), str(total_count), keyword))
t = t+ tick
if finalList == []:
for i in range(t, endTime+tick, tick):
finalList.append((str(i), str(0), keyword))
print "end time", time.time()
print "end time", time.clock()
return finalList
print "end time", time.time()
print "end time", time.clock()
return finalList
def selectRange(self, startTimestamp, endTimestamp, keyword):
[startFileNumber, startBucket] = self.getNames(startTimestamp)
[endFileNumber, endBucket] = self.getNames(endTimestamp)
aggregateCount = 0
#If timestamps span more than a day, we need to ensure that we get all the buckets in the range
for fileNumber in range(startFileNumber, endFileNumber+1):
if fileNumber == startFileNumber:
startB = startBucket
if startFileNumber==endFileNumber:
endB = endBucket
else:
endB = 287 #hardcoding right now, but can call windowsize if we want this to work for different time ranges
elif fileNumber == endFileNumber:
startB = 0
endB = endBucket
else:
startB = 0
endB = 287
for bucketNumber in range(startB, endB+1):
bucketNumber = str(bucketNumber)
if LRU.get(str(fileNumber)) == -1:
with open(str(fileNumber)+'.txt') as data_file:
dataMap = json.load(data_file)
LRU.set(str(fileNumber), dataMap)
else:
dataMap = LRU.get(str(fileNumber))
if bucketNumber in dataMap and str(keyword) in dataMap[bucketNumber]:
aggregateCount+=dataMap[bucketNumber][str(keyword)]
return str(aggregateCount)
def testGetPut(self):
obj = LRU(1)
obj.put(1, 2)
self.assertEqual(obj.get(1), 2)
obj.put(1, 4)
# checkk if value is updated
self.assertEqual(obj.get(1), 4)
# check if default value is returned if key isn't there
self.assertEqual(obj.get(2, "not found"), "not found")
def selectRangeForDisplay(self, startTimestamp, endTimestamp, keyword):
#sample timestamp is 1449186990 (assuming was divided by 1000 already)
print "start Time: ", startTimestamp
if (endTimestamp < startTimestamp):
return []
tick = 5 * 60 #seconds to add - assuming window size is 5 here!
bucketMod = self.setWindow(5)
print "bucketMod", bucketMod
[startFileNumber, startBucket] = self.getNames(startTimestamp) #convert bucket to string
[endFileNumber, endBucket] = self.getNames(endTimestamp)
print "fileNum", startFileNumber, endFileNumber
#If timestamps span more than a day, we need to ensure that we get all the buckets in the range
t = startTimestamp
finalList = []
for fileNumber in range(startFileNumber, endFileNumber+1):
if fileNumber == startFileNumber:
startB = startBucket
if startFileNumber==endFileNumber:
endB = endBucket
else:
endB = bucketMod-1
elif fileNumber == endFileNumber:
startB = 0
endB = endBucket
else:
startB = 0
endB = bucketMod -1
for bucketNumber in range(startB, endB+1):
bucketNumber = str(bucketNumber)
if LRU.get(str(fileNumber)) == -1:
with open(str(fileNumber)+'.txt') as data_file:
try:
dataMap = json.load(data_file)
except:
for i in range(t, endTimestamp+300, 300):
finalList.append((str(i), str(0)))
return finalList
LRU.set(str(fileNumber), dataMap)
else:
dataMap = LRU.get(str(fileNumber))
if bucketNumber in dataMap and str(keyword) in dataMap[bucketNumber]:
count=dataMap[bucketNumber][str(keyword)]
finalList.append((str(t), str(count), keyword))
else:
finalList.append((str(t),str(0), keyword))
t = t+ tick
if finalList == []:
for i in range(t, endTimestamp+300, 300):
finalList.append((str(i), str(0), keyword))
return finalList
return finalList
def select(self, timestamp, keyword):
[filename, bucket] = self.getNames(timestamp)
bucket = str(bucket)
keyword = str(keyword)
#first get the associated page with this data & timestamp
if LRU.get(str(filename)) == -1:
with open(str(filename)+'.txt') as data_file:
dataMap = json.load(data_file)
LRU.set(str(filename), dataMap)
else:
dataMap = LRU.get(str(filename))
if bucket in dataMap and keyword in dataMap[bucket]:
return [timestamp, dataMap[bucket][keyword]]
else:
return [timestamp, 0]
def test_get(self):
obj = LRU('a',1)
obj.put('a')
obj.put('b')
# obj.put('c')
# print(obj.l)
self.assertEqual(obj.get(),False)
def testLRUItemIsActuallyRemoved(self):
obj = LRU(4)
obj.put(1, 1)
obj.put(2, 1)
obj.put(3, 1)
obj.put(4, 1)
obj.put(1, 1) # 2 becomes lru
obj.put(5, 1)
# now get(2) should return none
self.assertEqual(obj.get(2), None)
class LRUTest:
def __init__(self):
self.lru = LRU()
def put(self, key):
return self.lru.put(key)
def get(self):
return self.lru.get()
def get_cache(self):
return self.lru.get_cache()
from LRU import LRU
import random
random_cache_size = random.randrange(10)
print("Initiaizing cache of size", random_cache_size)
cache_obj = LRU(random_cache_size)
# returns None as cache is empty
print("1 ->", cache_obj.get(1))
# returns "not found" as it is the default argument
print("1 ->", cache_obj.get(1, "not found"))
cache_obj.put(1, 2)
# prints 2
print("1 ->", cache_obj.get(1))
#!/usr/bin/env python3
from LRU import LRU
datasource = {
1: "one",
2: "two",
3: "three",
4: "four",
5: "five",
6: "six",
7: "seven",
8: "eight",
9: "nine",
10: "ten"
}
lru = LRU(2, datasource)
print(lru.get(1))
print(lru.get(2))
print(lru.get(3))
print(lru.get(4))
print(lru.get(6))
print(lru.get(3))
print(lru.get(6))
print(lru.get(1))
print(lru.get(2))
print(lru.get(5))
def insert(self,timestamp, keyword, count):
##assume values is coming in the python form:
##[('clinton', 1),('sanders',1)]
##do we want to store individual timestamps as well
filename = timestamp / 86400
tempTime = timestamp / 300
bucket = tempTime % 288
print filename
if not os.path.isfile(str(filename)+'.txt'):
print 'file doesnt exist'
dataMap = {}
for i in range(0,288):
dataMap[i] = {}
with open(str(filename)+'.txt','w') as data_file:
#json.dump(ast.literal_eval(str(dataMap)), data_file)
json.dump(dataMap, data_file)
if LRU.get(str(filename)) == -1:
with open(str(filename)+'.txt') as data_file:
dataMap = json.load(data_file)
LRU.set(str(filename), dataMap)
else:
dataMap = LRU.get(str(filename))
print "current bucket", bucket
print "previous bucket", self.previousBucket
if bucket != self.previousBucket:
self.incrementalCount[timestamp / 300] = {}
for candidate in self.candidateList:
if candidate in dataMap[str(self.previousBucket)]:
count = dataMap[str(self.previousBucket)][candidate]
squaredCount = dataMap[str(self.previousBucket)][candidate] ** 2
else:
count = 0
squaredCount = 0
self.totalCounts[str(candidate)] += count
self.squaredCounts[str(candidate)] += squaredCount
newMean = self.updateMean(self.counts[str(candidate)]+1, self.runningMean[str(candidate)], count)
newVar = self.updateVar(self.counts[str(candidate)]+1, self.totalCounts[str(candidate)], self.squaredCounts[str(candidate)])
self.runningVar[str(candidate)] = newVar
self.runningMean[str(candidate)] = newMean
self.counts[str(candidate)]+=1
if (timestamp/300 -1) not in self.incrementalCount:
self.incrementalCount[timestamp/300][candidate] = 0
else:
self.incrementalCount[timestamp/300][candidate] = self.incrementalCount[timestamp/300 - 1][candidate] +count
self.incrementalCount["lastTime"] = timestamp/300
print("COUNTS: ", self.counts)
print("RUNNING AVERAGE:", self.runningMean)
print("RUNNING VAR:", self.runningVar)
print("INCREMENTAL COUNT", self.incrementalCount)
self.previousBucket = bucket
#print 'dataMap', dataMap#str(dataMap).replace("u\'","\'")
#print "bucket", bucket
keywords = dataMap[str(bucket)]
bucket = str(bucket)
#print 'keywords', keywords
if not keyword in keywords:
print 'not in keyword so adding'
dataMap[bucket][keyword] = count
#print 'dataMap', dataMap
else:
#counts per bucket
dataMap[bucket][keyword]+=count
#to get the aggregate counts for each keyword for a day
if not keyword in dataMap:
dataMap[keyword] = count
else:
dataMap[keyword]+=count
with open(str(filename)+'.txt', 'w') as outfile:
print 'writing to json output'
#print dataMap
json.dump(dataMap, outfile) ## we don't want to load it every time.
return True
