Bug Fixes hopefully

Transaction.py

+from enum import Enum
+from dataclasses import dataclass
 
 class TransactionType(Enum):
     DEPOSIT = 1

TransactionExecutor.py

 from collections import defaultdict
-from dataclasses import dataclass
-from enum import Enum
 from Transaction import Transaction, TransactionType
 
 class InvalidTransactionError(Exception):

TrasactionDeliverer.py

-from dataclasses import dataclass
-from MessageServer import start_server
+from dataclasses import dataclass, replace
 from Messages import AgreedPriorityMessage, ProposedPriorityMessage, TransactionMessage
 import threading
 import socket
@@ -10,13 +9,13 @@ from TransactionExecutor import TransactionExecutor
 @dataclass(order=True)
 class _Transaction_Message_Queue_Item:
     priority: int
+    proposer: str
     transaction_message: TransactionMessage
     priority_confirmations: int = None
 
 class TransactionDeliverer:
     def __init__(self, client_names, addresss, ports) -> None:
-        #bring server up
-        self.serverThread = threading.Thread(target=start_server, agrs=(self, addresss[0], ports[0]))
+
         #make client connections
         self.client_sockets : dict[str, socket.socket] = {}
         for cn, ad, pt in zip(client_names[1:], addresss[1:], ports[1:]):
@@ -30,20 +29,20 @@ class TransactionDeliverer:
         self.transactions_queue: list[_Transaction_Message_Queue_Item] = []
         self.transactions_id_map: dict[str, _Transaction_Message_Queue_Item] = {}
 
-        self.node_name = client_names[0]
+        self.node_name: str = client_names[0]
     
     def new_transaction_message(self, transaction_message: TransactionMessage):
         proposed_priority = self.next_priority
         self.next_priority += 1
 
-        queue_item = _Transaction_Message_Queue_Item(proposed_priority, transaction_message, 1)
+        queue_item = _Transaction_Message_Queue_Item(proposed_priority, self.node_name, transaction_message, 1)
         self.transactions_queue.append(queue_item)
         self.transactions_queue.sort()
         self.transactions_id_map[transaction_message.id] = queue_item
 
         for client_name, sock in self.client_sockets.items():
-            proposed_priority_message = ProposedPriorityMessage(self.node_name, client_name,transaction_message.id, proposed_priority)
-            sock.sendall(pickle.dumps(proposed_priority_message))
+            to_send_transaction_message = replace(transaction_message, receiver=client_name)
+            sock.sendall(pickle.dumps(to_send_transaction_message))
         
         
     def process_transaction_message(self, transaction_message: TransactionMessage):
@@ -56,19 +55,22 @@ class TransactionDeliverer:
             )
         )
 
-        queue_item = _Transaction_Message_Queue_Item(proposed_priority, transaction_message, 1)
+        queue_item = _Transaction_Message_Queue_Item(proposed_priority, self.node_name, transaction_message, 1)
         self.transactions_queue.append(queue_item)
         self.transactions_queue.sort()
         self.transactions_id_map[transaction_message.id] = queue_item
 
 
-    def process_proposed_priority_message(self, proposed_priority_message : ProposedPriorityMessage):
+    def process_proposed_priority_message(self, proposed_priority_message: ProposedPriorityMessage):
         queue_item = self.transactions_id_map[proposed_priority_message.transaction_ID]
-        queue_item.priority = max(queue_item.priority, proposed_priority_message.proposed_priority)
+        queue_item.priority, queue_item.proposer = max(
+            (queue_item.priority, queue_item.proposer),
+            (proposed_priority_message.proposed_priority, proposed_priority_message.sender)
+        )
         self.transactions_queue.sort()
         queue_item.priority_confirmations+=1
 
-        if queue_item.priority_confirmations==len(self.client_names):
+        if queue_item.priority_confirmations==len(self.client_sockets):
             for client_name, sock in self.client_sockets.items():
                 agreed_priority_message = AgreedPriorityMessage(self.node_name,client_name,proposed_priority_message.transaction_ID,queue_item.priority)
                 sock.sendall(pickle.dumps(agreed_priority_message))