ByBit 25x EOSUSD High Frequency Trading Strategy 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have 125 days EOSUSD data available\n",
    "\n",
    "lookback_period = 100\n",
    "correlation_coefficient = 0.8\n",
    "band_height = 3.5\n",
    "stop = 0.35  \n",
    "\n",
    "latest_close = 0\n",
    "entry_price = 0\n",
    "wallet = 100\n",
    "margin = 25\n",
    "fee = 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread\n",
    "import matplotlib as plt\n",
    "from copy import deepcopy\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from copy import deepcopy\n",
    "import math\n",
    "from scipy.stats import linregress\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "klineslists = pd.read_csv(\"./klinelists.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "eosusds = klineslists[(klineslists.symbol==\"EOSUSD\")]\n",
    "eos_1m = eosusds[(eosusds.interval==1)]\n",
    "eos_1m = eos_1m.sort_values(by=['open_time'], ascending=True)[250000:]\n",
    "eos_1m = eos_1m.rename(columns={'open_time': 'timestamp'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BattleFieldSituation(object):\n",
    "    SHORTENTRY = \"shortentry\"\n",
    "    LONGENTRY = \"longentry\"\n",
    "    SHORTEXIT = \"shortexit\"\n",
    "    LONGEXIT = \"longexit\"\n",
    "\n",
    "class TradingStrategy(object):\n",
    "    def __init__(self, klines_list, interval, symbol):\n",
    "        self._interval = interval\n",
    "        self._symbol = symbol\n",
    "        self._klines = self.__check_kline_list(klines_list)\n",
    "\n",
    "    def __str__(self):\n",
    "        print(\"%s:INFO: average volume is %s for symbol %s:\" % (__name__, self.average_volume(), self._symbol))\n",
    "        print(\"%s:INFO:latest high is %s for symbol %s:\" % (__name__, self.latest_high(), self._symbol))\n",
    "        print(\"%s:INFO:latest low is %s for symbol %s:\" % (__name__, self.latest_low(), self._symbol))\n",
    "        print(\"%s:INFO:latest open is %s for symbol %s:\" % (__name__, self.latest_open(), self._symbol))\n",
    "        print(\"%s:INFO:latest close is %s for symbol %s:\" % (__name__, self.latest_close(), self._symbol))\n",
    "        print(\"%s:INFO:latest volume is %s for symbol %s:\" % (__name__, self.latest_volume(), self._symbol))\n",
    "        print(\"%s:INFO:latest timestamp is %s for symbol %s:\" % (__name__, self.latest_timestamp(), self._symbol))\n",
    "        print(\"%s:INFO:latest volume greater than average is %s for symbol %s:\" % (\n",
    "            __name__, self.latest_volume_greater_than_average(), self._symbol))\n",
    "\n",
    "    @staticmethod\n",
    "    def __check_kline_list(klines_list):\n",
    "        \"\"\"\n",
    "        :param klines_list:\n",
    "        [{\n",
    "            \"open\": 10293.0\n",
    "            \"close\": 15680.0,\n",
    "            \"high\": 15690.0,\n",
    "            \"low\": 15670.0,\n",
    "            \"volume\": \"3\",\n",
    "            \"timestamp\": 1569041656,\n",
    "            \"interval\": \"1m\"\n",
    "        }]\n",
    "        :exception: ValueError:\n",
    "        WARNING: **WE DO NOT CHECK WHETHER THE LIST IS SORTED :) It's your duty to sort the list in ASC order**\n",
    "        WELL :) just a joke, we sort it for you base on timestamp\n",
    "        :return: {list} klines_list\n",
    "        \"\"\"\n",
    "        klines_list = sorted(deepcopy(klines_list), key=lambda k: k[\"timestamp\"])\n",
    "        if not isinstance(klines_list, list):\n",
    "            raise ValueError(\"klines_list is not a list\")\n",
    "        if not 10 <= len(klines_list) <= 5000:\n",
    "            raise ValueError(\"kline_list length is not between 10 and 5000\")\n",
    "        for i in klines_list:\n",
    "            if \"open\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" open \\\" key\")\n",
    "            if \"close\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" close \\\" key\")\n",
    "            if \"high\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" high \\\" key\")\n",
    "            if \"low\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" low \\\" key\")\n",
    "            if \"volume\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" volume \\\" key\")\n",
    "            if \"timestamp\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" timestamp \\\" key\")\n",
    "            if \"interval\" not in i:\n",
    "                raise ValueError(\"Some element in kline_list does not contain \\\" interval \\\" key\")\n",
    "        return klines_list\n",
    "\n",
    "    def latest_high(self):\n",
    "        return self._klines[-1][(\"high\")]\n",
    "\n",
    "    def latest_low(self):\n",
    "        return self._klines[-1][\"low\"]\n",
    "\n",
    "    def latest_open(self):\n",
    "        return self._klines[-1][\"open\"]\n",
    "\n",
    "    def latest_close(self):\n",
    "        return self._klines[-1][\"close\"]\n",
    "\n",
    "    def latest_volume(self):\n",
    "        return self._klines[-1][\"volume\"]\n",
    "\n",
    "    def latest_timestamp(self):\n",
    "        return self._klines[-1][\"timestamp\"]\n",
    "\n",
    "    def latest_interval(self):\n",
    "        return self._klines[-1][\"interval\"]\n",
    "\n",
    "    def average_volume(self):\n",
    "        \"\"\"\n",
    "        This function returns the average volume of klines_list,\n",
    "        :return: float\n",
    "        \"\"\"\n",
    "        volumes = []\n",
    "        for i in self._klines:\n",
    "            volumes.append(int(i.get(\"volume\")))\n",
    "        return float(np.mean(volumes))\n",
    "\n",
    "    def latest_volume_greater_than_average(self):\n",
    "        \"\"\"\n",
    "        Whether the current volume is greater than the mean volume\n",
    "        :return: True or False\n",
    "        \"\"\"\n",
    "        last_volume = int(self.latest_volume())\n",
    "        avg_vol = self.average_volume()\n",
    "\n",
    "        return True if last_volume > avg_vol else False\n",
    "\n",
    "    def symbol_name(self):\n",
    "        return self._symbol\n",
    "\n",
    "class LinearRegressionStrategy(TradingStrategy):\n",
    "    _MINIMUM_KLINE_NUMBER = 10\n",
    "    _MAXIMUM_KLINE_NUMBER = 1000\n",
    "    _UPPER_BAND_HEIGHT = 1.8\n",
    "    _LOWER_BAND_HEIGHT = 2\n",
    "    _STRONG_UPTREND_CORRELATION_COEFFICIENT_LIMIT = 0.3\n",
    "    _STRONG_DOWNTREND_CORRELATION_COEFFICIENT_LIMIT = -0.3\n",
    "    _REGRESSION_SOURCE = \"close\"\n",
    "\n",
    "    def __init__(self, klines_list, interval, symbol, ub, lb, cor):\n",
    "        TradingStrategy.__init__(self, klines_list, interval, symbol)\n",
    "        self._UPPER_BAND_HEIGHT = ub\n",
    "        self._LOWER_BAND_HEIGHT = lb\n",
    "        self._STRONG_UPTREND_CORRELATION_COEFFICIENT_LIMIT = cor\n",
    "        self._STRONG_DOWNTREND_CORRELATION_COEFFICIENT_LIMIT = -cor\n",
    "        self._dn = float()  # upper deviation: self._reg_m * len(self.klines) + self._reg_c - self._dn\n",
    "        self._up = float()  # lower deviation: self._reg_m * len(self.klines) + self._reg_c + self._up\n",
    "        self._reg_m = float()  # factor value\n",
    "        self._reg_c = float()  # offset value\n",
    "        self._reg_r = float()  # correlation coefficient value\n",
    "        self._reg_p = float()  # Pearson value\n",
    "        self._reg_sd = float()  # standard deviation value\n",
    "        self.__run()\n",
    "\n",
    "    def __run(self):\n",
    "        x_list = range(len(self._klines))\n",
    "        y_list = []\n",
    "        for i in self._klines:\n",
    "            y_list.append(float(i[self._REGRESSION_SOURCE]))\n",
    "\n",
    "        deviationSum = 0\n",
    "        slope, intercept, r_value, p_value, std_err = linregress(x_list, y_list)\n",
    "        for count, i in enumerate(self._klines):\n",
    "            deviationSum += (float(i[self._REGRESSION_SOURCE]) - (slope * count + intercept)) ** 2\n",
    "        deviation = math.sqrt(deviationSum / len(self._klines))\n",
    "        self._dn = deviation * self._UPPER_BAND_HEIGHT\n",
    "        self._up = deviation * self._LOWER_BAND_HEIGHT\n",
    "        self._reg_m = slope\n",
    "        self._reg_c = intercept\n",
    "        self._reg_r = r_value\n",
    "        self._reg_p = p_value\n",
    "        self._reg_sd = std_err\n",
    "\n",
    "    def __str__(self):\n",
    "        super().__str__()\n",
    "        print(\n",
    "            \"%s:INFO: latest upper band price is %s for symbol %s:\" % (\n",
    "                __name__, self.latest_upper_band_price(), self._symbol))\n",
    "        print(\n",
    "            \"%s:INFO: latest lower band price is %s for symbol %s:\" % (\n",
    "                __name__, self.latest_lower_band_price(), self._symbol))\n",
    "        print(\"%s:INFO: is strong uptrend is %s for symbol %s:\" % (__name__, self.is_strong_uptrend(), self._symbol))\n",
    "        print(\n",
    "            \"%s:INFO: is strong downtrend is %s for symbol %s:\" % (__name__, self.is_strong_downtrend(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Factor is %s for symbol %s:\" % (\n",
    "            __name__, self.regression_factor(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Offset is %s for symbol %s:\" % (\n",
    "            __name__, self.regression_offset(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Correlation Coefficient is %s for symbol %s:\" % (\n",
    "            __name__, self.regression_correlation_coefficient(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Pearson Value is %s for symbol %s: \" % (\n",
    "            __name__, self.regression_pearson_value(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Standard Deviation is %s for symbol %s: \" % (\n",
    "            __name__, self.regression_standard_deviation(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Upper Band Height is %s for symbol %s: \" % (\n",
    "            __name__, self.regression_upper_band_height(), self._symbol))\n",
    "        print(\"%s:INFO: Linear Regression Lower Band Height is %s for symbol %s: \" % (\n",
    "            __name__, self.regression_lower_band_height(), self._symbol))\n",
    "        print(\"%s:INFO: Is outside channel is %s for symbol %s:\" % (__name__, self.is_outside_channel(), self._symbol))\n",
    "        print(\"%s:INFO: Is price higher than upper band is %s for symbol %s:\" % (\n",
    "            __name__, self.is_price_higher_than_upper_band(), self._symbol))\n",
    "        print(\"%s:INFO: Is price lower than lower band is %s for symbol %s:\" % (\n",
    "            __name__, self.is_price_lower_than_lower_band(), self._symbol))\n",
    "\n",
    "    def regression_factor(self):\n",
    "        return float(self._reg_m)\n",
    "\n",
    "    def regression_offset(self):\n",
    "        return float(self._reg_c)\n",
    "\n",
    "    def regression_correlation_coefficient(self):\n",
    "        return float(self._reg_r)\n",
    "\n",
    "    def regression_pearson_value(self):\n",
    "        return float(self._reg_p)\n",
    "\n",
    "    def regression_standard_deviation(self):\n",
    "        return float(self._reg_sd)\n",
    "\n",
    "    def regression_upper_band_height(self):\n",
    "        return float(self._up)\n",
    "\n",
    "    def regression_lower_band_height(self):\n",
    "        return float(self._dn)\n",
    "\n",
    "    def latest_upper_band_price(self):\n",
    "        \"\"\"\n",
    "        :return: {float} The Minimum Entry Price of Short Loot, The Upper Band\n",
    "        \"\"\"\n",
    "        return float(self._reg_m * len(self._klines) + self._reg_c + self._up)\n",
    "\n",
    "    def latest_lower_band_price(self):\n",
    "        \"\"\"\n",
    "        :return: {float} The Maximum Entry Price of Long Loot, The Lower Band\n",
    "        \"\"\"\n",
    "        return float(self._reg_m * len(self._klines) + self._reg_c - self._dn)\n",
    "\n",
    "    def latest_regression_line_price(self):\n",
    "        \"\"\"\n",
    "        :return: {float} The latest regression line\n",
    "        \"\"\"\n",
    "        return float(self._reg_m * len(self._klines) + self._reg_c)\n",
    "\n",
    "    def is_strong_uptrend(self):\n",
    "        \"\"\"\n",
    "        Whether the battlefield is in a strong uptrend\n",
    "        :return: True or False\n",
    "        \"\"\"\n",
    "        if self._reg_r >= self._STRONG_UPTREND_CORRELATION_COEFFICIENT_LIMIT:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_strong_downtrend(self):\n",
    "        \"\"\"\n",
    "        Whether the battlefield is in a strong downtrend\n",
    "        :return: True or False\n",
    "        \"\"\"\n",
    "        if self._reg_r <= self._STRONG_DOWNTREND_CORRELATION_COEFFICIENT_LIMIT:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_outside_channel(self):\n",
    "        \"\"\"\n",
    "        If close greater than upperband or lower than lowerband\n",
    "        :return: True or False\n",
    "        \"\"\"\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price < self.latest_lower_band_price() or \\\n",
    "                close_price > self.latest_upper_band_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_inside_channel(self):\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price > self.latest_lower_band_price() or \\\n",
    "                close_price < self.latest_upper_band_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_price_higher_than_upper_band(self):\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price > self.latest_upper_band_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_price_lower_than_lower_band(self):\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price < self.latest_lower_band_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_price_higher_than_regression_line(self):\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price > self.latest_regression_line_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def is_price_lower_than_regression_line(self):\n",
    "        close_price = float(self.latest_close())\n",
    "        if close_price < self.latest_regression_line_price():\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "class BurningHouseStrategy(LinearRegressionStrategy):\n",
    "\n",
    "    # noinspection SpellCheckingInspection,PyPep8Naming\n",
    "    def __init__(self, klines_list, interval, symbol, ub, lb, cor):\n",
    "        \"\"\"\"\n",
    "        NOTE: This is a strategy that is well suited for day trading,\n",
    "        for example, in crypto market, the sensor senses the chaos moment\n",
    "        in the market and returns some useful info for trading bot to trade\n",
    "        the ticker\n",
    "        NOTE: This strategy DOES NOT provide stop loss info, you need to\n",
    "        calculate the stop loss price according to your leverage.\n",
    "        CAPABILITY: From 0.02 BTC with 10x to 20x Leverage to up to 100K USD\n",
    "        :param {list} klines_list:\n",
    "        [{\n",
    "            \"high\": \"15690\",\n",
    "            \"low\": \"15670\",\n",
    "            \"close\": \"15680\",\n",
    "            \"timestamp\": 1569041656,\n",
    "            \"interval\": \"1m\"\n",
    "            \"volume\": \"3\",\n",
    "        },{...}]\n",
    "        :param {str} interval\n",
    "        :param {str} symbol\n",
    "        \"\"\"\n",
    "        LinearRegressionStrategy.__init__(self, deepcopy(klines_list), interval, symbol, ub, lb, cor)\n",
    "\n",
    "    # noinspection SpellCheckingInspection\n",
    "    def __str__(self):\n",
    "        LinearRegressionStrategy.__str__(self)\n",
    "        print(\"%s:INFO: Battlefield Situation is %s for symbol %s:\" % (\n",
    "            __name__, self.battlefield_situtation(), self._symbol))\n",
    "        print(\"%s:INFO: Latest Exit Price is %s for symbol %s:\" % (__name__, self.latest_exit_price(), self._symbol))\n",
    "        return \"\"\n",
    "\n",
    "    # noinspection SpellCheckingInspection\n",
    "    def battlefield_situtation(self) -> str:\n",
    "        \"\"\"\n",
    "        Whether the sensor saw a fire in battlefield\n",
    "        \"\"\"\n",
    "        if self.is_strong_uptrend() and \\\n",
    "                self.is_outside_channel() and \\\n",
    "                self.is_price_higher_than_upper_band():\n",
    "            return BattleFieldSituation.SHORTENTRY\n",
    "        elif self.is_strong_downtrend() and \\\n",
    "                self.is_outside_channel() and \\\n",
    "                self.is_price_lower_than_lower_band():\n",
    "            return BattleFieldSituation.LONGENTRY\n",
    "        elif self.is_inside_channel() and \\\n",
    "                self.is_price_higher_than_regression_line():\n",
    "            return BattleFieldSituation.LONGEXIT\n",
    "        elif self.is_inside_channel() and \\\n",
    "                self.is_price_lower_than_regression_line():\n",
    "            return BattleFieldSituation.SHORTEXIT\n",
    "        else: \n",
    "            return None\n",
    "\n",
    "    def latest_exit_price(self):\n",
    "        return self.regression_factor() * len(self._klines) + self.regression_offset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "metadata": {},
   "outputs": [],
   "source": [
    "offset = 0\n",
    "data_feed = eos_1m[offset:4000]\n",
    "lookback_period = 100\n",
    "correlation_coefficient = 0.8\n",
    "band_height = 3.5\n",
    "stop = 0.35  # 0.3% stop\n",
    "\n",
    "latest_close = 0\n",
    "entry_price = 0\n",
    "wallet = 100\n",
    "margin = 25\n",
    "fee = 0  # 0.1% fee\n",
    "\n",
    "gain = 0\n",
    "loss = 0\n",
    "rpnl = 0\n",
    "\n",
    "position = 'n' # 'l' 's' 'n'\n",
    "upnl = 0 # unrealized PnL 0%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x25e71550>"
      ]
     },
     "execution_count": 470,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_feed.plot(x=\"timestamp\", y=\"close\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(data_feed)-lookback_period-1):\n",
    "    klines_list=list(data_feed[i:i+lookback_period].T.to_dict().values())\n",
    "    bhs = BurningHouseStrategy(klines_list=klines_list, interval=\"1\", symbol=\"EOSUSD\", ub=band_height, lb=band_height, cor=correlation_coefficient)\n",
    "    latest_close = bhs.latest_close()\n",
    "    \n",
    "    if position == 'n':\n",
    "        if bhs.battlefield_situtation() == BattleFieldSituation.SHORTENTRY:\n",
    "            position = 's'\n",
    "            entry_price = latest_close\n",
    "        elif bhs.battlefield_situtation() == BattleFieldSituation.LONGENTRY:\n",
    "            position = 'l'\n",
    "            entry_price = latest_close\n",
    "        else:\n",
    "            # No trade to make, please wait for pump and dump\n",
    "            pass \n",
    "        \n",
    "    elif position == 's' or position == 'l':\n",
    "        if position == 'l':\n",
    "            upnl = (latest_close - entry_price) / entry_price * 100\n",
    "        elif position == 's':\n",
    "            upnl = -(latest_close - entry_price) / entry_price * 100\n",
    "            \n",
    "        if upnl >= stop:\n",
    "            gain+=1\n",
    "            position='n'\n",
    "            rpnl += upnl\n",
    "            wallet = wallet - wallet * margin * fee / 100\n",
    "            wallet = wallet + wallet * margin * upnl / 100\n",
    "            wallet = wallet - wallet * margin * fee / 100\n",
    "        elif upnl <= -stop:\n",
    "            loss+=1\n",
    "            position='n'\n",
    "            rpnl += upnl\n",
    "            wallet = wallet - wallet * margin * fee / 100\n",
    "            wallet = wallet + wallet * margin * upnl / 100\n",
    "            wallet = wallet - wallet * margin * fee / 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 472,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8889737276285642"
      ]
     },
     "execution_count": 472,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rpnl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 473,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 473,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 474,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102.8162766353627"
      ]
     },
     "execution_count": 475,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wallet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}