tx_ordering works for a testcase

Author: kdonthi

ordering.py

@@ -1,4 +1,4 @@
-from statistics import mode
+import statistics
 
 
 class Tx:
@@ -15,20 +15,28 @@ def __repr__(self):
 
 
 class CausalOrdering:
-    def order(self, nodes_vs_transaction_times):
-        assert (len(nodes_vs_transaction_times) != 0)
-        tx_sorted_by_timestamp = self.sort_tx_by_timestamp(nodes_vs_transaction_times)
-        tx_list = self.get_tx_list(nodes_vs_transaction_times)
-        return self.tx_ordering(tx_sorted_by_timestamp, tx_list)
+    def order(self, nodes_vs_tx_received):
+        assert (len(nodes_vs_tx_received) != 0)
+        self.sort_tx_by_timestamp(nodes_vs_tx_received)
+        self.extract_content(nodes_vs_tx_received)
+        tx_list = self.get_unique_tx_list(nodes_vs_tx_received)
+        return self.tx_ordering(nodes_vs_tx_received, tx_list)
 
-    def sort_tx_by_timestamp(self, nodes_vs_tx_times):
-        for node in nodes_vs_tx_times:
-            assert (len(nodes_vs_tx_times[node]) != 0)
-            nodes_vs_tx_times[node].sort(key=lambda tx: tx.timestamp)
+    def sort_tx_by_timestamp(self, nodes_vs_tx_received):
+        for node in nodes_vs_tx_received:
+            assert (len(nodes_vs_tx_received[node]) != 0)
+            nodes_vs_tx_received[node].sort(key=lambda tx: tx.timestamp)
 
-    def get_tx_list(self, nodes_vs_tx_times):
-        for node in nodes_vs_tx_times:
-            return [tx.content for tx in nodes_vs_tx_times[node]]
+    def extract_content(self, nodes_vs_tx_received):
+        for node in nodes_vs_tx_received:
+            nodes_vs_tx_received[node] = [tx.content for tx in nodes_vs_tx_received[node]]  # rename nodes_vs_tx_times
+
+    def get_unique_tx_list(self, nodes_vs_tx_received):
+        nodes_set = set()
+        for node in nodes_vs_tx_received:
+            for tx in nodes_vs_tx_received[node]:
+                nodes_set.add(tx)
+        return list(nodes_set)
 
     def tx_ordering(self, tx_id_ordered_by_timestamp, node_list):
         first_tx = self.first_tx(tx_id_ordered_by_timestamp)
@@ -37,25 +45,24 @@ def tx_ordering(self, tx_id_ordered_by_timestamp, node_list):
         tx_list = [first_tx]
         while node_list:
             added = False
-            connections = self.get_most_popular_connection_to(tx_to_connect, tx_id_ordered_by_timestamp)
+            connections = self.get_upcoming_connection_to(tx_to_connect, tx_id_ordered_by_timestamp)
             for connection in connections:
                 tx, _ = connection
                 if tx not in tx_list:
                     tx_list.append(tx)
-                    node_list.pop(node_list.index(first_tx))
+                    node_list.remove(tx)
                     tx_to_connect = tx
                     added = True
                     break
             if not added:
                 tx_list.append(node_list[0])
                 tx = node_list.pop(0)
                 tx_to_connect = tx
-
-        return first_tx.content
+        return tx_list
 
     def first_tx(self, tx_id_ordered_by_timestamp):
-        first_tx_list = [tx_id_ordered_by_timestamp[tx][0].content for tx in tx_id_ordered_by_timestamp]
-        return mode(first_tx_list)
+        first_tx_list = [tx_id_ordered_by_timestamp[tx][0] for tx in tx_id_ordered_by_timestamp]
+        return statistics.mode(first_tx_list)
 
     def get_upcoming_connection_to(self, from_tx, ordered_tx_lists):
         # what if all connections are to one at end and the one at the end doesn't have any other connections?
@@ -72,7 +79,7 @@ def get_upcoming_connection_to(self, from_tx, ordered_tx_lists):
                     tx_to_count_dict[next_elem] = 1
                 else:
                     tx_to_count_dict[next_elem] += 1
-        return tx_count.items().sort(key=lambda i, j: j, reverse=True)
+        return sorted(list(tx_to_count_dict.items()), key=lambda i: i[1], reverse=True)
 
 
 class AequitasOrdering: