mablue/zigzag-by-moving-averages.ipynb

## zigzag-by-moving-averages.ipynb
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ZigZag By Moving Averages.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMFKWOF8vfpch3TJoT6FXVd",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/mablue/912df3839136bd9bd77daa1f5597210b/zigzag-by-moving-averages.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Make Zigzag plot by random charts cross\n",
        "by: Masoud Azizi @mablue mablue92@gmail.com"
      ],
      "metadata": {
        "id": "RuNHSX7kjegL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Install ccxt and pandas and scikit"
      ],
      "metadata": {
        "id": "i0-4EIS8saGX"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 143,
      "metadata": {
        "id": "yqbl6fQap5rz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9675f41e-0390-4ba8-df1d-4776270cf3c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: ccxt in /usr/local/lib/python3.7/dist-packages (1.92.17)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (1.3.5)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.21.6)\n",
            "Requirement already satisfied: mplfinance in /usr/local/lib/python3.7/dist-packages (0.12.9b1)\n",
            "Requirement already satisfied: requests>=2.18.4 in /usr/local/lib/python3.7/dist-packages (from ccxt) (2.23.0)\n",
            "Requirement already satisfied: cryptography>=2.6.1 in /usr/local/lib/python3.7/dist-packages (from ccxt) (37.0.4)\n",
            "Requirement already satisfied: setuptools>=60.9.0 in /usr/local/lib/python3.7/dist-packages (from ccxt) (64.0.3)\n",
            "Requirement already satisfied: certifi>=2018.1.18 in /usr/local/lib/python3.7/dist-packages (from ccxt) (2022.6.15)\n",
            "Requirement already satisfied: aiodns>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from ccxt) (3.0.0)\n",
            "Requirement already satisfied: yarl==1.7.2 in /usr/local/lib/python3.7/dist-packages (from ccxt) (1.7.2)\n",
            "Requirement already satisfied: aiohttp>=3.8 in /usr/local/lib/python3.7/dist-packages (from ccxt) (3.8.1)\n",
            "Requirement already satisfied: idna>=2.0 in /usr/local/lib/python3.7/dist-packages (from yarl==1.7.2->ccxt) (2.10)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from yarl==1.7.2->ccxt) (4.1.1)\n",
            "Requirement already satisfied: multidict>=4.0 in /usr/local/lib/python3.7/dist-packages (from yarl==1.7.2->ccxt) (6.0.2)\n",
            "Requirement already satisfied: pycares>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from aiodns>=1.1.1->ccxt) (4.2.2)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (4.0.2)\n",
            "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (2.1.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (22.1.0)\n",
            "Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (0.13.0)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp>=3.8->ccxt) (1.2.0)\n",
            "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=2.6.1->ccxt) (1.15.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=2.6.1->ccxt) (2.21)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.18.4->ccxt) (3.0.4)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.18.4->ccxt) (1.24.3)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas) (2022.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas) (1.15.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mplfinance) (3.2.2)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mplfinance) (3.0.9)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mplfinance) (1.4.4)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mplfinance) (0.11.0)\n"
          ]
        }
      ],
      "source": [
        "!pip install ccxt pandas numpy mplfinance"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# -*- coding: utf-8 -*-\n",
        "\n",
        "import os\n",
        "import sys\n",
        "import csv\n",
        "\n",
        "# -----------------------------------------------------------------------------\n",
        "\n",
        "import ccxt  # noqa: E402\n",
        "\n",
        "\n",
        "# -----------------------------------------------------------------------------\n",
        "\n",
        "def retry_fetch_ohlcv(exchange, max_retries, symbol, timeframe, since, limit):\n",
        "    num_retries = 0\n",
        "    try:\n",
        "        num_retries += 1\n",
        "        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, since, limit)\n",
        "        # print('Fetched', len(ohlcv), symbol, 'candles from', exchange.iso8601 (ohlcv[0][0]), 'to', exchange.iso8601 (ohlcv[-1][0]))\n",
        "        return ohlcv\n",
        "    except Exception:\n",
        "        if num_retries > max_retries:\n",
        "            raise  # Exception('Failed to fetch', timeframe, symbol, 'OHLCV in', max_retries, 'attempts')\n",
        "\n",
        "\n",
        "def scrape_ohlcv(exchange, max_retries, symbol, timeframe, since, limit):\n",
        "    timeframe_duration_in_seconds = exchange.parse_timeframe(timeframe)\n",
        "    timeframe_duration_in_ms = timeframe_duration_in_seconds * 1000\n",
        "    timedelta = limit * timeframe_duration_in_ms\n",
        "    now = exchange.milliseconds()\n",
        "    all_ohlcv = []\n",
        "    fetch_since = since\n",
        "    while fetch_since < now:\n",
        "        ohlcv = retry_fetch_ohlcv(exchange, max_retries, symbol, timeframe, fetch_since, limit)\n",
        "        fetch_since = (ohlcv[-1][0] + 1) if len(ohlcv) else (fetch_since + timedelta)\n",
        "        all_ohlcv = all_ohlcv + ohlcv\n",
        "        if len(all_ohlcv):\n",
        "            print(len(all_ohlcv), 'candles in total from', exchange.iso8601(all_ohlcv[0][0]), 'to', exchange.iso8601(all_ohlcv[-1][0]))\n",
        "        else:\n",
        "            print(len(all_ohlcv), 'candles in total from', exchange.iso8601(fetch_since))\n",
        "    return exchange.filter_by_since_limit(all_ohlcv, since, None, key=0)\n",
        "\n",
        "\n",
        "def write_to_csv(filename, data):\n",
        "    with open(filename, mode='w') as output_file:\n",
        "        csv_writer = csv.writer(output_file, delimiter=',', quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n",
        "        csv_writer.writerows(data)\n",
        "\n",
        "\n",
        "def scrape_candles_to_csv(filename, exchange_id, max_retries, symbol, timeframe, since, limit):\n",
        "    # instantiate the exchange by id\n",
        "    exchange = getattr(ccxt, exchange_id)()\n",
        "    # convert since from string to milliseconds integer if needed\n",
        "    if isinstance(since, str):\n",
        "        since = exchange.parse8601(since)\n",
        "    # preload all markets from the exchange\n",
        "    exchange.load_markets()\n",
        "    # fetch all candles\n",
        "    ohlcv = scrape_ohlcv(exchange, max_retries, symbol, timeframe, since, limit)\n",
        "    # save them to csv file\n",
        "    write_to_csv(filename, ohlcv)\n",
        "    print('Saved', len(ohlcv), 'candles from', exchange.iso8601(ohlcv[0][0]), 'to', exchange.iso8601(ohlcv[-1][0]), 'to', filename)\n",
        "\n",
        "\n",
        "# -----------------------------------------------------------------------------\n",
        "# Binance's BTC/USDT candles start on 2017-08-17\n",
        "scrape_candles_to_csv('data.csv', 'binance', 3, 'ETH/USDT', '1d', '2017-08-17T04:00:00.000Z', 1000)"
      ],
      "metadata": {
        "id": "gUj-hDIDp736",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17656495-f406-40d7-cfbc-cd0fb0e3775d"
      },
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1000 candles in total from 2017-08-18T00:00:00.000Z to 2020-05-13T00:00:00.000Z\n",
            "1822 candles in total from 2017-08-18T00:00:00.000Z to 2022-08-13T00:00:00.000Z\n",
            "1822 candles in total from 2017-08-18T00:00:00.000Z to 2022-08-13T00:00:00.000Z\n",
            "Saved 1822 candles from 2017-08-18T00:00:00.000Z to 2022-08-13T00:00:00.000Z to data.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Load the CSV into a DataFrame"
      ],
      "metadata": {
        "id": "oKu4Ck3rsHkg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv('data.csv',names=['time','open','high','low','close','volume'])\n",
        "#df.set_index(\"time\",inplace=True)\n",
        "df.index = pd.DatetimeIndex(df['time']*1000000)\n",
        "print(df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "el2X0QMjr83D",
        "outputId": "6936a5e6-2a6f-4410-bf5d-7f8e12faa17a"
      },
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                     time     open     high      low    close        volume\n",
            "time                                                                       \n",
            "2017-08-18  1503014400000   302.00   311.79   283.94   293.96  9.537846e+03\n",
            "2017-08-19  1503100800000   293.31   299.90   278.00   290.91  2.146198e+03\n",
            "2017-08-20  1503187200000   289.41   300.53   282.85   299.10  2.510139e+03\n",
            "2017-08-21  1503273600000   299.10   346.52   294.60   323.29  5.219445e+03\n",
            "2017-08-22  1503360000000   321.04   330.41   144.21   309.80  7.956351e+03\n",
            "...                   ...      ...      ...      ...      ...           ...\n",
            "2022-08-09  1660003200000  1777.05  1790.83  1667.93  1702.76  8.181711e+05\n",
            "2022-08-10  1660089600000  1702.76  1885.00  1656.78  1853.57  1.317768e+06\n",
            "2022-08-11  1660176000000  1853.58  1942.00  1850.32  1880.19  1.105262e+06\n",
            "2022-08-12  1660262400000  1880.19  1964.71  1853.06  1958.28  7.176281e+05\n",
            "2022-08-13  1660348800000  1958.28  2020.00  1946.50  2004.45  2.980793e+05\n",
            "\n",
            "[1822 rows x 6 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## add indicators"
      ],
      "metadata": {
        "id": "z0Vgh1zSG4yj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "def crossed(series1, series2, direction=None):\n",
        "    if isinstance(series1, np.ndarray):\n",
        "        series1 = pd.Series(series1)\n",
        "\n",
        "    if isinstance(series2, (float, int, np.ndarray)):\n",
        "        series2 = pd.Series(index=series1.index, data=series2)\n",
        "\n",
        "    if direction is None or direction == \"above\":\n",
        "        above = pd.Series((series1 > series2) & (\n",
        "            series1.shift(1) <= series2.shift(1)))\n",
        "\n",
        "    if direction is None or direction == \"below\":\n",
        "        below = pd.Series((series1 < series2) & (\n",
        "            series1.shift(1) >= series2.shift(1)))\n",
        "\n",
        "    if direction is None:\n",
        "        return above or below\n",
        "\n",
        "    return above if direction == \"above\" else below\n",
        "\n",
        "\n",
        "def crossed_above(series1, series2):\n",
        "    return crossed(series1, series2, \"above\")\n",
        "\n",
        "\n",
        "def crossed_below(series1, series2):\n",
        "    return crossed(series1, series2, \"below\")"
      ],
      "metadata": {
        "id": "EdYYdMcmAg6B"
      },
      "execution_count": 146,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generate Indicators"
      ],
      "metadata": {
        "id": "hRmCaYPO0LXh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "df[\"cross\"]=0\n",
        "for i in range(1,1000,1):\n",
        "  df[f'ma{i}'] = df[\"close\"].rolling(i).mean()\n",
        "  if f\"ma{i-1}\" in df.keys():\n",
        "    df.loc[\n",
        "      crossed_above(df[f\"ma{i-1}\"],df[f'ma{i}'])\n",
        "    ,\"cross\"]+=1\n",
        "    df.loc[\n",
        "      crossed_below(df[f\"ma{i-1}\"],df[f'ma{i}'])\n",
        "    ,\"cross\"]-=1\n",
        "df[\"zigzag\"]=np.nan\n",
        "df[\"zigzag\"][0]=df[\"close\"][0]\n",
        "df.loc[\n",
        "    ((df['cross']>df['cross'].shift(1))&\n",
        "    (df['cross']>df['cross'].shift(-1)))|\n",
        "    ((df['cross']<df['cross'].shift(1))&\n",
        "    (df['cross']<df['cross'].shift(-1)))\n",
        "  ,\"zigzag\"]=df[\"close\"]\n",
        "df[\"zigzag\"]=df[\"zigzag\"].interpolate()#.rolling(3).mean()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEQThxfY0Qbk",
        "outputId": "5f0219c8-7db0-4656-a175-462c34b20520"
      },
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:4: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead.  To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  after removing the cwd from sys.path.\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:12: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead.  To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  if sys.path[0] == '':\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:13: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  del sys.path[0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Virtualize"
      ],
      "metadata": {
        "id": "3E9YEKEf8rJ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import mplfinance as mpf\n",
        "df=df.tail(100)\n",
        "apdict = mpf.make_addplot(df['zigzag'],color=\"red\")\n",
        "\n",
        "mpf.plot(df,addplot=apdict)"
      ],
      "metadata": {
        "id": "1Rk0hG8682mP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "outputId": "e1f8aec1-e360-4b7e-aa22-550453e7894b"
      },
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x575 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}