public_gist_live_plotter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "#from mpl_finance import candlestick_ohlc\n",
    "from mplfinance.original_flavor import candlestick_ohlc\n",
    "import matplotlib.dates as mdates\n",
    "from matplotlib import style\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import datetime as dt\n",
    "import time\n",
    "import re   #for regular expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Plotter(object):\n",
    "    def __init__(self,datastream,args):\n",
    "        self.datastream        = datastream\n",
    "        self.args              = args \n",
    "        self.fig               = plt.figure()\n",
    "        self.ax1               = self.fig.add_subplot(1,1,1)\n",
    "        self.plot_func         = None\n",
    "        self.plot_refresh_rate = args.plot_refresh_rate\n",
    "        self.candle_width      = args.candle_width\n",
    "        self._width            = self._convert_candleWidth_to_chartWidth()\n",
    "        plt.xlabel('Timestamp')\n",
    "        plt.ylabel('Price')\n",
    "        \n",
    "        self._set_plot_function()\n",
    "    \n",
    "    def _convert_candleWidth_to_chartWidth(self):\n",
    "        # determine the frequency of the bars\n",
    "        num_freq  = re.findall('\\d+', self.candle_width)[0]\n",
    "        timeframe = re.findall('[a-z]+',self.candle_width,re.I)[0].lower()\n",
    "        #print('TIMEFRAME:',timeframe)\n",
    "        #Define default number of candles in a day if we assume each candle is 1 second thick\n",
    "        hours = 24          #bars per day\n",
    "        mins  = 60          #bars per hour\n",
    "        secs  = 60          #bars per minute\n",
    "        num_candles = hours * mins * secs\n",
    "\n",
    "        #Modify number of candles based on requested bar width\n",
    "        bar_reduction_rate = 0.85\n",
    "        if timeframe == 's':\n",
    "            bar_thickness   = int(num_freq) * bar_reduction_rate\n",
    "        elif timeframe == 't' or timeframe == 'min':\n",
    "            bar_thickness   = (int(num_freq) * 60) * bar_reduction_rate\n",
    "            #print('We are here. Bar_thickness:',bar_thickness)\n",
    "        new_num_candles = num_candles / bar_thickness\n",
    "\n",
    "        return 1./new_num_candles\n",
    "\n",
    "    def clear_canvas(self):\n",
    "        self.ax1.clear()\n",
    "        \n",
    "    def _set_plot_function(self):\n",
    "        if self.args.plot_mode.lower() == 'tick':\n",
    "            self.plot_func = self._tick_plotter\n",
    "        elif self.args.plot_mode.lower() == 'candle':\n",
    "            self.plot_func = self._candle_plotter\n",
    "    \n",
    "    def _tick_plotter(self,i):\n",
    "        self.ax1.clear()\n",
    "        for label in self.ax1.xaxis.get_ticklabels():\n",
    "            label.set_rotation(45)\n",
    "        self.ax1.plot(self.datastream.timestamps,self.datastream.bids)\n",
    "        \n",
    "    def _candle_plotter(self,i):\n",
    "        '''Function to animate a live chart using matplotlib.animation.FuncAnimation.\n",
    "        It is defined here for convenience but I will look for a more elegant solution later.'''\n",
    "\n",
    "        ohlc_df = self.datastream.get_ohlc(self.candle_width)#['bid']\n",
    "        ohlc_df.set_index('datetime',inplace=True)\n",
    "        ohlc_df = ohlc_df['bid']\n",
    "        ohlc_df.reset_index(inplace=True)\n",
    "\n",
    "        ohlc_df['datetime'] = pd.to_datetime(ohlc_df['datetime'])\n",
    "        ohlc_df['datetime'] = ohlc_df[\"datetime\"].apply(mdates.date2num)\n",
    "        self.ax1.clear()\n",
    "        for label in self.ax1.xaxis.get_ticklabels():\n",
    "            label.set_rotation(45)\n",
    "        candlestick_ohlc(self.ax1, ohlc_df.values, width=self._width, colorup='green', colordown='red')\n",
    "        self.ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M:%S'))\n",
    "\n",
    "    def plot(self):\n",
    "        ani = animation.FuncAnimation(self.fig, self.plot_func, interval=self.plot_refresh_rate)      #fig is the canvas we are drawing on. animate is the animation function we defined above. interval is the frecuency (in milliseconds) of refresh for the canvas\n",
    "        plt.show()\n",
    "        \n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ohlc_resample(dataframe, interval):\n",
    "    i = interval    #do some processing here to make the interval appropriate or to check for correct format\n",
    "    headers = ['datetime','bid','ask']\n",
    "\n",
    "    dataframe = dataframe.set_index('datetime')\n",
    "    #bid_ask_ohlc['datetime'] = pd.to_datetime(bid_ask_ohlc['datetime'])\n",
    "    dataframe.index = pd.to_datetime(dataframe.index, unit='s')\n",
    "\n",
    "    bid_ohlc = dataframe['bid'].resample(i).ohlc()\n",
    "    ask_ohlc = dataframe['ask'].resample(i).ohlc()\n",
    "    data_bid_ask = pd.concat([bid_ohlc, ask_ohlc], axis=1, keys=['bid','ask'])\n",
    "    data_bid_ask = data_bid_ask.reset_index()\n",
    "    return data_bid_ask\n",
    "\n",
    "class DataStream():\n",
    "    '''Replacement for OrderBook and should be in a higher level location.'''\n",
    "    ITER_IDX = 0\n",
    "    MEANING_DICT = {\n",
    "        't'  : 'datetime',\n",
    "        'b'  : 'bid',\n",
    "        'a'  : 'ask',\n",
    "        'vb' : 'volume bid',\n",
    "        'va' : 'volume ask',\n",
    "        'ob' : 'open interest bid',\n",
    "        'oa' : 'open interest ask',\n",
    "        'sym': 'asset symbol (i.e. EUR/USD)'\n",
    "    }\n",
    "    def __init__(self):\n",
    "        self.symbol           = \"\"\n",
    "        self.timestamps       = []\n",
    "        self.bids             = []\n",
    "        self.asks             = []\n",
    "        self.volume_bid       = []\n",
    "        self.volume_ask       = []\n",
    "        self.openinterest_bid = []\n",
    "        self.openinterest_ask = []\n",
    "\n",
    "        self.last_checked     = dt.datetime.utcnow()\n",
    "\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.timestamps)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        i = self.ITER_IDX\n",
    "        #Check for a stopping condition\n",
    "        if i >= len(self):\n",
    "            raise StopIteration()\n",
    "        else:\n",
    "            tick = self.get_tick(idx=i)\n",
    "            self.ITER_IDX += 1\n",
    "            return tick\n",
    "        \n",
    "    def get_dataframe(self,size=-1,empty_data=False,include_cols=['t','b','a']):\n",
    "        '''size indicates how many rows to include in the dataframe, counting from the last row up.\n",
    "        empty_data is a flag to see if we should clear all the rows included in the dataframe'''\n",
    "        if (len(self) < size) or (size < 0):\n",
    "            start_idx = 0\n",
    "        else:\n",
    "            start_idx = len(self) - size\n",
    "        data = {\n",
    "            'datetime':self.timestamps[start_idx:],\n",
    "            'bid'     :self.bids[start_idx:],\n",
    "            'ask'     :self.asks[start_idx:],\n",
    "        }\n",
    "        df = pd.DataFrame(data)\n",
    "        return df\n",
    "\n",
    "        \n",
    "    def get_tick(self,idx=None,tick_format=['t','b','a']):\n",
    "        '''always returns the latest tick data available.\n",
    "        format tells the function what information to pack for return. For example,\n",
    "        the default format is [t,b,a] which tells the program to return timestamp, bid, and ask.\n",
    "        possible values are:\n",
    "        t  -> timestamp\n",
    "        b  -> bid\n",
    "        a  -> ask\n",
    "        vb -> volume bid\n",
    "        va -> volume ask\n",
    "        ob -> open interest bid\n",
    "        oa -> open interest ask\n",
    "        '''\n",
    "        #Define the correct index to use\n",
    "        if idx is None:\n",
    "            i = -1\n",
    "        else:\n",
    "            i = idx\n",
    "        output_tick = []\n",
    "        for requested_data in tick_format:\n",
    "            if requested_data.lower()   == 't':\n",
    "                output_tick.append(self.timestamps[i])\n",
    "            elif requested_data.lower() == 'b':\n",
    "                output_tick.append(self.bids[i])\n",
    "            elif requested_data.lower() == 'a':\n",
    "                output_tick.append(self.asks[i])\n",
    "            elif requested_data.lower() == 'vb':\n",
    "                output_tick.append(self.volume_bid[i])\n",
    "            elif requested_data.lower() == 'va':\n",
    "                output_tick.append(self.volume_ask[i])\n",
    "            elif requested_data.lower() == 'ob':\n",
    "                output_tick.append(self.open_interest_bid[i])\n",
    "            elif requested_data.lower() == 'oa':\n",
    "                output_tick.append(self.open_interest_ask[i])\n",
    "            elif requested_data.lower() == 'sym':\n",
    "                output_tick.append(self.symbol)\n",
    "        return output_tick\n",
    "\n",
    "        return ohlc_tick\n",
    "\n",
    "    def _prefill_kargs(self,kargs_dict):\n",
    "        keys = ['timestamp','bid','ask','volume_bid','volume_ask','openinterest_bid','openinterest_ask']\n",
    "        for k in keys:\n",
    "            try:\n",
    "                kargs_dict[k]\n",
    "            except KeyError:\n",
    "                kargs_dict[k] = -1\n",
    "\n",
    "        return kargs_dict\n",
    "\n",
    "    def add_tick(self,**kargs):\n",
    "        kargs = self._prefill_kargs(kargs)\n",
    "        bid         = kargs['bid']\n",
    "        ask         = kargs['ask']\n",
    "        timestamp   = kargs['timestamp']\n",
    "        openint_bid = kargs['openinterest_bid']\n",
    "        openint_ask = kargs['openinterest_ask']\n",
    "\n",
    "        self.timestamps.append(timestamp)\n",
    "        self.bids.append(bid)\n",
    "        self.asks.append(ask)\n",
    "        self.openinterest_bid.append(openint_bid)\n",
    "        self.openinterest_ask.append(openint_ask)\n",
    "        #print(f\"----->tick added: ({self.timestamps[-1]},{self.bids[-1]},{self.asks[-1]})\")\n",
    "        #try:\n",
    "        #    printvv(\"{:<27} {:<10} {:<10}\".format(str(self.timestamps[-1]),str(self.bids[-1]),str(self.asks[-1])))\n",
    "        #except TypeError:\n",
    "        #    printvv(\"-----error------\")\n",
    "\n",
    "    def get_ohlc(self,timeframe,num_bars=-1):\n",
    "        data = self.get_dataframe(size=num_bars)#size=num_bars)\n",
    "        bid_ask_ohlc = ohlc_resample(data,timeframe)\n",
    "        return bid_ask_ohlc\n",
    "\n",
    "    def clear_all_data(self):\n",
    "        self.symbol = \"\"\n",
    "        self.timestamps.clear()\n",
    "        self.bids.clear()\n",
    "        self.asks.clear()\n",
    "        self.volume_bid.clear()\n",
    "        self.volume_ask.clear()\n",
    "        self.open_interest_bid.clear()\n",
    "        self.open_interest_ask.clear()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_TICKS = 10000\n",
    "\n",
    "def generate_fake_timestamps(num_ticks=10000):\n",
    "    d = dt.datetime.fromisoformat('2020-02-01 19:12:04.000000')\n",
    "    delta = dt.timedelta(milliseconds=100)\n",
    "    timestamps = []\n",
    "    for i in range(num_ticks):\n",
    "        d = d + delta\n",
    "        timestamps.append(d)\n",
    "    return timestamps\n",
    "        \n",
    "def generate_fake_bids_asks(num_ticks):\n",
    "    base_bid    = 1.1050\n",
    "    base_ask    = 1.1120\n",
    "    noise_sigma = 0.01\n",
    "    mu          = 0\n",
    "    \n",
    "    #add gaussian noise to simulate market movements\n",
    "    bid_noise   = np.random.normal(mu,noise_sigma,size=num_ticks)\n",
    "    ask_noise   = np.random.normal(mu,noise_sigma,size=num_ticks) + 0.025   #adding a shift up to make sure it is always higher than the bid price\n",
    "    bids = list(base_bid + bid_noise)\n",
    "    asks = list(base_ask + ask_noise)\n",
    "    \n",
    "    #for i in range(num_ticks):\n",
    "    #    pass\n",
    "    \n",
    "    return bids,asks\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f19dc46c090>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "timestamps = generate_fake_timestamps(NUM_TICKS)\n",
    "bids,asks  = generate_fake_bids_asks(NUM_TICKS)\n",
    "\n",
    "data = {\n",
    "    \"timestamp\":timestamps,\n",
    "    \"bid\"      :bids,\n",
    "    \"ask\"      :asks,\n",
    "}\n",
    "\n",
    "#just making a dataframe to check the data here\n",
    "df = pd.DataFrame(data=data)\n",
    "#df.set_index('timestamp')\n",
    "#df.index = pd.to_datetime(df.index)\n",
    "df[-50:].plot(x='timestamp',y=['bid','ask'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAEgCAYAAADVKCZpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAEVklEQVR4nO3VQQ0AIBDAMMC/58MDH7KkVbDf9swsAKg5vwMA4IWBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkGRgASQYGQJKBAZBkYAAkXUEcBT0Vb8A4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 6x4 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Below is my attempt at simulating market data streaming.\n",
    "from types import SimpleNamespace\n",
    "import threading\n",
    "\n",
    "datastream = DataStream()\n",
    "args = SimpleNamespace(\n",
    "        plot_mode         ='candle',\n",
    "        plot_refresh_rate = 100,    #in milliseconds\n",
    "        candle_width      = '5S', \n",
    "    )\n",
    "plotter        = Plotter(datastream,args)\n",
    "\n",
    "\n",
    "def stream_data(datastream,timestamps,bids,asks):\n",
    "    first_tick_idx = 0\n",
    "    for i in range(NUM_TICKS):\n",
    "        t,b,a = timestamps[i], bids[i], asks[i]\n",
    "        datastream.add_tick(timestamp=t, bid=b, ask=a)\n",
    "\n",
    "\n",
    "        candle_delta = dt.timedelta(seconds=5)\n",
    "        diff = timestamps[-1] - timestamps[first_tick_idx]\n",
    "        if diff > candle_delta:\n",
    "            #we have a new candle\n",
    "            first_tick_idx = i\n",
    "        time.sleep(0.05)\n",
    "\n",
    "def plot_data(plotter):\n",
    "    plotter.plot()\n",
    "            \n",
    "streaming_thread = threading.Thread(target=stream_data,args=(datastream,timestamps,bids,asks))\n",
    "plotting_thread  = threading.Thread(target=plot_data,args=(plotter,))\n",
    "\n",
    "streaming_thread.start()\n",
    "plotting_thread.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}