simulator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from wallet import Wallet\n",
    "import datetime\n",
    "from pymongo import MongoClient\n",
    "import time\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from coinoneTrader import get_orderbook, get_ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "978290"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client = MongoClient(\"mongodb://mongo-191809ff-1.673dca44.cont.dockerapp.io:32768\")\n",
    "db = client.coinone\n",
    "db.tickers.find().count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tickers_bson = db.tickers.find().limit(3000)\n",
    "tickers_dic = list(tickers_bson)\n",
    "tickers_df = pd.DataFrame(tickers_dic)\n",
    "tickers_df = tickers_df[['datetime', 'last']]\n",
    "tickers_df['datetime'] = pd.to_datetime(tickers_df['datetime'], \"%Y-%m-%d %h:%m:%s\")\n",
    "tickers_df = tickers_df.set_index('datetime')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tickers_df['last'] = tickers_df['last'].astype(np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# orderbooks_bson = db.orderbooks.find()\n",
    "# orderbooks_dic = list(orderbooks_bson)\n",
    "# orderbooks_df = pd.DataFrame(orderbooks_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "orderbooks_bson = db.orderbooks.find().limit(3000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def simulate(n_iter=10):\n",
    "\n",
    "    dict_lst = []\n",
    "\n",
    "    for i in range(n_iter):\n",
    "        orderbook = orderbooks_bson[i]\n",
    "        bid_df = pd.DataFrame(orderbook['bid'])\n",
    "        ask_df = pd.DataFrame(orderbook['ask'])\n",
    "        selected_time = pd.to_datetime(orderbook['timestamp'], unit ='s')\n",
    "    \n",
    "        try:\n",
    "\n",
    "            market_price = tickers_df.loc[selected_time, 'last']\n",
    "            \n",
    "        except:\n",
    "            continue\n",
    "        if type(market_price) == np.float64:\n",
    "            position, price = get_position(bid_df, ask_df, delta=10)\n",
    "            dict_lst.append({\n",
    "                'datetime': selected_time,\n",
    "                'market_price': market_price,\n",
    "                'bid_ask_position': position,\n",
    "                'price': price\n",
    "            })\n",
    "\n",
    "\n",
    "\n",
    "    tmp_df = pd.DataFrame(dict_lst)\n",
    "    tmp_df = tmp_df.set_index('datetime')\n",
    "    return tmp_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def bid_ask_ratio(series):\n",
    "    n_bid = np.sum(series == 'bid')\n",
    "    n_ask = np.sum(series == 'ask')\n",
    "    \n",
    "    if n_ask == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return n_bid / n_ask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1278306d0>"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x128d4e710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tmp_df = pd.read_csv(\"backst_90000.csv\", parse_dates=True, index_col='datetime')\n",
    "tmp_df.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime\n",
       "2018-01-06 19:44:49    ask\n",
       "2018-01-06 19:44:50    ask\n",
       "2018-01-06 19:44:52    ask\n",
       "2018-01-06 19:44:53    ask\n",
       "2018-01-06 19:44:55    ask\n",
       "Name: bid_ask_position, dtype: object"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp_df['bid_ask_position'].tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bid_ask_position = tmp_df['bid_ask_position'].resample('5S').apply(bid_ask_ratio)\n",
    "tmp_df = tmp_df.resample('5S').last()\n",
    "tmp_df['bid_ask_position'] = bid_ask_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_simul():\n",
    "    from wallet import Wallet\n",
    "    wallet = Wallet(kw=1000000)\n",
    "    # wallet.get_balance()\n",
    "\n",
    "    for index in range(tmp_df.shape[0]):\n",
    "\n",
    "        position_ratio = tmp_df.iloc[index,0]\n",
    "        market_price = tmp_df.iloc[index,1]\n",
    "        price = tmp_df.iloc[index,2]\n",
    "\n",
    "        if market_price == price:\n",
    "            if position_ratio == 0:\n",
    "                continue\n",
    "            elif position_ratio < 0.5:\n",
    "                wallet.sell_qtum(-1, market_price)\n",
    "            elif position_ratio > 2:\n",
    "                wallet.buy_qtum(-1, market_price)\n",
    "    return wallet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'kw': 0.0, 'qtum': 13.55184581976113}"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wallet = run_simul()\n",
    "wallet.get_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1055456.0260586319"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wallet.get_balance_in_kw(78000.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.020358306188925084"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wallet.total_transanction_fee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wallet.get_trasanction_n()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from coinoneTrader import get_orderbook, get_ticker\n",
    "from wallet import Wallet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_position(bid_df, ask_df, delta = 0):\n",
    "    bid_df = bid_df.astype(np.float)\n",
    "    ask_df = ask_df.astype(np.float)\n",
    "    n_ask_influencer = ask_df[ask_df.qty > 50000]['price'].count()\n",
    "    n_bid_influencer = bid_df[bid_df.qty > 50000]['price'].count()\n",
    "\n",
    "    print('bid-ask-qty: ' + str(np.sum(bid_df.qty)) + ' / ' + str(np.sum(ask_df.qty)))\n",
    "    print('')\n",
    "    \n",
    "    print('bid front: ')\n",
    "    print(str(bid_df[['qty', 'price']].head(1)))\n",
    "    print('')\n",
    "    print('ask front: ')\n",
    "    print(str(ask_df[['qty', 'price']].head(1)))\n",
    "    print('')\n",
    "    \n",
    "    gap = abs(n_bid_influencer - n_ask_influencer)\n",
    "    print('bid-ask: ' + str(n_bid_influencer) + '/' + str(n_ask_influencer) + ' [' + str(gap) + ']')\n",
    "    \n",
    "    if n_bid_influencer > 1.1 * n_ask_influencer:\n",
    "        return (\"bid\", np.max(bid_df['price']) + delta)\n",
    "    elif n_bid_influencer * 1.1 < n_ask_influencer:\n",
    "        return (\"ask\", np.min(ask_df['price']) - delta)\n",
    "    else:\n",
    "        return (\"tied\", np.nan)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "COIN_NAME = 'xrp'\n",
    "wallet = Wallet(kw=1000000)\n",
    "while True:\n",
    "    try:\n",
    "        print(\"------------------\")\n",
    "        ticker = get_ticker(COIN_NAME)\n",
    "\n",
    "\n",
    "        market_price = float(ticker['last'])\n",
    "\n",
    "        orderbook = get_orderbook(COIN_NAME)\n",
    "        ask_pd = pd.DataFrame(orderbook['ask'])\n",
    "        ask_price = float(ask_pd.iloc[0, 0])\n",
    "\n",
    "        bid_pd = pd.DataFrame(orderbook['bid'])\n",
    "        bid_price = float(bid_pd.iloc[0, 0])\n",
    "    except:\n",
    "        continue\n",
    "    \n",
    "    position, price = get_position(bid_pd, ask_pd)\n",
    "    price = float(price)\n",
    "\n",
    "    print('')\n",
    "    print('market / price : ' + str(market_price) + ' / ' + str(price) + ' ['+ str(abs(market_price - price)) +']')\n",
    "    print('')\n",
    "\n",
    "\n",
    "    if position == 'ask' and ((ask_price == market_price) or (ask_price <= bid_price and bid_price - 20 <= ask_price)):\n",
    "#         if position == 'ask':\n",
    "#     if position == 'ask' and ((ask_price == market_price) or (ask_price == bid_price)):\n",
    "        print(position + ' sold')\n",
    "        print('')\n",
    "        wallet.sell_qtum(-1, market_price)\n",
    "\n",
    "#     if position == 'bid' and ((bid_price == market_price) or (bid_price == ask_price)): \n",
    "    if position == 'bid' and ((bid_price == market_price) or (bid_price >= ask_price and ask_price + 20 >= bid_price)):\n",
    "\n",
    "        print(position + ' bought')\n",
    "        print('')\n",
    "        wallet.buy_qtum(-1, market_price)\n",
    "\n",
    "\n",
    "    \n",
    "    print(wallet.get_balance())\n",
    "    print('')\n",
    "    print(wallet.get_balance_in_kw(market_price))\n",
    "    time.sleep(0.8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72010"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def transform(index):\n",
    "    tmp_selected = orderbooks_bson[index]\n",
    "    tmp_selected_ask = pd.DataFrame(tmp_selected['ask'])\n",
    "    tmp_selected_ask['timestamp'] = tmp_selected['timestamp']\n",
    "    tmp_selected_ask['bid_ask'] = 'ask'\n",
    "\n",
    "    tmp_selected_bid = pd.DataFrame(tmp_selected['bid'])\n",
    "    tmp_selected_bid['timestamp'] = tmp_selected['timestamp']\n",
    "    tmp_selected_bid['bid_ask'] = 'bid'\n",
    "    return (tmp_selected_ask, tmp_selected_bid)\n",
    "transformed_lst = []\n",
    "\n",
    "for i in range(10000):\n",
    "    transformed_ask, transformed_bid = transform(i)\n",
    "    transformed_lst.append(transformed_ask)\n",
    "    transformed_lst.append(transformed_bid)\n",
    "    \n",
    "transformed_df = pd.concat(transformed_lst)\n",
    "transformed_df.to_csv(\"../rawdata/tranformed_df.csv\")\n",
    "transformed_df.head(10)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}