examples/HarmoCurrent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:25.659999Z",
     "start_time": "2023-01-07T23:12:25.545687Z"
    },
    "init_cell": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "import matplotlib\n",
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "#%matplotlib notebook\n",
    "#%matplotlib widget\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:25.748099Z",
     "start_time": "2023-01-07T23:12:25.663793Z"
    },
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "import logging\n",
    "import signal, threading, os, time\n",
    "import logging\n",
    "\n",
    "from IPython.core.debugger import set_trace\n",
    "from IPython.terminal.embed import embed\n",
    "\n",
    "import os, sys\n",
    "\n",
    "\n",
    "import ccxt\n",
    "import pandas as pd\n",
    "\n",
    "logger = logging.getLogger('notebook')\n",
    "logger.setLevel(logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:25.842974Z",
     "start_time": "2023-01-07T23:12:25.751353Z"
    },
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "import mplfinance as mpf\n",
    "#matplotlib.use('Agg')\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [8, 12]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:25.939296Z",
     "start_time": "2023-01-07T23:12:25.846489Z"
    },
    "code_folding": [
     9
    ],
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "\n",
    "try:\n",
    "    from settings import HTTP_PROXY\n",
    "except ImportError:\n",
    "    HTTP_PROXY = None\n",
    "    \n",
    "# (!!!)You should change this according to your network environment\n",
    "if HTTP_PROXY is None:\n",
    "    HTTP_PROXY = 'http://127.0.0.1:1087'    \n",
    "\n",
    "def kline_to_df(arr) -> pd.DataFrame:\n",
    "    kline = pd.DataFrame(\n",
    "        arr,\n",
    "        columns=['ts', 'open', 'high', 'low', 'close', 'volume' ])\n",
    "    kline.index = pd.to_datetime(kline.ts, unit='ms')\n",
    "    kline.drop('ts', axis=1, inplace=True)\n",
    "    return kline\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:26.022225Z",
     "start_time": "2023-01-07T23:12:25.942116Z"
    },
    "code_folding": [],
    "init_cell": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "PROXIES = {\n",
    "    'http': HTTP_PROXY,\n",
    "    'https': HTTP_PROXY,\n",
    "}\n",
    "\n",
    "ccxt_options = {'proxies': PROXIES}\n",
    "\n",
    "ok = 'okex'\n",
    "bn = 'binance'\n",
    "\n",
    "client_list = [bn, ok]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step by Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:35.936358Z",
     "start_time": "2023-01-07T23:12:35.160500Z"
    }
   },
   "outputs": [],
   "source": [
    "# prepare client\n",
    "binance = getattr(ccxt, 'binance')(ccxt_options)\n",
    "markerts = binance.load_markets()\n",
    "symbol = 'BTC/USDT'\n",
    "period = '4h'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:36.660188Z",
     "start_time": "2023-01-07T23:12:36.278189Z"
    }
   },
   "outputs": [],
   "source": [
    "# fetch raw kline data via ccxt unified api\n",
    "kline_data = binance.fetch_ohlcv(symbol, period, limit=1000)\n",
    "\n",
    "kline = kline_to_df(kline_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:37.083300Z",
     "start_time": "2023-01-07T23:12:37.002885Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw ccxt kline data:\n",
      " [[1658736000000, 21962.33, 22110.98, 21868.36, 21941.25, 22048.18138], [1658750400000, 21942.18, 22003.12, 21683.4, 21895.79, 32159.10297], [1658764800000, 21893.94, 22021.47, 21552.53, 21890.17, 27200.4675], [1658779200000, 21892.66, 22259.98, 21250.0, 21310.9, 43229.18467]]\n"
     ]
    }
   ],
   "source": [
    "print('raw ccxt kline data:\\n', kline_data[:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:37.503897Z",
     "start_time": "2023-01-07T23:12:37.432331Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convert to dataframe:\n",
      "                          open      high       low     close       volume\n",
      "ts                                                                      \n",
      "2022-07-25 08:00:00  21962.33  22110.98  21868.36  21941.25  22048.18138\n",
      "2022-07-25 12:00:00  21942.18  22003.12  21683.40  21895.79  32159.10297\n",
      "2022-07-25 16:00:00  21893.94  22021.47  21552.53  21890.17  27200.46750\n",
      "2022-07-25 20:00:00  21892.66  22259.98  21250.00  21310.90  43229.18467\n"
     ]
    }
   ],
   "source": [
    "print('convert to dataframe:\\n', kline[:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:39.898580Z",
     "start_time": "2023-01-07T23:12:37.843840Z"
    }
   },
   "outputs": [],
   "source": [
    "patterns, predict_patterns = detector.search_patterns(kline, only_last=False, last_n=4, plot=False, predict=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:40.288715Z",
     "start_time": "2023-01-07T23:12:40.216987Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BTC/USDT 4h \n",
      "patterns found: [Timestamp('2022-08-17 04:00:00'), Timestamp('2022-08-20 20:00:00'), Timestamp('2022-08-21 20:00:00'), Timestamp('2022-08-23 04:00:00'), Timestamp('2022-08-24 16:00:00')], [['H', 24446.71, 137], ['L', 20761.9, 159], ['H', 21800.0, 165], ['L', 20890.14, 173], ['H', 21900.0, 182]], \n",
      " bearish abcd, {'AB': 0.8764666217127463, 'BC': 1.1099070186622118, 'AB=CD': 0.9727964550621349}\n",
      "BTC/USDT 4h \n",
      "patterns found: [Timestamp('2022-08-15 00:00:00'), Timestamp('2022-08-20 20:00:00'), Timestamp('2022-08-21 20:00:00'), Timestamp('2022-08-23 04:00:00'), Timestamp('2022-08-24 16:00:00')], [['H', 25211.32, 124], ['L', 20761.9, 159], ['H', 21800.0, 165], ['L', 20890.14, 173], ['H', 21900.0, 182]], \n",
      " bearish abcd, {'AB': 0.8764666217127463, 'BC': 1.1099070186622118, 'AB=CD': 0.9727964550621349}\n",
      "BTC/USDT 4h \n",
      "patterns found: [Timestamp('2022-10-04 20:00:00'), Timestamp('2022-10-13 12:00:00'), Timestamp('2022-10-14 00:00:00'), Timestamp('2022-10-21 12:00:00'), Timestamp('2022-10-29 08:00:00')], [['H', 20475.0, 429], ['L', 18190.0, 481], ['H', 19951.87, 484], ['L', 18650.0, 529], ['H', 21085.0, 576]], \n",
      " bearish butterfly, {'XAB': 0.7710590809628004, 'XAD': 1.2669584245076586, 'ABC': 0.7389137677581205, 'BCD': 1.8703864441150053, 'AB=CD': 1.3820542945847316}\n"
     ]
    }
   ],
   "source": [
    "for pat in patterns:\n",
    "    msg = f'{symbol} {period} \\npatterns found: {pat[1]}, {pat[0]}, \\n {pat[2]}, {pat[3]}'\n",
    "    print(msg)\n",
    "\n",
    "\n",
    "for pat in predict_patterns:\n",
    "    msg = '\\n'.join([f'{p} {v}' for p,v in list(zip([str(dt) for dt in pat[1]], [p for p in pat[0]]))])\n",
    "    msg = f'{symbol} {period} {msg} {pat[2]} {pat[3]}'\n",
    "    print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "###  Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T23:12:26.120221Z",
     "start_time": "2023-01-07T23:12:26.025441Z"
    },
    "code_folding": [],
    "hidden": true,
    "init_cell": true,
    "run_control": {
     "marked": true
    }
   },
   "outputs": [],
   "source": [
    "from harmonic_functions import HarmonicDetector\n",
    "#from HarmonicPatterns.harmonic import send_alert, search_function\n",
    "from functools import partial\n",
    "import time\n",
    "from multiprocessing import Pool\n",
    "\n",
    "PERIODS = ['1h', '4h', '1d']\n",
    "\n",
    "################\n",
    "# HarmonicDetector params\n",
    "# err_allowed: The error rate that detector would allow, usually 0.05 < err_rate < 0.1\n",
    "# strict: for example 0.618 * (1 - err_rate) < pattern < 0.618 * (1 + err_rate), the base should be a fibbonacci number, like 0.382, 0.618, 0.786, 1.618....\n",
    "# predict_err_rate: # similiar to err_allowed but used in predict\n",
    "\n",
    "\n",
    "################\n",
    "# search params\n",
    "# only_last: find patterns in history or not\n",
    "# symbols: symbols list to find\n",
    "# periods: periods that used in ccxt\n",
    "# last_n: if only_last is set, how near should the bar be\n",
    "# alert: send alerts when patterns found\n",
    "# plot: plot patterns when patterns found\n",
    "def search_function(detector, exchange_id, symbols, periods=PERIODS, ccxt_args={}, savefig=False, predict=True, only_last=False, alert=False, plot=True):\n",
    "    client = getattr(ccxt, exchange_id)(ccxt_args)\n",
    "    client.load_markets()\n",
    "    RETRY_TIMES=3\n",
    "    for symbol in symbols:\n",
    "        for period in periods:\n",
    "            print(f'------------------calculating {symbol} {period}------------------')\n",
    "            retry = RETRY_TIMES\n",
    "            while retry>0:\n",
    "                try:\n",
    "                    df = kline_to_df(client.fetch_ohlcv(symbol, period, limit=1000))\n",
    "\n",
    "                    patterns, predict_patterns = detector.search_patterns(df, only_last=only_last, last_n=4, plot=plot, predict=predict)\n",
    "                    break\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "                    retry -= 1\n",
    "                    if retry==0: raise\n",
    "                    continue\n",
    "            for pat in patterns:\n",
    "                msg = f'{symbol} {period} \\npatterns found: {pat[1]}, {pat[0]}, \\n {pat[2]}, {pat[3]}'\n",
    "                print(msg)\n",
    "                if alert and pat[0][-1][2] == len(df)-1:\n",
    "                    send_alert(f'Pattern_Found_{symbol}_{period}', msg)\n",
    "\n",
    "            for pat in predict_patterns:\n",
    "                msg = '\\n'.join([f'{p} {v}' for p,v in list(zip([str(dt) for dt in pat[1]], [p for p in pat[0]]))])\n",
    "                msg = f'{symbol} {period} {msg} {pat[2]} {pat[3]}'\n",
    "                print(msg)\n",
    "                if alert:\n",
    "                    send_alert(f'Pattern_Predict_{symbol}_{period}', msg)\n",
    "\n",
    "\n",
    "detector = HarmonicDetector(error_allowed=0.07, strict=True, predict_err_rate=0.07)\n",
    "search = partial(search_function, detector, ccxt_args=ccxt_options, only_last=False, plot=True)\n",
    "\n",
    "#PERIODS = ['5m','15m', '30m']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  DETECT BTC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T22:59:52.333500Z",
     "start_time": "2023-01-07T22:59:42.268411Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "s = ['BTC/USDT', 'ETH/USDT']\n",
    "search('binance', s, periods = ['1h', '4h'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  BTC USDT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-07T22:47:19.358619Z",
     "start_time": "2023-01-07T22:47:17.448137Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "s = ['BTC/USDT']\n",
    "\n",
    "search(ok, s, periods=['1h', '4h'], predict=True, only_last=False, alert=False, plot=True)\n"
   ]
  }
 ],
 "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.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}