def test_display():
"""Test Linked_List display method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
assert test_list.display() == "(123, 456)"
def test_insert():
"""Test Linked_List insert method."""
from linked_list import Linked_List
from linked_list import Node
test_list = Linked_List()
test_list.insert(data[0])
assert isinstance(test_list.head, Node)
def reversed(self):
_result = Linked_List() # init empty list
current = self._head # init start
while current is not None:
_result.add_head(current._value)
current = current._next # incr
return _result
def test_search():
"""Test Linked_List length method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
assert test_list.search(data[0]) == data[0]
def test_list_head_two_nodes():
list1 = Linked_List()
list1.insert("Mary")
list1.insert("Kyle")
assert list1.size == 2
assert list1.head.node_name == "Kyle"
assert list1.head.node_next.node_name == "Mary"
class Queue:
def __init__(self):
self._lst= Linked_List()
def enqueue(self, datum):
self._lst.insert(datum)
def dequeue(self):
if self._lst.size() > 1:
trace= self._lst.head
while trace.pointer.pointer is not None:
trace= trace.pointer
result= trace.pointer.datum
trace.pointer= None
return result
elif self._lst.size()==1:
result= self._lst.head.datum
self._lst.head= None
return result
else:
raise ValueError("Cannot dequeue an empty queue")
def size(self):
return self._lst.size()
def test_print():
lst = Linked_List()
lst.insert('A')
lst.insert((1, 2, 3))
lst.insert(42)
lst.insert('Bob Dole')
assert str(lst) == "('Bob Dole', 42, (1, 2, 3), 'A')"
def test_insert():
lst= Linked_List()
lst.insert(7)
assert lst.head.datum==7
lst.insert('Sir Sean Connery')
assert lst.head.datum=='Sir Sean Connery'
class Stack:
def __init__(self):
self._lst = Linked_List()
def push(self, datum):
self._lst.insert(datum)
def pop(self):
return self._lst.pop()
def polynomial(a, x, n):
if a >= n:
P = Linked_List()
for i in range(n, 0, -1):
node = a * x ** i
P.add(node)
a -= 1
return P
else:
return ValueError("a>=n")
class Stack:
def __init__(self):
self._lst= Linked_List()
def push(self, datum):
self._lst.insert(datum)
def pop(self):
return self._lst.pop()
def deleteDuplicates(self, head):
if not head:
return None
tracer = head
outputList = Linked_List()
while (tracer.next != None):
if (tracer.val != tracer.next.val):
outputList.AddTail(tracer.val)
tracer = tracer.next
outputList.AddTail(tracer.val)
return outputList.head
def test_str():
a = Linked_List()
print a
a.insert('When A Café')
a.insert('b')
a.insert(2)
print a
assert a.display_prep() == "(2, 'b', 'When A Café')"
def test_print():
lst= Linked_List()
lst.insert('A')
lst.insert((1, 2, 3))
lst.insert(42)
lst.insert('Bob Dole')
assert str(lst) == "('Bob Dole', 42, (1, 2, 3), 'A')"
def test_regular_search():
list1 = Linked_List()
list1.insert("John")
list1.insert("Paul")
list1.insert("George")
list1.insert("Ringo")
searched_node = list1.search("George")
assert searched_node.node_name == "George"
searched_node = list1.search("John")
assert searched_node.node_name == "John"
searched_node = list1.search("Ralph")
assert searched_node is None
def test_remove():
"""Test Linked_List remove method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
test_list.insert(data[1])
test_list.insert(data[2])
test_list.remove(data[1])
assert test_list.size() == 2
def test_find(self):
ll = Linked_List()
ll.append('A')
ll.append('B')
ll.append('C')
assert ll.find(lambda item: item == 'B') == 'B'
assert ll.find(lambda item: item < 'B') == 'A'
assert ll.find(lambda item: item > 'B') == 'C'
assert ll.find(lambda item: item == 'D') is None
class Stack(object):
"""The stack data structure is a composition of the Linked List structure."""
def __init__(self, iterable=None):
"""Initialize stack as a Linked_List-esque object."""
self._container = Linked_List(iterable)
def push(self, val):
"""Use Linked List push method to add one Node to stack."""
self._container.push(val)
def pop(self):
"""Use Linked List pop() method to remove one from stack."""
return self._container.pop()
def create_linked_list(fencers_csv):
''' Creates a sorted linked list from a CSV file. '''
with open(fencers_csv) as csv_file:
fencer_list = Linked_List()
reader = csv.reader(csv_file, delimiter='\t')
for row in reader:
fencer = {
'last_name': row[0].split(',')[0],
'first_name': row[0].split(',')[1],
'team': row[0].split(',')[2],
'rank': row[0].split(',')[3]
}
fencer_list.insert(fencer)
return fencer_list
def test_pop():
list1 = Linked_List()
list1.insert("John")
list1.insert("Paul")
list1.insert("George")
list1.insert("Ringo")
popped = list1.pop()
assert popped.node_name == "Ringo"
assert list1.head.node_name == "George"
assert list1.size == 3
def test_next():
list1 = Linked_List()
list1.insert("John")
list1.insert("Paul")
list1.insert("George")
list1.insert("Ringo")
assert list1.head.node_next.node_next.node_next.node_name == "John"
def check_linked_list_cycle(first_node):
# """Returns True if the linked list is a circular linked list, else
# it returns False.
# >>> check_linked_list_cycle(first_node)
# False
# """
ll = Linked_List()
first_node = ll.first_node()
slow_runner = first_node
fast_runner = first_node
while fast_runner != None and fast_runner.next != None:
slow_runner = slow_runner.next
fast_runner = fast_runner.next.next
if fast_runner == slow_runner:
return True
return False
def check_linked_list_cycle(first_node): # """Returns True if the linked list is a circular linked list, else # it returns False. # >>> check_linked_list_cycle(first_node) # False # """ ll = Linked_List() first_node = ll.first_node() slow_runner = first_node fast_runner = first_node while fast_runner != None and fast_runner.next != None: slow_runner = slow_runner.next fast_runner = fast_runner.next.next if fast_runner == slow_runner: return True return False
def test_prepend(self):
ll = Linked_List()
ll.prepend('C')
assert ll.head.data == 'C'
assert ll.tail.data == 'C'
ll.prepend('B')
assert ll.head.data == 'B'
assert ll.tail.data == 'C'
ll.prepend('A')
assert ll.head.data == 'A'
assert ll.tail.data == 'C'
def test_pop():
lst = Linked_List()
lst.insert(7)
lst.insert('Sir Sean Connery')
val1 = lst.pop()
val2 = lst.pop()
assert val1 == 'Sir Sean Connery'
assert val2 == 7
assert lst.head is None
def __init__(self):
"""
Generates an empty hash-table.
"""
self.table = [Linked_List() for _ in range(4)]
self.hash_size = 2
self.min_size = 1
self.max_size = 4
self.num_keys = 0
self.rand = randrange(1, max_int)
self.word_size = int(log(max_int, 2))
self.h = lambda key: (self.rand * key % max_int) >> (self.word_size -
self.hash_size)
def test():
ll = Linked_List(1)
ll.insert(4)
ll.insert(16)
ll.insert(9)
print(ll.head)
res = reverse_loop(ll.head)
print(res)
print(res.next)
print(res.next.next)
print(res.next.next.next)
def rehash(self):
"""
Rehashes all keys in the hash-table.
"""
self.num_keys = 0
table = self.table
self.table = [Linked_List() for slot in range(self.max_size)]
for slot in table:
element = slot.head
while element:
self.insert(element.key, element.value)
element = element.next
def test_insert():
lst = Linked_List()
lst.insert(7)
assert lst.head.datum == 7
lst.insert('Sir Sean Connery')
assert lst.head.datum == 'Sir Sean Connery'
class Queue:
def __init__(self):
self._lst = Linked_List()
def enqueue(self, datum):
self._lst.insert(datum)
def dequeue(self):
if self._lst.size() > 1:
trace = self._lst.head
while trace.pointer.pointer is not None:
trace = trace.pointer
result = trace.pointer.datum
trace.pointer = None
return result
elif self._lst.size() == 1:
result = self._lst.head.datum
self._lst.head = None
return result
else:
raise ValueError("Cannot dequeue an empty queue")
def size(self):
return self._lst.size()
def test_pop():
lst= Linked_List()
lst.insert(7)
lst.insert('Sir Sean Connery')
val1= lst.pop()
val2= lst.pop()
assert val1=='Sir Sean Connery'
assert val2==7
assert lst.head is None
def __init__(self, link, timeout=10):
"""Creates a socket and binds it to a free, unique port"""
self.link = link
self.results = Linked_List()
self.my_socket = socket.socket()
self.conn_ref = False
# bind socket to free port
ref_count = 0
while True:
self.port = BitcoinSocket.get_port() # autoimcrement
try:
self.my_socket.bind(('',self.port))
break;
except OSError: # if port is not free
pass
# print("os error")
except ConnectionRefusedError:
ref_count += 1
if ref_count > 3:
self.conn_ref = True
break;
# print("conn refused, trying again")
self.my_socket.settimeout(timeout)
def test_size():
lst = Linked_List()
lst.insert(0)
lst.insert(1)
lst.insert(45)
lst.insert('turds')
assert lst.size() == 4
assert lst.head.datum == 'turds'
lst.pop()
lst.pop()
assert lst.size() == 2
assert lst.head.datum == 1
lst.insert('boobies')
assert lst.size() == 3
lst.insert('i am mature')
assert lst.size() == 4
lst.pop()
assert lst.head.datum == 'boobies'
def __init__(self, iterable=None):
"""Initialize stack as a Linked_List-esque object."""
self._container = Linked_List(iterable)
def test_list_head_when_none():
list1 = Linked_List()
list1.insert("Mary")
assert list1.head.node_name == "Mary"
assert list1.size == 1
assert list1.head.node_next is None
def test_remove():
lst= Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.remove(4)
lst.remove('Sir Sean Connery')
assert lst.size()==2
assert str(lst)=="((1, 2, 3), 7)"
lst.remove((1, 2, 3))
assert str(lst)=="(7,)"
def test_search():
lst= Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.insert('Harrison Ford')
n1= lst.search('Sir Sean Connery')
n2= lst.search(7)
assert n1.datum=='Sir Sean Connery'
assert n2.pointer is None
assert lst.search('Batman') is None
# new message to send transaction
to_send = msg_tx()
to_send.tx = the_tx
self.my_socket.send(to_send.to_bytes())
# print("SENT OUR PC BRO TRANSACTION")
return "donedone"
else:
pass
# print("something else: ", msg.command, msg)
return False
if __name__ == "__main__":
bitcoin.SelectParams('mainnet')
linked = Linked_List() # of potential nodes
known_set = set() # docs imply this is a hashset. good nodes
known_bad = set() # offline nodes
version_strings = {} # string : count
# server_ip = "75.132.169.13"
# server_ip = "199.233.246.224"
server_ip = "94.112.102.36"
# server_ip = "95.191.251.158"
# server_ip = "188.230.153.108"
# server_ip = "186.159.101.96"
# server_ip = "76.170.160.69"
# server_ip = "70.15.155.219"
# server_ip = "81.64.219.50"
# server_ip = "73.20.98.44"
def __init__(self, orig = None):
# Can this be done as super().__init__(....) ???
Linked_List.__init__(self, orig)
def test_print():
list1 = Linked_List()
list1.insert("John")
list1.insert("Paul")
list1.insert("George")
list1.insert("Ringo")
assert list1.__str__() == "('Ringo', 'George', 'Paul', 'John')"
list2 = Linked_List()
assert list2.__str__() == "()"
list1.pop()
assert list1.__str__() == "('George', 'Paul', 'John')"
def __init__(self):
self._lst= Linked_List()
def new_empty_ll():
"""Create an empty object of type Stack to be used in test functions."""
from linked_list import Linked_List
this_empty_ll = Linked_List()
return this_empty_ll
# Time Comp: O(n2)
# Space Comp: O(1)
def remove_dupes_1(ll):
curr = ll.head
while curr:
runner = ll.head
prev = ll.head
while runner:
if curr.data is runner.data:
prev.next_node = runner.next_node
else:
prev = prev.next_node
runner = runner.next_node
curr = curr.next_node
L1 = Linked_List()
L1.insert(5)
L1.insert(3)
L1.insert(5)
L1.insert(5)
L1.insert(10)
L1.insert(5)
L1.insert(10)
L1.output()
print("Removing all duplicates...")
# remove_dupes(L1)
# remove_dupes_1(L1)
L1.output()
def test_search():
lst = Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.insert('Harrison Ford')
n1 = lst.search('Sir Sean Connery')
n2 = lst.search(7)
assert n1.datum == 'Sir Sean Connery'
assert n2.pointer is None
assert lst.search('Batman') is None
def test_linked_list():
"""
Code to test each part of the linked list class
"""
# empty()
ll = Linked_List()
assert ll.empty() == True
ll.head = Node(3)
assert ll.empty() == False
# next_is_empty()
assert ll.head.next_is_empty() == True
ll.head.tail = Node(4)
assert ll.head.next_is_empty() == False
# size()
ll.head.tail.tail = Node(5)
assert ll.size() == 3
assert Linked_List().size() == 0
size_one = Linked_List()
size_one.head = Node(18)
assert size_one.size() == 1
# value_at()
assert ll.value_at(0) == 3
assert ll.value_at(1) == 4
assert ll.value_at(2) == 5
assert ll.value_at(3) == "IndexError: Index is too large or incorrect. Should be an integer less than size of linkedlist"
# push_front()
ll.push_front(2)
assert ll.value_at(0) == 2
assert ll.value_at(1) == 3
assert ll.value_at(2) == 4
assert ll.value_at(3) == 5
assert ll.size() == 4
# pop_front()
front_value = ll.pop_front()
assert front_value == 2
assert ll.size() == 3
assert ll.value_at(0) == 3
# push_back()
ll.push_back(6)
assert ll.size() == 4
assert ll.value_at(3) == 6
# pop_back()
back_value = ll.pop_back()
assert ll.size() == 3
assert back_value == 6
# front()
front_value = ll.front()
assert front_value == 3
assert ll.size() == 3
# back()
back_value = ll.back()
assert back_value == 5
assert ll.size() == 3
# insert_at()
ll.insert_at(0, 2)
assert ll.size() == 4
assert ll.value_at(0) == 2
ll.insert_at(1, 2.5)
assert ll.size() == 5
assert ll.value_at(1) == 2.5
assert ll.value_at(2) == 3
# erase()
ll.remove(0)
assert ll.size() == 4
assert ll.value_at(0) == 2.5
ll.remove(1)
assert ll.size() == 3
assert ll.value_at(1) == 4
# value_n_from_end()
n = ll.value_n_from_end(0)
assert n == 5
assert ll.size() == 3
# reverse()
reversed = ll.reverse()
assert reversed.size() == 3
assert reversed.value_at(0) == 5
assert reversed.value_at(1) == 4
assert reversed.value_at(2) == 2.5
# remove_value(value)
reversed.remove_value(4)
assert reversed.size() == 2
assert reversed.value_at(0) == 5
assert reversed.value_at(1) == 2.5
def test_remove():
lst = Linked_List()
lst.insert(7)
lst.insert(4)
lst.insert('Sir Sean Connery')
lst.insert((1, 2, 3))
lst.remove(4)
lst.remove('Sir Sean Connery')
assert lst.size() == 2
assert str(lst) == "((1, 2, 3), 7)"
lst.remove((1, 2, 3))
assert str(lst) == "(7,)"
def test_remove():
list1 = Linked_List()
list1.insert("John")
list1.insert("Paul")
list1.insert("George")
list1.insert("Ringo")
list1.remove("John")
assert list1.head.node_next.node_next.node_next is None
list1.remove("George")
assert list1.size == 2
assert list1.head.node_next.node_name == "Paul"
# assert list1.remove("Pete") == "Node not in list"
with pytest.raises(No_Node_Exception) as excinfo:
list1.remove("Pete")
assert excinfo.value.message == '-1'
list1.remove("Ringo")
def test_init():
lst = Linked_List()
assert lst.head is None
class BitcoinSocket(object):
client_ip = "1.1.1.1" # TODO This value doesn't seem to matter, but we should make sure or use your IP address
# or best case write code to find your public facing IP address
_port_num = 8000 # also, this port is the LAN port, not internet port, so the same issue is here
def get_port(): # NOTE: this is not an instance method
"""In the future this will allow a good way to support parallelization"""
with port_lock:
val = BitcoinSocket._port_num
BitcoinSocket._port_num += 1
return val
def __init__(self, link, timeout=10):
"""Creates a socket and binds it to a free, unique port"""
self.link = link
self.results = Linked_List()
self.my_socket = socket.socket()
self.conn_ref = False
# bind socket to free port
ref_count = 0
while True:
self.port = BitcoinSocket.get_port() # autoimcrement
try:
self.my_socket.bind(('',self.port))
break;
except OSError: # if port is not free
pass
# print("os error")
except ConnectionRefusedError:
ref_count += 1
if ref_count > 3:
self.conn_ref = True
break;
# print("conn refused, trying again")
self.my_socket.settimeout(timeout)
def connect(self):
"""Connect to the destination, returning True on success"""
try:
self.my_socket.connect( (self.link.ip,self.link.port) )
except socket.timeout:
return False
return True
def listen_until_acked(self):
# Send Version packet
self.my_socket.send( self._make_version_pkt().to_bytes() )
ver_rec = False
verack_rec = False
iterations = 0
while not verack_rec and not ver_rec and iterations < 15:
res = self._process_message()
if res == "version":
ver_rec = True
elif res == "verack":
verack_rec = True
if iterations > 13:
print("stuck on ack? tid: ", threading.get_ident(), '\n\ttarget: ', self.link)
iterations += 1
def send_transaction(self):
import createTransaction
tx = createTransaction.make_self_transaction()
inv_msg = msg_inv()
tx_inv = CInv()
tx_inv.type = 1
tx_inv.hash = tx.GetHash()
inv_msg.inv.append(tx_inv)
self.my_socket.send(inv_msg.to_bytes())
iterations = 0
while self._process_message(transaction=tx) != "donedone" and iterations < 50:
pass
if iterations > 45:
print("stuck on send? tid: ", threading.get_ident(), '\n\ttarget: ', self.link)
iterations += 1
# print("leaving send_transaction()")
return tx_inv.hash
def listen_until_addresses(self):
"""Implements the Bitcoin protocol, sending info until it gets an addr message"""
# Try to get addresses
self.my_socket.send(msg_getaddr().to_bytes())
while not self._process_message(): # TODO set timeout or something for multiple addr messages
pass
self.my_socket.close()
def listen_forever(self):
print("starting to listen forever")
while True:
self._process_message()
def get_results(self):
"""Returns a linked list of all new potential nodes (needs pruning)."""
return self.results
def _make_version_pkt(self):
msg = msg_version()
msg.nVersion = 70002
msg.addrTo.ip = self.link.ip
msg.addrTo.port = self.link.port
msg.addrFrom.ip = BitcoinSocket.client_ip
msg.addrFrom.port = self.port
return msg
# ...we don't need to tell people who we know about :)
# def _make_addr_pkt(self, str_addrs ):
# msg = msg_addr()
# addrs = []
# for i in str_addrs:
# addr = CAddress()
# addr.port = 8333
# addr.nTime = int(time.time())
# addr.ip = i
# addrs.append( addr )
# msg.addrs = addrs
# return msg
def _process_message(self, **kwargs):
msg = MsgSerializable.stream_deserialize(Wrapper(self.my_socket))
if msg.command == b"version": # TODO conglomerate these message strings into a dictionary
# Send Verack
# print('version: ', msg.strSubVer, msg.nVersion)
self.my_socket.send( msg_verack().to_bytes() )
return "version"
elif msg.command == b"verack":
# print("verack: ", msg)
return "verack"
elif msg.command == b"inv":
pass
# print("inv: ", msg.inv)
# print(dir(msg))
# print(type(msg.inv))
elif msg.command == b"ping":
# print("ping: ", msg)
self.my_socket.send(msg_pong(msg.nonce).to_bytes())
elif msg.command == b"getheaders":
pass
# print("getheaders received ")
elif msg.command == b"addr": # TODO this needs multi-message support
# print("addr: size ", len(msg.addrs))
for address in msg.addrs:
node = Link(address.ip, address.port)
self.results.add(node)
return True
elif msg.command == b"getdata":
# print("getdata: ", msg.inv)
if 'transaction' not in kwargs:
return False
the_tx = kwargs['transaction']
for request in msg.inv:
if request.hash == the_tx.GetHash():
print(threading.current_thread().name,"sending tx: ", self.link)
# new message to send transaction
to_send = msg_tx()
to_send.tx = the_tx
self.my_socket.send(to_send.to_bytes())
# print("SENT OUR PC BRO TRANSACTION")
return "donedone"
else:
pass
# print("something else: ", msg.command, msg)
return False
def test_size():
lst= Linked_List()
lst.insert(0)
lst.insert(1)
lst.insert(45)
lst.insert('turds')
assert lst.size()==4
assert lst.head.datum=='turds'
lst.pop()
lst.pop()
assert lst.size()==2
assert lst.head.datum==1
lst.insert('boobies')
assert lst.size()==3
lst.insert('i am mature')
assert lst.size()==4
lst.pop()
assert lst.head.datum=='boobies'
from RemoveDuplicatesfromSortedList import Solution
from linked_list import ListNode, Linked_List
a = Linked_List()
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(1)
a.AddTail(2)
a.AddTail(3)
a.AddTail(3)
temp = Solution()
tracer = temp.deleteDuplicates(a.head)
while tracer.next != None:
print(tracer.val)
tracer = tracer.next
print(tracer.val)
def test_pop():
"""Test Linked_List pop method."""
from linked_list import Linked_List
test_list = Linked_List()
test_list.insert(data[0])
assert test_list.pop().data == data[0]
