Trading Simulator in Python With Algorithmic Traders.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "44faf262",
   "metadata": {},
   "source": [
    "# Trading Simulator in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bacea12",
   "metadata": {},
   "source": [
    "## Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bcbd4abd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from collections import deque, namedtuple\n",
    "from bisect import insort\n",
    "import pandas as pd\n",
    "import simplefix\n",
    "import socket\n",
    "import time\n",
    "import threading\n",
    "import logging\n",
    "import random\n",
    "import yfinance as yf\n",
    "import statistics\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.layers import TextVectorization\n",
    "from newsapi import NewsApiClient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abbee62b",
   "metadata": {},
   "source": [
    "## Implementing Order Book Functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb62d239",
   "metadata": {},
   "outputs": [],
   "source": [
    "Order = namedtuple('Order', ['id', 'price', 'quantity', 'side', 'type', 'symbol'])\n",
    "\n",
    "class OrderBook:\n",
    "    def __init__(self):\n",
    "        self.bids = {}  # Key: Price, Value: deque of Orders (bid side)\n",
    "        self.asks = {}  # Key: Price, Value: deque of Orders (ask side)\n",
    "        self.order_map = {}  # Key: Order ID, Value: (Order, Price level in bids/asks)\n",
    "\n",
    "    def add_order(self, order):\n",
    "        \"\"\"Add a new order to the order book.\"\"\"\n",
    "        if order.side == 'buy':\n",
    "            if order.price not in self.bids:\n",
    "                self.bids[order.price] = deque()\n",
    "            self.bids[order.price].append(order)\n",
    "        else:\n",
    "            if order.price not in self.asks:\n",
    "                self.asks[order.price] = deque()\n",
    "            self.asks[order.price].append(order)\n",
    "        \n",
    "        # Keep track of orders\n",
    "        self.order_map[order.id] = order\n",
    "\n",
    "    def remove_order(self, order_id):\n",
    "        \"\"\"Remove an order from the order book.\"\"\"\n",
    "        if order_id in self.order_map:\n",
    "            order = self.order_map[order_id]\n",
    "            if order.side == 'buy':\n",
    "                self.bids[order.price].remove(order)\n",
    "                if not self.bids[order.price]:\n",
    "                    del self.bids[order.price]\n",
    "            else:\n",
    "                self.asks[order.price].remove(order)\n",
    "                if not self.asks[order.price]:\n",
    "                    del self.asks[order.price]\n",
    "            del self.order_map[order_id]\n",
    "\n",
    "    def modify_order(self, order_id, new_quantity):\n",
    "        \"\"\"Modify an existing order's quantity.\"\"\"\n",
    "        if order_id in self.order_map:\n",
    "            order = self.order_map[order_id]\n",
    "            self.remove_order(order_id)\n",
    "            modified_order = order._replace(quantity=new_quantity)\n",
    "            self.add_order(modified_order)\n",
    "\n",
    "    def get_best_bid(self):\n",
    "        \"\"\"Get the highest bid price.\"\"\"\n",
    "        if self.bids:\n",
    "            return max(self.bids)\n",
    "        return None\n",
    "\n",
    "    def get_best_ask(self):\n",
    "        \"\"\"Get the lowest ask price.\"\"\"\n",
    "        if self.asks:\n",
    "            return min(self.asks)\n",
    "        return None\n",
    "\n",
    "    def cancel_order(self, order_id):\n",
    "        \"\"\"Cancel an existing order.\"\"\"\n",
    "        if order_id in self.order_map:\n",
    "            self.remove_order(order_id)\n",
    "            print(f\"Order {order_id} has been cancelled.\")\n",
    "        else:\n",
    "            print(f\"Order {order_id} not found for cancellation.\")\n",
    "            \n",
    "    def modify_order(self, order_id, new_quantity=None, new_price=None):\n",
    "        \"\"\"Modify an existing order's quantity and/or price.\"\"\"\n",
    "        if order_id in self.order_map:\n",
    "            order = self.order_map[order_id]\n",
    "            self.remove_order(order_id)\n",
    "            if new_quantity is not None:\n",
    "                order = order._replace(quantity=new_quantity)\n",
    "            if new_price is not None:\n",
    "                order = order._replace(price=new_price)\n",
    "            self.add_order(order)\n",
    "            print(f\"Order {order_id} has been modified.\")\n",
    "        else:\n",
    "            print(f\"Order {order_id} not found for modification.\")\n",
    "            \n",
    "    def display_bids(self):\n",
    "        \"\"\"Display all current bid orders in the order book.\"\"\"\n",
    "        print(\"Bid Side:\")\n",
    "        for price in sorted(self.bids.keys(), reverse=True):\n",
    "            for order in self.bids[price]:\n",
    "                print(f\"Order ID: {order.id}, Price: {order.price}, Quantity: {order.quantity}\")\n",
    "\n",
    "    def display_asks(self):\n",
    "        \"\"\"Display all current ask orders in the order book.\"\"\"\n",
    "        print(\"Ask Side:\")\n",
    "        for price in sorted(self.asks.keys()):\n",
    "            for order in self.asks[price]:\n",
    "                print(f\"Order ID: {order.id}, Price: {order.price}, Quantity: {order.quantity}\")\n",
    "\n",
    "    def display_order_book(self):\n",
    "        \"\"\"Display the current state of the order book (both bids and asks).\"\"\"\n",
    "        print(\"\\nOrder Book:\")\n",
    "        self.display_bids()\n",
    "        self.display_asks()\n",
    "        \n",
    "    def bids_to_dataframe(self):\n",
    "        \"\"\"Convert the bid side of the order book to a pandas DataFrame.\"\"\"\n",
    "        bids = []\n",
    "        for price in sorted(self.bids.keys(), reverse=True):\n",
    "            for order in self.bids[price]:\n",
    "                bids.append({'Order ID': order.id, 'Price': order.price, 'Quantity': order.quantity})\n",
    "        return pd.DataFrame(bids)\n",
    "\n",
    "    def asks_to_dataframe(self):\n",
    "        \"\"\"Convert the ask side of the order book to a pandas DataFrame.\"\"\"\n",
    "        asks = []\n",
    "        for price in sorted(self.asks.keys()):\n",
    "            for order in self.asks[price]:\n",
    "                asks.append({'Order ID': order.id, 'Price': order.price, 'Quantity': order.quantity})\n",
    "        return pd.DataFrame(asks)\n",
    "\n",
    "    def display_order_book(self):\n",
    "        \"\"\"Display the current state of the order book as pandas DataFrames.\"\"\"\n",
    "        print(\"\\nOrder Book:\")\n",
    "        bids_df = self.bids_to_dataframe()\n",
    "        asks_df = self.asks_to_dataframe()\n",
    "\n",
    "        print(\"Bid Side:\")\n",
    "        print(bids_df)\n",
    "        print(\"\\nAsk Side:\")\n",
    "        print(asks_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d96213e",
   "metadata": {},
   "source": [
    "# Implementing a Matching Engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3c2d751",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MatchingEngine:\n",
    "    def __init__(self, order_book):\n",
    "        self.order_book = order_book\n",
    "\n",
    "    def match_order(self, incoming_order):\n",
    "        \"\"\"Match incoming orders against the order book.\"\"\"\n",
    "        if incoming_order.side == 'buy':\n",
    "            self.match_buy_order(incoming_order)\n",
    "        else:\n",
    "            self.match_sell_order(incoming_order)\n",
    "\n",
    "    def match_buy_order(self, order):\n",
    "        \"\"\"Match buy orders.\"\"\"\n",
    "        while order.quantity > 0 and self.order_book.get_best_ask() is not None:\n",
    "            best_ask_price = self.order_book.get_best_ask()\n",
    "            logging.info(f\"Best ask price: {best_ask_price}, Incoming buy order price: {order.price}\")\n",
    "            if order.price >= best_ask_price:\n",
    "                logging.info(f\"Executing buy order at price {best_ask_price}\")\n",
    "                self.execute_order(order, best_ask_price, 'sell')\n",
    "            else:\n",
    "                break\n",
    "\n",
    "    def match_sell_order(self, order):\n",
    "        \"\"\"Match sell orders.\"\"\"\n",
    "        while order.quantity > 0 and self.order_book.get_best_bid() is not None:\n",
    "            best_bid_price = self.order_book.get_best_bid()\n",
    "            logging.info(f\"Best bid price: {best_bid_price}, Incoming sell order price: {order.price}\")\n",
    "            if order.price <= best_bid_price:\n",
    "                logging.info(f\"Executing sell order at price {best_bid_price}\")\n",
    "                self.execute_order(order, best_bid_price, 'buy')\n",
    "            else:\n",
    "                break\n",
    "                \n",
    "    def execute_order(self, order, price, counter_side):\n",
    "        \"\"\"Execute orders at the given price.\"\"\"\n",
    "        counter_orders = self.order_book.asks if counter_side == 'sell' else self.order_book.bids\n",
    "        queue = counter_orders.get(price, deque())  # Safely get the queue, return an empty deque if the price level doesn't exist\n",
    "    \n",
    "        while order.quantity > 0 and queue:\n",
    "            best_order = queue[0]\n",
    "            if best_order.quantity > order.quantity:\n",
    "                # Fully match the incoming order\n",
    "                best_order = best_order._replace(quantity=best_order.quantity - order.quantity)\n",
    "                self.order_book.modify_order(best_order.id, best_order.quantity)\n",
    "                order = order._replace(quantity=0)\n",
    "                logging.info(f\"Fully matched order {order.id} with {best_order.id} at price {price}\")\n",
    "            elif best_order.quantity <= order.quantity:\n",
    "                # Partially or fully match the incoming order\n",
    "                order = order._replace(quantity=order.quantity - best_order.quantity)\n",
    "                self.order_book.remove_order(best_order.id)\n",
    "                if queue:  # Check if queue is not empty before popping\n",
    "                    queue.popleft()  # Remove the matched order from the queue\n",
    "                    logging.info(f\"Partially matched order {order.id} with {best_order.id} at price {price}\")\n",
    "            \n",
    "            # Check if the queue is empty and safely remove the price level\n",
    "            if not queue:\n",
    "                if price in counter_orders:\n",
    "                    del counter_orders[price]\n",
    "                    logging.info(f\"Deleted price level {price} from order book\")\n",
    "                else:\n",
    "                    logging.warning(f\"Price level {price} already removed from order book\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de119a4d",
   "metadata": {},
   "source": [
    "## Writing a Simplefix Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "816ac1da",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Set up basic logging\n",
    "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')\n",
    "\n",
    "FIX_TAGS = {\n",
    "    8: \"BeginString\",\n",
    "    35: \"MsgType\",\n",
    "    11: \"ClOrdID\",\n",
    "    54: \"Side\",\n",
    "    55: \"Symbol\",\n",
    "    44: \"Price\",\n",
    "    38: \"OrderQty\",\n",
    "    10: \"Checksum\",\n",
    "    41: \"OrigClOrdID\"\n",
    "}\n",
    "\n",
    "SIDE_MAPPING = {\n",
    "    '1': 'Buy',\n",
    "    '2': 'Sell'\n",
    "}\n",
    "\n",
    "MSG_TYPE_MAPPING = {\n",
    "    'D': 'NewOrderSingle',\n",
    "    'F': 'OrderCancelRequest',\n",
    "}\n",
    "\n",
    "class FixApplication:\n",
    "    def __init__(self, matching_engine):\n",
    "        self.matching_engine = matching_engine\n",
    "        self.parser = simplefix.parser.FixParser()\n",
    "        self.server_socket = None\n",
    "\n",
    "    def translate_fix_message(self, parsed_msg):\n",
    "        \"\"\"Translate FIX message tags to human-readable field names.\"\"\"\n",
    "        translated_msg = {}\n",
    "        for field in parsed_msg:\n",
    "            tag = field[0]\n",
    "            value = field[1].decode()\n",
    "            field_name = FIX_TAGS.get(tag, f\"Unknown({tag})\")\n",
    "            if field_name == \"Side\":\n",
    "                value = SIDE_MAPPING.get(value, value)\n",
    "            if field_name == \"MsgType\":\n",
    "                value = MSG_TYPE_MAPPING.get(value, value)\n",
    "            translated_msg[field_name] = value\n",
    "        return translated_msg\n",
    "\n",
    "    def handle_new_order(self, translated_msg):\n",
    "        order_id = translated_msg[\"ClOrdID\"]\n",
    "        side = translated_msg[\"Side\"]\n",
    "        price = float(translated_msg[\"Price\"])\n",
    "        quantity = int(translated_msg[\"OrderQty\"])\n",
    "        symbol = translated_msg[\"Symbol\"]\n",
    "\n",
    "        order = Order(id=order_id, price=price, quantity=quantity, side=side.lower(), type='limit')\n",
    "        self.matching_engine.match_order(order)\n",
    "        logging.info(f\"New order processed: {order_id} ({side} {quantity} {symbol} @ {price})\")\n",
    "\n",
    "    def handle_cancel_order(self, translated_msg):\n",
    "        order_id = translated_msg[\"OrigClOrdID\"]\n",
    "        self.matching_engine.cancel_order(order_id)\n",
    "        logging.info(f\"Cancel order processed for order ID: {order_id}\")\n",
    "\n",
    "    def handle_incoming_message(self, message):\n",
    "        self.parser.append_buffer(message)\n",
    "        parsed_msg = self.parser.get_message()\n",
    "\n",
    "        if parsed_msg is None:\n",
    "            logging.error(\"Received malformed message.\")\n",
    "            return\n",
    "\n",
    "        # Translate the message to human-readable form\n",
    "        translated_msg = self.translate_fix_message(parsed_msg)\n",
    "        logging.info(f\"Received FIX message: {translated_msg}\")\n",
    "\n",
    "        msg_type = translated_msg.get(\"MsgType\")\n",
    "        if msg_type == 'NewOrderSingle':\n",
    "            self.handle_new_order(translated_msg)\n",
    "        elif msg_type == 'OrderCancelRequest':\n",
    "            self.handle_cancel_order(translated_msg)\n",
    "        else:\n",
    "            logging.warning(f\"Unhandled message type: {msg_type}\")\n",
    "\n",
    "    def start(self):\n",
    "        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n",
    "        self.server_socket.bind(('localhost', 5005))\n",
    "        self.server_socket.listen(5)\n",
    "        self.running = True\n",
    "        logging.info(\"FIX server started. Waiting for connections...\")\n",
    "\n",
    "        while self.running:\n",
    "            try:\n",
    "                client_socket, addr = self.server_socket.accept()\n",
    "                logging.info(f\"Connection from {addr}\")\n",
    "                data = client_socket.recv(1024)\n",
    "                if data:\n",
    "                    logging.info(f\"Received raw data: {data.decode()}\")\n",
    "                    self.handle_incoming_message(data)\n",
    "                    client_socket.sendall(b'Ack')\n",
    "                client_socket.close()\n",
    "            except OSError:\n",
    "                if not self.running:\n",
    "                    logging.info(\"Server socket closed.\")\n",
    "                else:\n",
    "                    raise\n",
    "\n",
    "    def stop(self):\n",
    "        self.running = False\n",
    "        if self.server_socket:\n",
    "            self.server_socket.close()\n",
    "            logging.info(\"FIX server stopped.\")\n",
    "\n",
    "    def create_order_message(self, order):\n",
    "        \"\"\"Create a FIX message based on the given order.\"\"\"\n",
    "        msg = simplefix.FixMessage()\n",
    "        msg.append_pair(8, b'FIX.4.2')\n",
    "        msg.append_pair(35, b'D')  # New Order Single\n",
    "        msg.append_pair(11, order['id'].encode())  # Order ID (ClOrdID)\n",
    "        msg.append_pair(54, b'1' if order['side'] == 'buy' else b'2')  # Side\n",
    "        msg.append_pair(55, order['symbol'].encode())  # Symbol\n",
    "        msg.append_pair(44, str(order['price']).encode())  # Price\n",
    "        msg.append_pair(38, str(order['quantity']).encode())  # OrderQty\n",
    "        msg.append_pair(10, b'000')  # Checksum placeholder\n",
    "\n",
    "        return msg\n",
    "\n",
    "    def send_message(self, msg):\n",
    "        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "        client_socket.connect(('localhost', 5005))\n",
    "        client_socket.sendall(msg.encode())\n",
    "        response = client_socket.recv(1024)\n",
    "        logging.info(f\"Received response: {response.decode()}\")\n",
    "        client_socket.close()\n",
    "        \n",
    "    def send_execution_report(self, order, status, filled_quantity):\n",
    "        \"\"\"Send an execution report back to the client.\"\"\"\n",
    "        report = simplefix.FixMessage()\n",
    "        report.append_pair(8, b'FIX.4.2')\n",
    "        report.append_pair(35, b'8')  # MsgType: 8 = Execution Report\n",
    "        report.append_pair(37, order.id.encode())  # OrderID\n",
    "        report.append_pair(17, str(random.randint(100000, 999999)).encode())  # ExecID\n",
    "        report.append_pair(150, b'0' if status == 'Filled' else b'1')  # ExecType: 0 = New, 1 = Partial fill\n",
    "        report.append_pair(39, b'2' if status == 'Filled' else b'1')  # OrdStatus: 2 = Filled, 1 = Partially filled\n",
    "        report.append_pair(55, order.symbol.encode())  # Symbol\n",
    "        report.append_pair(54, b'1' if order.side == 'buy' else b'2')  # Side\n",
    "        report.append_pair(38, str(order.quantity).encode())  # OrderQty\n",
    "        report.append_pair(44, str(order.price).encode())  # Price\n",
    "        report.append_pair(14, str(filled_quantity).encode())  # CumQty\n",
    "        report.append_pair(6, str(order.price).encode())  # AvgPx\n",
    "        report.append_pair(10, b'000')  # Checksum placeholder\n",
    "\n",
    "        self.send_message(report)\n",
    "\n",
    "    def handle_incoming_message(self, message):\n",
    "        self.parser.append_buffer(message)\n",
    "        parsed_msg = self.parser.get_message()\n",
    "\n",
    "        if parsed_msg is None:\n",
    "            logging.error(\"Received malformed message.\")\n",
    "            return\n",
    "\n",
    "        translated_msg = self.translate_fix_message(parsed_msg)\n",
    "        logging.info(f\"Received FIX message: {translated_msg}\")\n",
    "\n",
    "        msg_type = translated_msg.get(\"MsgType\")\n",
    "        if msg_type == 'NewOrderSingle':\n",
    "            self.handle_new_order(translated_msg)\n",
    "        elif msg_type == 'OrderCancelRequest':\n",
    "            self.handle_cancel_order(translated_msg)\n",
    "        else:\n",
    "            logging.warning(f\"Unhandled message type: {msg_type}\")\n",
    "\n",
    "    def handle_new_order(self, translated_msg):\n",
    "        order_id = translated_msg[\"ClOrdID\"]\n",
    "        side = translated_msg[\"Side\"]\n",
    "        price = float(translated_msg[\"Price\"])\n",
    "        quantity = int(translated_msg[\"OrderQty\"])\n",
    "        symbol = translated_msg[\"Symbol\"]\n",
    "\n",
    "        order = Order(id=order_id, price=price, quantity=quantity, side=side.lower(), type='limit')\n",
    "        self.matching_engine.match_order(order)\n",
    "        logging.info(f\"New order processed: {order_id} ({side} {quantity} {symbol} @ {price})\")\n",
    "\n",
    "        # Assume that matching_engine.match_order can return the filled quantity and status\n",
    "        filled_quantity = order.quantity  # Placeholder; update with actual logic\n",
    "        status = 'Filled' if filled_quantity == quantity else 'PartiallyFilled'\n",
    "        self.send_execution_report(order, status, filled_quantity)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5b16bee",
   "metadata": {},
   "source": [
    "## Getting Live Market Data Feed Using yfinance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68d59fb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MarketDataFeed:\n",
    "    def __init__(self, symbol):\n",
    "        self.symbol = symbol\n",
    "        self.subscribers = []\n",
    "        self.running = False\n",
    "\n",
    "    def subscribe(self, client):\n",
    "        \"\"\"Subscribe a client to the market data feed.\"\"\"\n",
    "        self.subscribers.append(client)\n",
    "\n",
    "    def broadcast(self, data):\n",
    "        \"\"\"Broadcast data to all subscribers.\"\"\"\n",
    "        for client in self.subscribers:\n",
    "            client.receive(data)\n",
    "\n",
    "    def fetch_market_data(self):\n",
    "        \"\"\"Fetch market data using yfinance.\"\"\"\n",
    "        ticker = yf.Ticker(self.symbol)\n",
    "        data = ticker.history(period=\"1d\", interval=\"1m\")  # 1-minute interval data\n",
    "        if not data.empty:\n",
    "            latest_data = data.iloc[-1]\n",
    "            return {\n",
    "                'symbol': self.symbol,\n",
    "                'timestamp': latest_data.name,\n",
    "                'price': latest_data['Close'],\n",
    "                'volume': latest_data['Volume']\n",
    "            }\n",
    "        return None\n",
    "\n",
    "    def start(self):\n",
    "        \"\"\"Start the feed to fetch and broadcast market data.\"\"\"\n",
    "        self.running = True\n",
    "        while self.running:\n",
    "            market_data = self.fetch_market_data()\n",
    "            if market_data:\n",
    "                self.broadcast(market_data)\n",
    "            time.sleep(60)  # Fetch every 1 minute\n",
    "\n",
    "    def stop(self):\n",
    "        \"\"\"Stop the market data feed.\"\"\"\n",
    "        self.running = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69b1753f",
   "metadata": {},
   "source": [
    "## Writing a Simple Market Maker Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36af6f26",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MarketMaker:\n",
    "    def __init__(self, symbol, matching_engine):\n",
    "        self.symbol = symbol\n",
    "        self.matching_engine = matching_engine\n",
    "        self.spread = 0.5  # Fixed spread for simplicity\n",
    "        self.price_history = []  # Track price history for volatility calculation\n",
    "        self.running = False\n",
    "\n",
    "    def calculate_dynamic_spread(self):\n",
    "        \"\"\"Calculate spread based on recent price volatility.\"\"\"\n",
    "        if len(self.price_history) < 10:\n",
    "            return self.spread  # Not enough data to calculate volatility\n",
    "        \n",
    "        volatility = statistics.stdev(self.price_history[-10:])\n",
    "        return max(self.spread, volatility * 0.5)  # Dynamic spread\n",
    "\n",
    "    def generate_order(self, side, price):\n",
    "        \"\"\"Generate a market-making order.\"\"\"\n",
    "        order_id = str(random.randint(10000, 99999))\n",
    "        quantity = random.randint(10, 100)\n",
    "        order = Order(id=order_id, price=price, quantity=quantity, side=side, type='limit', symbol=self.symbol)\n",
    "        return order\n",
    "\n",
    "    def on_market_data(self, data):\n",
    "        \"\"\"Respond to market data by posting orders.\"\"\"\n",
    "        if data['symbol'] == self.symbol:\n",
    "            self.price_history.append(data['price'])\n",
    "            dynamic_spread = self.calculate_dynamic_spread()\n",
    "            best_bid_price = data['price'] - dynamic_spread\n",
    "            best_ask_price = data['price'] + dynamic_spread\n",
    "\n",
    "            bid_order = self.generate_order('buy', best_bid_price)\n",
    "            ask_order = self.generate_order('sell', best_ask_price)\n",
    "\n",
    "            self.matching_engine.match_order(bid_order)\n",
    "            self.matching_engine.match_order(ask_order)\n",
    "            logging.info(f\"Posted bid: {bid_order.price}, ask: {ask_order.price}\")\n",
    "\n",
    "    def start(self, feed):\n",
    "        \"\"\"Start the market maker.\"\"\"\n",
    "        self.running = True\n",
    "        feed.subscribe(self)\n",
    "\n",
    "    def stop(self):\n",
    "        \"\"\"Stop the market maker.\"\"\"\n",
    "        self.running = False\n",
    "\n",
    "    def receive(self, data):\n",
    "        \"\"\"Handle incoming market data.\"\"\"\n",
    "        self.on_market_data(data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "990a54d5",
   "metadata": {},
   "source": [
    "## Synthetic Liquidity Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db839719",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SyntheticLiquidityProvider:\n",
    "    def __init__(self, symbol, matching_engine, num_orders=10):\n",
    "        self.symbol = symbol\n",
    "        self.matching_engine = matching_engine\n",
    "        self.num_orders = num_orders\n",
    "\n",
    "    def generate_liquidity(self):\n",
    "        for _ in range(self.num_orders):\n",
    "            side = 'buy' if random.random() < 0.5 else 'sell'\n",
    "            ticker = yf.Ticker(self.symbol)\n",
    "            data = ticker.history(period=\"1d\", interval=\"1m\")\n",
    "            latest_data = data.iloc[-1]\n",
    "            price = latest_data['Close']\n",
    "            order = Order(id=str(random.randint(10000, 99999)), price=price, quantity=random.randint(10, 100), side=side, type='limit', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "            logging.info(f\"Synthetic liquidity added: {side} order at {price}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a81034",
   "metadata": {},
   "source": [
    "## Implementing Algorithmic Traders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7c074a",
   "metadata": {},
   "source": [
    "### Parent Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "660b46ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlgorithmicTrader:\n",
    "    def __init__(self, symbol, matching_engine, interval=0.1):\n",
    "        self.symbol = symbol\n",
    "        self.matching_engine = matching_engine\n",
    "        self.interval = interval\n",
    "        self.running = False\n",
    "        self.current_price = None\n",
    "\n",
    "    def start(self, feed):\n",
    "        self.running = True\n",
    "        feed.subscribe(self)\n",
    "        while self.running:\n",
    "            self.trade()\n",
    "            time.sleep(self.interval)\n",
    "\n",
    "    def stop(self):\n",
    "        self.running = False\n",
    "\n",
    "    def trade(self):\n",
    "        pass  # To be implemented by subclasses\n",
    "\n",
    "    def receive(self, data):\n",
    "        if data['symbol'] == self.symbol:\n",
    "            self.on_market_data(data)\n",
    "\n",
    "    def on_market_data(self, data):\n",
    "        self.current_price = data['price']  # Update current price\n",
    "        self.handle_market_data(data)\n",
    "\n",
    "    def handle_market_data(self, data):\n",
    "        pass  # To be implemented by subclasses\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3082a796",
   "metadata": {},
   "source": [
    "### Momentum Based Trader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "012cabf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MomentumTrader(AlgorithmicTrader):\n",
    "    def __init__(self, symbol, matching_engine, interval=0.1, lookback=5):\n",
    "        super().__init__(symbol, matching_engine, interval)\n",
    "        self.lookback = lookback\n",
    "        self.prices = []\n",
    "\n",
    "    def handle_market_data(self, data):\n",
    "        self.prices.append(self.current_price)\n",
    "        if len(self.prices) > self.lookback:\n",
    "            self.prices.pop(0)\n",
    "\n",
    "    def trade(self):\n",
    "        if len(self.prices) < self.lookback:\n",
    "            return\n",
    "\n",
    "        price_change = self.prices[-1] - self.prices[0]\n",
    "        if price_change > 0:\n",
    "            # Buy\n",
    "            order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='buy', type='limit', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "            logging.info(f\"MomentumTrader placed a buy order at {self.current_price}\")\n",
    "        elif price_change < 0:\n",
    "            # Sell\n",
    "            order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='sell', type='limit', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "            logging.info(f\"MomentumTrader placed a sell order at {self.current_price}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92176ed6",
   "metadata": {},
   "source": [
    "### EMA Based Trader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b90ab68",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EMABasedTrader(AlgorithmicTrader):\n",
    "    def __init__(self, symbol, matching_engine, interval=0.1, short_window=5, long_window=20):\n",
    "        super().__init__(symbol, matching_engine, interval)\n",
    "        self.short_window = short_window\n",
    "        self.long_window = long_window\n",
    "        self.prices = []\n",
    "\n",
    "    def handle_market_data(self, data):\n",
    "        self.prices.append(self.current_price)\n",
    "        if len(self.prices) > self.long_window:\n",
    "            self.prices.pop(0)\n",
    "\n",
    "    def trade(self):\n",
    "        if len(self.prices) < self.long_window:\n",
    "            return\n",
    "\n",
    "        short_ema = self.calculate_ema(self.short_window)\n",
    "        long_ema = self.calculate_ema(self.long_window)\n",
    "\n",
    "        if short_ema > long_ema:\n",
    "            # Buy\n",
    "            order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='buy', type='limit', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "            logging.info(f\"EMABasedTrader placed a buy order at {self.current_price}\")\n",
    "        elif short_ema < long_ema:\n",
    "            # Sell\n",
    "            order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='sell', type='limit', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "            logging.info(f\"EMABasedTrader placed a sell order at {self.current_price}\")\n",
    "\n",
    "    def calculate_ema(self, window):\n",
    "        weights = np.exp(np.linspace(-1., 0., window))\n",
    "        weights /= weights.sum()\n",
    "        a = np.convolve(self.prices, weights, mode='valid')\n",
    "        return a[-1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a667470a",
   "metadata": {},
   "source": [
    "### Swing Trader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1062e993",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SwingTrader(AlgorithmicTrader):\n",
    "    def __init__(self, symbol, matching_engine, interval=0.1, support_level=100, resistance_level=200):\n",
    "        super().__init__(symbol, matching_engine, interval)\n",
    "        self.support_level = support_level\n",
    "        self.resistance_level = resistance_level\n",
    "\n",
    "    def trade(self):\n",
    "        if self.current_price:\n",
    "            if self.current_price <= self.support_level:\n",
    "                # Buy\n",
    "                order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='buy', type='limit', symbol=self.symbol)\n",
    "                self.matching_engine.match_order(order)\n",
    "                logging.info(f\"SwingTrader placed a buy order at {self.current_price}\")\n",
    "            elif self.current_price >= self.resistance_level:\n",
    "                # Sell\n",
    "                order = Order(id=str(random.randint(10000, 99999)), price=self.current_price, quantity=100, side='sell', type='limit', symbol=self.symbol)\n",
    "                self.matching_engine.match_order(order)\n",
    "                logging.info(f\"SwingTrader placed a sell order at {self.current_price}\")\n",
    "\n",
    "    def handle_market_data(self, data):\n",
    "        self.current_price = data['price']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01706af2",
   "metadata": {},
   "source": [
    "### Sentiment Analysis Trader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf14d7e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SentimentAnalysisTrader(AlgorithmicTrader):\n",
    "    def __init__(self, symbol, matching_engine, model_file, news_api_key, interval=60, vocab_size=20000, max_sequence_length=128):\n",
    "        super().__init__(symbol, matching_engine, interval)\n",
    "        self.model = self.load_model(model_file)\n",
    "        self.vectorize_layer = self.create_vectorize_layer(vocab_size, max_sequence_length)\n",
    "        self.news_fetcher = NewsFetcher(api_key=news_api_key)\n",
    "\n",
    "    def load_model(self, model_file):\n",
    "        # Load the pre-trained sentiment analysis model\n",
    "        return load_model(model_file)\n",
    "    \n",
    "    def create_vectorize_layer(self, vocab_size, max_sequence_length):\n",
    "        # Create a TextVectorization layer\n",
    "        vectorize_layer = tf.keras.layers.TextVectorization(\n",
    "            max_tokens=vocab_size,\n",
    "            output_mode='int',\n",
    "            output_sequence_length=max_sequence_length\n",
    "        )\n",
    "        # This layer should be adapted to the vocabulary of your training data\n",
    "        return vectorize_layer\n",
    "    \n",
    "    def vectorize_text(self, text):\n",
    "        return self.vectorize_layer(text)\n",
    "    \n",
    "    def predict_sentiment(self, headlines):\n",
    "        # Vectorize the headlines\n",
    "        inputs = self.vectorize_text(headlines)\n",
    "        \n",
    "        # Predict sentiment probabilities\n",
    "        probs = self.model.predict(inputs)\n",
    "        \n",
    "        # Determine sentiment score (0: negative, 1: neutral, 2: positive)\n",
    "        sentiment_scores = np.argmax(probs, axis=1)\n",
    "        return sentiment_scores\n",
    "    \n",
    "    def decide_trade_action(self, sentiment_score):\n",
    "        # Define your trading logic based on sentiment scores\n",
    "        if sentiment_score == 2:  # positive sentiment\n",
    "            return \"buy\"\n",
    "        elif sentiment_score == 0:  # negative sentiment\n",
    "            return \"sell\"\n",
    "        else:\n",
    "            return \"hold\"\n",
    "\n",
    "    def trade(self):\n",
    "        # Fetch the latest news\n",
    "        headlines = self.news_fetcher.fetch_latest_news(query=self.symbol)\n",
    "        \n",
    "        # Predict sentiment and decide trade action\n",
    "        for headline in headlines:\n",
    "            sentiment_score = self.predict_sentiment([headline])\n",
    "            action = self.decide_trade_action(sentiment_score[0])\n",
    "            print(f\"Headline: {headline}\\nSentiment: {sentiment_score[0]} -> Action: {action}\\n\")\n",
    "\n",
    "            if self.current_price is not None:\n",
    "                # Execute trade based on sentiment\n",
    "                if action == \"buy\":\n",
    "                    order = Order(id='some_unique_id', price=self.current_price, quantity=100, side='buy', type='market', symbol=self.symbol)\n",
    "                    self.matching_engine.match_order(order)\n",
    "                elif action == \"sell\":\n",
    "                    order = Order(id='some_unique_id', price=self.current_price, quantity=100, side='sell', type='market', symbol=self.symbol)\n",
    "                    self.matching_engine.match_order(order)\n",
    "\n",
    "    def handle_market_data(self, data):\n",
    "        # This method can be used to further process market data if needed\n",
    "        pass\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67e72eb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NewsFetcher:\n",
    "    def __init__(self, api_key):\n",
    "        self.newsapi = NewsApiClient(api_key=api_key)\n",
    "\n",
    "    def fetch_latest_news(self, query='stock market'):\n",
    "        all_articles = self.newsapi.get_everything(q=query,\n",
    "                                                   language='en',\n",
    "                                                   sort_by='publishedAt',\n",
    "                                                   page_size=5)\n",
    "        headlines = [article['title'] for article in all_articles['articles']]\n",
    "        return headlines"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c045919a",
   "metadata": {},
   "source": [
    "### Custom Trader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09dd4c8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomTrader(AlgorithmicTrader):\n",
    "    def trade(self):\n",
    "        # Custom trading logic here\n",
    "        if self.current_price < some_threshold:\n",
    "            # Generate and submit a buy order\n",
    "            order = Order(id='custom_buy', price=self.current_price, quantity=10, side='buy', type='market', symbol=self.symbol)\n",
    "            self.matching_engine.match_order(order)\n",
    "\n",
    "custom_trader = CustomTrader(symbol=\"AAPL\", matching_engine=matching_engine)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ff7392",
   "metadata": {},
   "source": [
    "## Backtesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f704b6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_historical_data(symbol, start_date, end_date):\n",
    "    \"\"\"Load historical data from yfinance.\"\"\"\n",
    "    data = yf.download(symbol, start=start_date, end=end_date)\n",
    "    # Ensure the data is formatted as expected\n",
    "    data.reset_index(inplace=True)\n",
    "    return data\n",
    "\n",
    "def run_backtest(historical_data, market_maker, matching_engine):\n",
    "    \"\"\"Simulate historical data through the market maker and matching engine.\"\"\"\n",
    "    for index, row in historical_data.iterrows():\n",
    "        # Simulate a market data update for the market maker\n",
    "        market_data = {\n",
    "            'symbol': market_maker.symbol,\n",
    "            'price': row['Close'],\n",
    "            'timestamp': row['Date']\n",
    "        }\n",
    "        \n",
    "        # MarketMaker reacts to the incoming market data\n",
    "        market_maker.on_market_data(market_data)\n",
    "        \n",
    "        # The MarketMaker will internally decide whether to generate an order\n",
    "        # and will send it to the MatchingEngine as needed.\n",
    "        \n",
    "        # Optional: sleep to simulate time passing, though this isn't necessary in backtesting\n",
    "        # time.sleep(1)\n",
    "\n",
    "    print(\"Backtest completed.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a68635",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    # Initialize historical data\n",
    "    symbol = \"AAPL\"\n",
    "    start_date = \"2023-01-01\"\n",
    "    end_date = \"2023-12-31\"\n",
    "    historical_data = load_historical_data(symbol, start_date, end_date)\n",
    "\n",
    "    # Initialize the market maker, matching engine, and other components\n",
    "    order_book = OrderBook()\n",
    "    matching_engine = MatchingEngine(order_book)\n",
    "    market_maker = MarketMaker(symbol=symbol, matching_engine=matching_engine)\n",
    "\n",
    "    # Run the backtest\n",
    "    run_backtest(historical_data, market_maker, matching_engine)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adf57518",
   "metadata": {},
   "source": [
    "## How to Run/Test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae1d4979",
   "metadata": {},
   "source": [
    "### Initialising Everything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "551fd435",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "order_book = OrderBook()\n",
    "matching_engine = MatchingEngine(order_book)\n",
    "fix_app = FixApplication(matching_engine)\n",
    "\n",
    "# Prompt user for the stock ticker\n",
    "ticker_symbol = input(\"Enter the stock ticker symbol you want to track (e.g., AAPL): \").upper()\n",
    "\n",
    "# Initialize the MarketDataFeed with the user-provided ticker symbol\n",
    "market_data_feed = MarketDataFeed(symbol=ticker_symbol)\n",
    "market_maker = MarketMaker(symbol=ticker_symbol, matching_engine=matching_engine)\n",
    "\n",
    "# Start FIX server\n",
    "fix_thread = threading.Thread(target=fix_app.start)\n",
    "fix_thread.start()\n",
    "\n",
    "# Start market data feed\n",
    "feed_thread = threading.Thread(target=market_data_feed.start)\n",
    "feed_thread.start()\n",
    "\n",
    "# Start market maker\n",
    "market_maker.start(market_data_feed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3642d9a7",
   "metadata": {},
   "source": [
    "### Order Creation and Control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db180e84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an ask order\n",
    "ask_order = Order(id='2', price=415, quantity=100, side='sell', type='limit', symbol='MSFT')\n",
    "order_book.add_order(ask_order)\n",
    "\n",
    "# Post a buy order that should match the ask\n",
    "#buy_order = Order(id='2', price=228.00, quantity=100, side='buy', type='limit', symbol='AAPL')\n",
    "#order_book.add_order(buy_order)\n",
    "#matching_engine.match_order(buy_order)\n",
    "\n",
    "# Display the order book after matching\n",
    "order_book.display_order_book()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d2bcef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "order1 = Order(id='1', price=100.0, quantity=10, side='buy', type='limit', symbol='AAPL')\n",
    "order2 = Order(id='2', price=101.0, quantity=20, side='buy', type='limit', symbol='AAPL')\n",
    "order3 = Order(id='3', price=102.0, quantity=15, side='sell', type='limit', symbol='AAPL')\n",
    "order4 = Order(id='4', price=103.0, quantity=25, side='sell', type='limit', symbol='AAPL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0e5466b",
   "metadata": {},
   "outputs": [],
   "source": [
    "order_book.modify_order(order_id='2', new_quantity=30, new_price=100.5)\n",
    "order_book.cancel_order(order_id='3')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bffd899",
   "metadata": {},
   "source": [
    "### Synthetic Liquidity Controls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45ab646f",
   "metadata": {},
   "outputs": [],
   "source": [
    "liquidity_provider = SyntheticLiquidityProvider(symbol=symbol, matching_engine=matching_engine, num_orders=10)\n",
    "liquidity_provider.generate_liquidity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2eeee398",
   "metadata": {},
   "outputs": [],
   "source": [
    "liquidity_thread = threading.Thread(target=auto_inject_liquidity, args=(liquidity_provider, 5))  # Inject every 5 seconds\n",
    "liquidity_thread.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "806e6bef",
   "metadata": {},
   "source": [
    "### Algo Trading Bot Controls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ce523ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the pre-trained sentiment analysis model (assuming it’s stored as 'sentiment_classifier_model.h5')\n",
    "sentiment_model = tf.keras.models.load_model('sentiment_classifier_model.keras')\n",
    "\n",
    "    # Initialize the traders\n",
    "momentum_trader = MomentumTrader(symbol=ticker_symbol, matching_engine=matching_engine, interval=10)\n",
    "ema_trader = EMABasedTrader(symbol=ticker_symbol, matching_engine=matching_engine, interval=30)\n",
    "swing_trader = SwingTrader(symbol=ticker_symbol, matching_engine=matching_engine, interval=15)\n",
    "sentiment_trader = SentimentAnalysisTrader(\n",
    "        symbol=ticker_symbol,\n",
    "        matching_engine=matching_engine,\n",
    "        model_file='sentiment_classifier_model.keras',\n",
    "        news_api_key=\"your_newsapi_key_here\",\n",
    "        interval=60\n",
    "    )\n",
    "\n",
    "# Collect all traders into a list\n",
    "traders = [momentum_trader, ema_trader, swing_trader, sentiment_trader]\n",
    "\n",
    "# Start each trader in its own thread\n",
    "trader_threads = []\n",
    "for trader in traders:\n",
    "    thread = threading.Thread(target=trader.start, args=(market_data_feed,))\n",
    "    thread.start()\n",
    "    trader_threads.append(thread)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e21763d",
   "metadata": {},
   "source": [
    "### Stop All"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03a364b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "market_maker.stop()\n",
    "market_data_feed.stop()\n",
    "fix_app.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6b9327f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stop all traders\n",
    "for trader in traders:\n",
    "trader.stop()\n",
    "\n",
    "# Join all threads to ensure they have finished\n",
    "for thread in trader_threads:\n",
    "thread.join()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}