matching engine

Author: mohammadoshkooh

heap.py

@@ -0,0 +1,52 @@
+class Heap:
+
+    def heapify(self, heap, n, i, heap_type):
+        """
+
+        :param heap_type: max or min
+        :param heap:
+        :param n: number of nodes
+        :param i: current node
+        :return:
+        """
+        largest = i  # Initialize largest as root
+        left = 2 * i + 1
+        right = 2 * i + 2
+
+        if heap_type == 'max':
+            # See if left child of root exists and is greater than root
+            if left < n and heap[largest] > heap[left]:
+                largest = left
+
+            # See if right child of root exists and is greater than root
+            if right < n and heap[largest] > heap[right]:
+                largest = right
+
+        elif heap_type == 'min':
+            # See if left child of root exists and is greater than root
+            if left < n and heap[largest] < heap[left]:
+                largest = left
+
+            # See if right child of root exists and is greater than root
+            if right < n and heap[largest] < heap[right]:
+                largest = right
+
+        # Change root, if needed
+        if largest != i:
+            heap[i], heap[largest] = heap[largest], heap[i]  # swap
+
+            # Heapify the root
+            self.heapify(heap, n, largest, heap_type)
+
+    def heapsort(self, heap, heap_type):
+        """ Create a sorted heap"""
+        length = len(heap)
+
+        # Build a max heap.
+        for i in range(length // 2 - 1, -1, -1):
+            self.heapify(heap, length, i, heap_type)
+
+        # One by one extract elements
+        for i in range(length - 1, 0, -1):
+            heap[i], heap[0] = heap[0], heap[i]  # swap
+            self.heapify(heap, i, 0, heap_type)

main.py

@@ -0,0 +1,17 @@
+# This is a sample Python script.
+
+# Press Shift+F10 to execute it or replace it with your code.
+# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
+
+
+def print_hi(name):
+    # Use a breakpoint in the code line below to debug your script.
+    print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.
+
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+    print_hi('PyCharm')
+
+
+# See PyCharm help at https://www.jetbrains.com/help/pycharm/

matching_engine.py

@@ -0,0 +1,66 @@
+import heapq
+import json
+
+from heap import Heap
+
+
+class MatchingEngine():
+
+    def __init__(self, **kwargs):
+        # create a heap instance
+        self.heap = Heap()
+
+        # Creating empty heap
+        super().__init__(**kwargs)
+        self.seller_min_heap = []  # min heap
+        heapq.heapify(self.seller_min_heap)
+
+        self.buyers_max_heap = []  # max heap
+        heapq.heapify(self.buyers_max_heap)
+
+        # load
+        with open('app/api/sellers_data.json') as file:
+            sellers_data = json.load(file)
+            for element in sellers_data:
+                heapq.heappush(self.seller_min_heap, (element.get('price'), element))
+
+        with open('app/api/buyers_data.json') as file:
+            buyers_data = json.load(file)
+            for element in buyers_data:
+                heapq.heappush(self.buyers_max_heap, (element.get('price'), element))
+
+        self.heap.heapsort(self.buyers_max_heap, heap_type='max')
+        self.heap.heapsort(self.seller_min_heap, heap_type='min')
+
+    def matching_engine(self, data):
+        request_type = data['type']
+        current_heap = self.seller_min_heap if request_type == 'sell' else self.buyers_max_heap
+        other_heap = self.buyers_max_heap if request_type == 'sell' else self.seller_min_heap
+
+        def comparison():
+            if request_type == 'sell':
+                return other_heap[0][1].get('price') >= data['price']
+            elif request_type == 'buy':
+                return other_heap[0][1].get('price') <= data['price']
+
+        while other_heap[0][1].get('amount') > 0:
+            if comparison():
+                if other_heap[0][1].get('amount') <= data['amount']:
+                    data['amount'] -= other_heap[0][1].get('amount')
+                    heapq.heappop(other_heap)
+                else:
+                    other_heap[0][1].update(
+                        amount=other_heap[0][1].get('amount') - data['amount'])
+                    break
+            else:
+                heapq.heappush(current_heap, (data['price'], data))
+                self.heap.heapsort(current_heap, heap_type='max')
+                break
+
+    @staticmethod
+    def get_data(self):
+        serialized_data = input()
+        data = serialized_data
+        data['amount'] = float(data['amount'])
+        self.matching_engine(data)
+

test.py

@@ -0,0 +1,17 @@
+import requests
+
+# while True:
+#     api_url = "http://127.0.0.1:8000/api/test/"
+#     response = requests.get(api_url)
+#     print(response.text)
+
+
+from fastapi import FastAPI
+
+app = FastAPI()
+
+
+@app.get("/")
+async def root():
+    print('f')
+    return {"message": "Hello World"}