class Peer(object):
def __init__(self, peer_id, socket):
self.peer_id = peer_id
self.socket = socket
self.pending_requests = {} # req_id -> ValueEvent
self.incoming_buffer = msgpack.Unpacker()
self.outgoing_buffer = CircularBuffer(OUTGOING_PEER_BUFFER_SIZE)
self.lock = threading.Lock()
def close(self):
try:
self.lock.release()
except threading.ThreadError:
pass # lock may not have been acquired.
self.socket.close()
def add_request(self, req_id, request_bytes, value_event):
"""Add ValueEvent to pending requests and write request_bytes to
outgoing_buffer"""
with self.lock:
self.pending_requests[req_id] = value_event
self.outgoing_buffer.write(request_bytes)
def handle_response(self, response):
"""Extract req_id from response and check if there is a pending request
for the req_id. If so set the value.
"""
with self.lock:
req_id, status, message = response
if req_id in self.pending_requests: # request may have timed out
self.pending_requests[req_id].set((status, message))
def remove_request(self, req_id):
with self.lock:
del self.pending_requests[req_id]
class Peer(object):
def __init__(self, peer_id, socket):
self.peer_id = peer_id
self.socket = socket
self.pending_requests = {} # req_id -> ValueEvent
self.incoming_buffer = msgpack.Unpacker()
self.outgoing_buffer = CircularBuffer(OUTGOING_PEER_BUFFER_SIZE)
self.lock = threading.Lock()
def close(self):
try:
self.lock.release()
except threading.ThreadError:
pass # lock may not have been acquired.
self.socket.close()
def add_request(self, req_id, request_bytes, value_event):
"""Add ValueEvent to pending requests and write request_bytes to
outgoing_buffer"""
with self.lock:
self.pending_requests[req_id] = value_event
self.outgoing_buffer.write(request_bytes)
def handle_response(self, response):
"""Extract req_id from response and check if there is a pending request
for the req_id. If so set the value.
"""
with self.lock:
req_id, status, message = response
if req_id in self.pending_requests: # request may have timed out
self.pending_requests[req_id].set((status, message))
def remove_request(self, req_id):
with self.lock:
del self.pending_requests[req_id]
def __init__(self, peer_id, socket):
self.peer_id = peer_id
self.socket = socket
self.pending_requests = {} # req_id -> ValueEvent
self.incoming_buffer = msgpack.Unpacker()
self.outgoing_buffer = CircularBuffer(OUTGOING_PEER_BUFFER_SIZE)
self.lock = threading.Lock()
def test_reading_empty_buffer_should_fail(self):
buf = CircularBuffer(1)
with self.assertRaises(BufferError) as err:
buf.read()
self.assertEqual(type(err.exception), BufferEmptyException)
self.assertEqual(err.exception.args[0], "Circular buffer is empty")
def test_read_back_oldest_item(self):
buf = CircularBuffer(3)
buf.write('1')
buf.write('2')
buf.read()
buf.write('3')
buf.read()
self.assertEqual('3', buf.read())
def test_init(self):
c = CircularBuffer(3)
assert c.size == 0
assert c.list == [None, None, None]
CircVal = CircularBuffer(2)
assert CircVal.size == 0
assert CircVal.list == [None, None]
def test_init(self): c = CircularBuffer() assert c.size == 0 assert c.max_size == 12 assert c.elements == [None, None, None, None, None, None, None, None, None, None, None, None] c = CircularBuffer(4) assert c.size == 0 assert c.max_size == 4 assert c.elements == [None, None, None, None]
def __init__(self, fixed_size):
self.vs1 = WebcamVideoStream(src=0) #For anylizing
self.vs1.start()
self.vs2 = WebcamVideoStream(src=0) #For anylizing
self.vs2.start()
self.cb = CircularBuffer(fixed_size)
self.stopped = False
self.current_stream = (None, None)
self.disp = None
self.haptic = None
def test_enqueue_full(self):
q = CircularBuffer(iterable=['A', 'B', 'C', 'D', 'E', 'F', 'G'])
assert q.length() == 7
assert q.enqueue('H') == None
assert q.length() == 8
assert q.is_full() is True
assert q.enqueue('I') == 'A'
assert q.length() == 8
assert q.is_full() is True
def test_overwrite_full_buffer(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
buf.overwrite('A')
self.assertEqual('2', buf.read())
self.assertEqual('A', buf.read())
with self.assertRaises(BufferEmptyException):
buf.read()
def __init__(self, address):
self.address = address
self.window = CircularBuffer(
60) # Store last 60 seconds of traffic stats
self.requests_mean = 0
self.requests_stdev = 0
self.clients_mean = 0
self.clients_stdev = 0
# Store current second of traffic stats:
self.current_ts = 0
self.current_requests = 0
self.current_clients = set()
self.is_attack = False
def _full_buffer(self):
cb = CircularBuffer(5)
cb.add_to_end('a')
cb.add_to_end('b')
cb.add_to_end('c')
cb.add_to_end('d')
cb.add_to_end('e')
return cb
def test_read_back_oldest_item(self):
buf = CircularBuffer(3)
buf.write('1')
buf.write('2')
self.assertEqual(buf.read(), '1')
buf.write('3')
self.assertEqual(buf.read(), '2')
self.assertEqual(buf.read(), '3')
def test_read_position_is_maintained_across_multiple_writes(self):
buf = CircularBuffer(3)
buf.write('1')
buf.write('2')
self.assertEqual(buf.read(), '1')
buf.write('3')
self.assertEqual(buf.read(), '2')
self.assertEqual(buf.read(), '3')
def test_read_position_is_maintained_even_across_multiple_writes(self):
buf = CircularBuffer(3)
buf.write("1")
buf.write("2")
self.assertEqual(buf.read(), "1")
buf.write("3")
self.assertEqual(buf.read(), "2")
self.assertEqual(buf.read(), "3")
def __init__(self,
row1=23,
row2=19,
row3=18,
row4=26,
col1=16,
col2=17,
col3=21,
col4=22):
self.rows = [None] * 4
self.cols = [None] * 4
self.cb = CircularBuffer(32)
self.row_pins = [row1, row2, row3, row4]
self.col_pins = [col1, col2, col3, col4]
for i in range(4):
print("self.rows[%d]: %d" % (i, self.row_pins[i]))
for i in range(4):
print("self.cols[%d]: %d" % (i, self.col_pins[i]))
# set all pins to input with pull_up
for row in range(4):
self.rows[row] = Pin(self.row_pins[row], Pin.OUT)
self.rows[row].off() # set the level to zero
for col in range(4):
self.cols[col] = Pin(self.col_pins[col], Pin.IN, Pin.PULL_UP)
self.cols[col].irq(handler=None)
self.cols[col].irq(trigger=Pin.IRQ_FALLING,
handler=self.key_change)
def __init__(self, peer_id, socket):
self.peer_id = peer_id
self.socket = socket
self.pending_requests = {} # req_id -> ValueEvent
self.incoming_buffer = msgpack.Unpacker()
self.outgoing_buffer = CircularBuffer(OUTGOING_PEER_BUFFER_SIZE)
self.lock = threading.Lock()
def test_items_cleared_out_of_buffer_can_t_be_read(self):
buf = CircularBuffer(1)
buf.write("1")
buf.clear()
with self.assertRaises(BufferError) as err:
buf.read()
self.assertEqual(type(err.exception), BufferEmptyException)
self.assertEqual(err.exception.args[0], "Circular buffer is empty")
def test_overwrite_replaces_oldest_item(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
buf.overwrite('3')
self.assertEqual(buf.read(), '2')
self.assertEqual(buf.read(), '3')
def test_overwrite_replaces_the_oldest_item_on_full_buffer(self):
buf = CircularBuffer(2)
buf.write("1")
buf.write("2")
buf.overwrite("3")
self.assertEqual(buf.read(), "2")
self.assertEqual(buf.read(), "3")
def main():
file = open("books.txt", 'r')
books = file.readlines()
file.close()
file_name = "raw_corpus.txt"
n = 4
sentence = list()
text = load_words(file_name)
current_words = CircularBuffer(n)
for i in range(n - 1):
current_words.enqueue(text[i].lower())
new_text = text[n - 1:]
markov = {}
for i in range(len(new_text) - n):
current_words.enqueue(new_text[i].lower())
key = tuple(current_words.items())
if key not in markov:
markov[key] = Dictogram()
print(key)
print(markov[key])
print(i)
markov[key].add_count(new_text[i + 1], 1)
for key in markov:
print("key: " + str(key))
print(markov[key])
pickle.dump(markov, open("save.p", "wb"))
def test_write_and_read_back_multiple_items(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
self.assertEqual('1', buf.read())
self.assertEqual('2', buf.read())
with self.assertRaises(BufferEmptyException):
buf.read()
def test_each_item_may_only_be_read_once(self):
buf = CircularBuffer(1)
buf.write("1")
self.assertEqual(buf.read(), "1")
with self.assertRaises(BufferError) as err:
buf.read()
self.assertEqual(type(err.exception), BufferEmptyException)
self.assertEqual(err.exception.args[0], "Circular buffer is empty")
def test_init_max_size_greater_than_iterable(test):
q = CircularBuffer(max_size=4,
iterable=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
assert q.length() == 4
assert q.is_empty() is False
assert q.is_full() is True
assert q.front() == 'E'
def test_overwrite_replaces_oldest_item(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
buf.overwrite('3')
self.assertEqual(buf.read(), '2')
self.assertEqual(buf.read(), '3')
def test_full_buffer_can_t_be_written_to(self):
buf = CircularBuffer(1)
buf.write("1")
with self.assertRaises(BufferError) as err:
buf.write("2")
self.assertEqual(type(err.exception), BufferFullException)
self.assertEqual(err.exception.args[0], "Circular buffer is full")
def get_word_list(text, word_to_find, n):
to_return = list()
current_words = CircularBuffer(n)
for i in range(0, n - 1):
current_words.enqueue(text[i].lower())
index = 0
for i in range(0, len(text) - n + 1):
current_words.enqueue(text[i].lower())
compare = tuple(current_words.items())
if (compare == word_to_find):
to_return.append(text[index + 1])
index += 1
return to_return
def create_dict_of_dict(self, text):
"""
Creating a dictionary of {(current_tuple):{next_type: 1}} structure.
"""
current_words = CircularBuffer(self.order)
for i in range(self.order - 1):
current_words.enqueue(text[i].lower())
new_text = text[self.order - 1:]
for i in range(len(new_text) - self.order):
current_words.enqueue(new_text[i].lower())
key = tuple(current_words.items())
if key not in self:
self[key] = Dictogram()
self[key].add_count(new_text[i + 1], 1)
def generate_random_sentence(self, text, sentence_length=12):
"""
Generating a random sentence from given corpus using markov chains,
returning as a list.
"""
sentence = ""
start_index = random.randrange(len(text) - self.order)
current = CircularBuffer(self.order)
for i in range(self.order):
current.enqueue(text[start_index + i])
for i in range(sentence_length):
key = tuple(current.items())
new_word = sample_dictionary(self[key])
sentence += " " + new_word
current.enqueue(new_word)
sentence += "."
return sentence
def _limit(self, rate: int, period: timedelta, limit_name: str,
unique_id: str) -> bool:
"""
Tries to record an access to the endpoint in a database. The database
limites the number of entries up to the rate limit, and consequently a
failure to add the access to the database indicates that access to the
endpoint should fail. Returns True on success.
rate -- the rate limit
period -- the time period over which the rate limit applies (timedelta)
endpoint_name -- the name of the endpoint or shared rate limit to which
the rate limit applies
unique_id -- a unique identifier for the user accessing the endpoint
"""
# Create a database for this endpoint if it doesn't exist
if not limit_name in databases:
databases[limit_name] = {}
database = databases[limit_name]
# Create an buffer and lock for this user if it doesn't exist
if not unique_id in database:
database[unique_id] = {
'buffer': CircularBuffer(rate),
'lock': Lock()
}
cbuffer = database[unique_id]['buffer']
lock = database[unique_id]['lock']
now = datetime.now()
with lock:
self._clear_buffer(cbuffer, period, now)
succeeded = self._record_access(cbuffer, now)
logging.info(limit_name + ' accessed by ' + unique_id + ' ' +
str(cbuffer.size) + ' times in the last ' +
str(period) + 'h')
if not succeeded:
s = self._seconds_remaining(now, period, cbuffer)
abort(429, f"Rate limit exceeded. Try again in #{s} seconds")
def test_write_full_buffer(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
with self.assertRaises(BufferFullException):
buf.write('A')
def test_write_and_read_back_multiple_items_ordered(self):
buf = CircularBuffer(2)
buf.write('1')
buf.write('2')
self.assertEqual(buf.read(), '1')
self.assertEqual(buf.read(), '2')
def test_alternate_write_and_read(self):
buf = CircularBuffer(2)
buf.write('1')
self.assertEqual('1', buf.read())
buf.write('2')
self.assertEqual('2', buf.read())
def test_overwrite_replaces_oldest_remaining_item(self):
buf = CircularBuffer(3)
buf.write('1')
buf.write('2')
buf.write('3')
self.assertEqual(buf.read(), '1')
buf.write('4')
buf.overwrite('5')
self.assertEqual(buf.read(), '3')
self.assertEqual(buf.read(), '4')
self.assertEqual(buf.read(), '5')
def test_overwrite_non_full_buffer(self):
buf = CircularBuffer(2)
buf.write('1')
buf.overwrite('2')
self.assertEqual(buf.read(), '1')
self.assertEqual(buf.read(), '2')
def test_clearing_buffer(self):
buf = CircularBuffer(3)
for c in '123':
buf.write(c)
buf.clear()
with self.assertRaises(BufferEmptyException):
buf.read()
buf.write('1')
buf.write('2')
self.assertEqual('1', buf.read())
buf.write('3')
self.assertEqual('2', buf.read())
is_init = False
niveau_count = 0
platau_count = 0
print "signal walking"
for i in range(1, buffer.size-1):
ksum = 0
for k in range(-1,2):
w = -k
ksum += buffer.value(i+k) * w
print ksum
if is_init:
diff = ksum - last_ksum
last_ksum = ksum
is_init = True
size = 10
data = [0 for i in range(size)]
buffer = CircularBuffer(data, size)
for i in range(25):
#buffer.add((i-5)**2.0)
buffer.add(i)
peak_detect(buffer)
def test_write_and_read_back_one_item(self):
buf = CircularBuffer(1)
buf.write('1')
self.assertEqual('1', buf.read())
with self.assertRaises(BufferEmptyException):
buf.read()
def test_read_empty_buffer(self):
buf = CircularBuffer(1)
with self.assertRaises(BufferEmptyException):
buf.read()
def test_cant_write_to_full_buffer(self):
buf = CircularBuffer(1)
buf.write('1')
with self.assertRaisesWithMessage(BufferFullException):
buf.write('2')
def test_clear_does_nothing_on_empty_buffer(self):
buf = CircularBuffer(1)
buf.clear()
buf.write('1')
self.assertEqual(buf.read(), '1')
def test_clearing_buffer(self):
buf = CircularBuffer(1)
buf.write('1')
buf.clear()
with self.assertRaisesWithMessage(BufferEmptyException):
buf.read()
def test_clear_free_buffer_for_write(self):
buf = CircularBuffer(1)
buf.write('1')
buf.clear()
buf.write('2')
self.assertEqual(buf.read(), '2')
def test_alternate_read_and_overwrite(self):
buf = CircularBuffer(5)
for c in '123':
buf.write(c)
buf.read()
buf.read()
buf.write('4')
buf.read()
for c in '5678':
buf.write(c)
buf.overwrite('A')
buf.overwrite('B')
self.assertEqual('6', buf.read())
self.assertEqual('7', buf.read())
self.assertEqual('8', buf.read())
self.assertEqual('A', buf.read())
self.assertEqual('B', buf.read())
with self.assertRaises(BufferEmptyException):
buf.read()
def test_read_just_written_item(self):
buf = CircularBuffer(1)
buf.write('1')
self.assertEqual(buf.read(), '1')
