diff --git a/notebooks/moirai_forecast.ipynb b/notebooks/moirai_forecast.ipynb
new file mode 100644
index 0000000..69d077e
--- /dev/null
+++ b/notebooks/moirai_forecast.ipynb
@@ -0,0 +1,1374 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cloning into 'uni2ts'...\n",
+      "remote: Enumerating objects: 716, done.\u001b[K\n",
+      "remote: Counting objects: 100% (270/270), done.\u001b[K\n",
+      "remote: Compressing objects: 100% (136/136), done.\u001b[K\n",
+      "remote: Total 716 (delta 159), reused 152 (delta 128), pack-reused 446\u001b[K\n",
+      "Receiving objects: 100% (716/716), 5.22 MiB | 1.30 MiB/s, done.\n",
+      "Resolving deltas: 100% (328/328), done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "!git clone https://github.com/SalesforceAIResearch/uni2ts.git\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import the packeges"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/json.py:101: UserWarning: Using `json`-module for json-handling. Consider installing one of `orjson`, `ujson` to speed up serialization and deserialization.\n",
+      "  warnings.warn(\n",
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "import matplotlib.pyplot as plt\n",
+    "root_path = os.path.abspath(os.path.join(os.getcwd(), './uni2ts/src'))\n",
+    "sys.path.append(root_path)\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from einops import rearrange\n",
+    "from gluonts.dataset.pandas import PandasDataset\n",
+    "from gluonts.dataset.split import split\n",
+    "from gluonts.torch.model.predictor import PyTorchPredictor\n",
+    "import yfinance as yf\n",
+    "\n",
+    "from uni2ts.eval_util.plot import plot_single\n",
+    "from uni2ts.model.moirai import MoiraiForecast, MoiraiModule\n",
+    "import backtrader as bt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fetch Data from Yahoo Finance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Step 1: Fetch Data from Yahoo Finance\n",
+    "def fetch_data(symbol, since):\n",
+    "    try:\n",
+    "        ticker = yf.Ticker(symbol)\n",
+    "        ohlcv = ticker.history(period='1d', start=since)\n",
+    "        ohlcv.reset_index(inplace=True)\n",
+    "        ohlcv['timestamp'] = pd.to_datetime(ohlcv['Date'])\n",
+    "        ohlcv.set_index('timestamp', inplace=True)\n",
+    "        ohlcv = ohlcv[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+    "        ohlcv.rename(columns={'Open': 'open', 'High': 'high', 'Low': 'low', 'Close': 'close', 'Volume': 'volume'}, inplace=True)\n",
+    "        \n",
+    "        # Ensure the data is uniformly spaced by resampling\n",
+    "        ohlcv = ohlcv.resample('D').ffill()\n",
+    "        \n",
+    "        return ohlcv\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error fetching data for {symbol}: {str(e)}\")\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load and predict "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_and_predict(data):\n",
+    "    # Use only the 'close' price for forecasting\n",
+    "    df = data[['close']].rename(columns={'close': 'target'})\n",
+    "\n",
+    "    # Ensure data is sorted\n",
+    "    df = df.sort_index()\n",
+    "\n",
+    "    # Step 2: Prepare the Data for the Model\n",
+    "    # Convert into GluonTS dataset\n",
+    "    ds = PandasDataset(dict(df), freq=\"D\")\n",
+    "\n",
+    "    # Split into train/test set\n",
+    "    TEST = 100  # Define the length of the test set\n",
+    "    PDT = 20  # Define the prediction length\n",
+    "    train, test_template = split(ds, offset=-TEST)\n",
+    "\n",
+    "    # Ensure the length of the dataset is sufficient for rolling window evaluation\n",
+    "    total_length = len(df)\n",
+    "    if total_length < TEST + PDT:\n",
+    "        raise ValueError(f\"Not enough data points. Total length: {total_length}, TEST: {TEST}, PDT: {PDT}\")\n",
+    "\n",
+    "    # Construct rolling window evaluation\n",
+    "    test_data = test_template.generate_instances(\n",
+    "        prediction_length=PDT,\n",
+    "        windows=TEST // PDT,\n",
+    "        distance=PDT\n",
+    "    )\n",
+    "\n",
+    "    # Step 3: Load the Model and Make Predictions\n",
+    "    SIZE = \"small\"  # Model size\n",
+    "    CTX = 200  # Context length\n",
+    "    PSZ = \"auto\"  # Patch size\n",
+    "    BSZ = 32  # Batch size\n",
+    "\n",
+    "    # Prepare pre-trained model by downloading model weights from Hugging Face hub\n",
+    "    model = MoiraiForecast(\n",
+    "        module=MoiraiModule.from_pretrained(f\"Salesforce/moirai-1.0-R-{SIZE}\"),\n",
+    "        prediction_length=PDT,\n",
+    "        context_length=CTX,\n",
+    "        patch_size=PSZ,\n",
+    "        num_samples=100,\n",
+    "        target_dim=1,\n",
+    "        feat_dynamic_real_dim=ds.num_feat_dynamic_real,\n",
+    "        past_feat_dynamic_real_dim=ds.num_past_feat_dynamic_real,\n",
+    "    )\n",
+    "\n",
+    "    predictor = model.create_predictor(batch_size=BSZ)\n",
+    "    forecasts = predictor.predict(test_data.input)\n",
+    "\n",
+    "    # Step 4: Plot the Results\n",
+    "    input_it = iter(test_data.input)\n",
+    "    label_it = iter(test_data.label)\n",
+    "    forecast_it = iter(forecasts)\n",
+    "\n",
+    "    try:\n",
+    "        inp = next(input_it)\n",
+    "        label = next(label_it)\n",
+    "        forecast = next(forecast_it)\n",
+    "\n",
+    "        plot_single(\n",
+    "            inp, \n",
+    "            label, \n",
+    "            forecast, \n",
+    "            context_length=CTX,\n",
+    "            name=\"pred\",\n",
+    "            show_label=True,\n",
+    "        )\n",
+    "        plt.show()\n",
+    "    except StopIteration:\n",
+    "        print(\"Error: Not enough data points to generate forecasts.\")\n",
+    "    \n",
+    "    return forecasts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define the strategies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the strategies\n",
+    "class RsiBollingerBandsStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('rsi_period', 14),\n",
+    "        ('bb_period', 20),\n",
+    "        ('bb_dev', 2),\n",
+    "        ('oversold', 30),\n",
+    "        ('overbought', 70),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.rsi = bt.indicators.RelativeStrengthIndex(period=self.params.rsi_period)\n",
+    "        self.bbands = bt.indicators.BollingerBands(period=self.params.bb_period, devfactor=self.params.bb_dev)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.rsi < self.params.oversold and self.data.close <= self.bbands.lines.bot:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.rsi > self.params.overbought or self.data.close >= self.bbands.lines.top:\n",
+    "                self.sell()\n",
+    "        \n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class MacdStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('macd1_period', 12),\n",
+    "        ('macd2_period', 26),\n",
+    "        ('signal_period', 9),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.macd = bt.indicators.MACDHisto(period_me1=self.params.macd1_period, period_me2=self.params.macd2_period, period_signal=self.params.signal_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.macd.lines.histo[0] > 0 and self.macd.lines.histo[-1] <= 0:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.macd.lines.histo[0] < 0 and self.macd.lines.histo[-1] >= 0:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class StochasticOscillatorStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('stoch_period', 14),\n",
+    "        ('stoch_low', 20),\n",
+    "        ('stoch_high', 80),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.stoch = bt.indicators.Stochastic(period=self.params.stoch_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.stoch.lines.percK[0] < self.params.stoch_low and self.stoch.lines.percK[-1] >= self.params.stoch_low:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.stoch.lines.percK[0] > self.params.stoch_high and self.stoch.lines.percK[-1] <= self.params.stoch_high:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the backtest strategies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Running backtest for RsiBollingerBandsStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 101338.30\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n    if (typeof WebSocket !== 'undefined') {\n        return WebSocket;\n    } else if (typeof MozWebSocket !== 'undefined') {\n        return MozWebSocket;\n    } else {\n        alert(\n            'Your browser does not have WebSocket support. ' +\n                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n                'Firefox 4 and 5 are also supported but you ' +\n                'have to enable WebSockets in about:config.'\n        );\n    }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n    this.id = figure_id;\n\n    this.ws = websocket;\n\n    this.supports_binary = this.ws.binaryType !== undefined;\n\n    if (!this.supports_binary) {\n        var warnings = document.getElementById('mpl-warnings');\n        if (warnings) {\n            warnings.style.display = 'block';\n            warnings.textContent =\n                'This browser does not support binary websocket messages. ' +\n                'Performance may be slow.';\n        }\n    }\n\n    this.imageObj = new Image();\n\n    this.context = undefined;\n    this.message = undefined;\n    this.canvas = undefined;\n    this.rubberband_canvas = undefined;\n    this.rubberband_context = undefined;\n    this.format_dropdown = undefined;\n\n    this.image_mode = 'full';\n\n    this.root = document.createElement('div');\n    this.root.setAttribute('style', 'display: inline-block');\n    this._root_extra_style(this.root);\n\n    parent_element.appendChild(this.root);\n\n    this._init_header(this);\n    this._init_canvas(this);\n    this._init_toolbar(this);\n\n    var fig = this;\n\n    this.waiting = false;\n\n    this.ws.onopen = function () {\n        fig.send_message('supports_binary', { value: fig.supports_binary });\n        fig.send_message('send_image_mode', {});\n        if (fig.ratio !== 1) {\n            fig.send_message('set_device_pixel_ratio', {\n                device_pixel_ratio: fig.ratio,\n            });\n        }\n        fig.send_message('refresh', {});\n    };\n\n    this.imageObj.onload = function () {\n        if (fig.image_mode === 'full') {\n            // Full images could contain transparency (where diff images\n            // almost always do), so we need to clear the canvas so that\n            // there is no ghosting.\n            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n        }\n        fig.context.drawImage(fig.imageObj, 0, 0);\n    };\n\n    this.imageObj.onunload = function () {\n        fig.ws.close();\n    };\n\n    this.ws.onmessage = this._make_on_message_function(this);\n\n    this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n    var titlebar = document.createElement('div');\n    titlebar.classList =\n        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n    var titletext = document.createElement('div');\n    titletext.classList = 'ui-dialog-title';\n    titletext.setAttribute(\n        'style',\n        'width: 100%; text-align: center; padding: 3px;'\n    );\n    titlebar.appendChild(titletext);\n    this.root.appendChild(titlebar);\n    this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n    var fig = this;\n\n    var canvas_div = (this.canvas_div = document.createElement('div'));\n    canvas_div.setAttribute('tabindex', '0');\n    canvas_div.setAttribute(\n        'style',\n        'border: 1px solid #ddd;' +\n            'box-sizing: content-box;' +\n            'clear: both;' +\n            'min-height: 1px;' +\n            'min-width: 1px;' +\n            'outline: 0;' +\n            'overflow: hidden;' +\n            'position: relative;' +\n            'resize: both;' +\n            'z-index: 2;'\n    );\n\n    function on_keyboard_event_closure(name) {\n        return function (event) {\n            return fig.key_event(event, name);\n        };\n    }\n\n    canvas_div.addEventListener(\n        'keydown',\n        on_keyboard_event_closure('key_press')\n    );\n    canvas_div.addEventListener(\n        'keyup',\n        on_keyboard_event_closure('key_release')\n    );\n\n    this._canvas_extra_style(canvas_div);\n    this.root.appendChild(canvas_div);\n\n    var canvas = (this.canvas = document.createElement('canvas'));\n    canvas.classList.add('mpl-canvas');\n    canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'pointer-events: none;' +\n            'position: relative;' +\n            'z-index: 0;'\n    );\n\n    this.context = canvas.getContext('2d');\n\n    var backingStore =\n        this.context.backingStorePixelRatio ||\n        this.context.webkitBackingStorePixelRatio ||\n        this.context.mozBackingStorePixelRatio ||\n        this.context.msBackingStorePixelRatio ||\n        this.context.oBackingStorePixelRatio ||\n        this.context.backingStorePixelRatio ||\n        1;\n\n    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n        'canvas'\n    ));\n    rubberband_canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'left: 0;' +\n            'pointer-events: none;' +\n            'position: absolute;' +\n            'top: 0;' +\n            'z-index: 1;'\n    );\n\n    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n    if (this.ResizeObserver === undefined) {\n        if (window.ResizeObserver !== undefined) {\n            this.ResizeObserver = window.ResizeObserver;\n        } else {\n            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n            this.ResizeObserver = obs.ResizeObserver;\n        }\n    }\n\n    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n        // There's no need to resize if the WebSocket is not connected:\n        // - If it is still connecting, then we will get an initial resize from\n        //   Python once it connects.\n        // - If it has disconnected, then resizing will clear the canvas and\n        //   never get anything back to refill it, so better to not resize and\n        //   keep something visible.\n        if (fig.ws.readyState != 1) {\n            return;\n        }\n        var nentries = entries.length;\n        for (var i = 0; i < nentries; i++) {\n            var entry = entries[i];\n            var width, height;\n            if (entry.contentBoxSize) {\n                if (entry.contentBoxSize instanceof Array) {\n                    // Chrome 84 implements new version of spec.\n                    width = entry.contentBoxSize[0].inlineSize;\n                    height = entry.contentBoxSize[0].blockSize;\n                } else {\n                    // Firefox implements old version of spec.\n                    width = entry.contentBoxSize.inlineSize;\n                    height = entry.contentBoxSize.blockSize;\n                }\n            } else {\n                // Chrome <84 implements even older version of spec.\n                width = entry.contentRect.width;\n                height = entry.contentRect.height;\n            }\n\n            // Keep the size of the canvas and rubber band canvas in sync with\n            // the canvas container.\n            if (entry.devicePixelContentBoxSize) {\n                // Chrome 84 implements new version of spec.\n                canvas.setAttribute(\n                    'width',\n                    entry.devicePixelContentBoxSize[0].inlineSize\n                );\n                canvas.setAttribute(\n                    'height',\n                    entry.devicePixelContentBoxSize[0].blockSize\n                );\n            } else {\n                canvas.setAttribute('width', width * fig.ratio);\n                canvas.setAttribute('height', height * fig.ratio);\n            }\n            /* This rescales the canvas back to display pixels, so that it\n             * appears correct on HiDPI screens. */\n            canvas.style.width = width + 'px';\n            canvas.style.height = height + 'px';\n\n            rubberband_canvas.setAttribute('width', width);\n            rubberband_canvas.setAttribute('height', height);\n\n            // And update the size in Python. We ignore the initial 0/0 size\n            // that occurs as the element is placed into the DOM, which should\n            // otherwise not happen due to the minimum size styling.\n            if (width != 0 && height != 0) {\n                fig.request_resize(width, height);\n            }\n        }\n    });\n    this.resizeObserverInstance.observe(canvas_div);\n\n    function on_mouse_event_closure(name) {\n        /* User Agent sniffing is bad, but WebKit is busted:\n         * https://bugs.webkit.org/show_bug.cgi?id=144526\n         * https://bugs.webkit.org/show_bug.cgi?id=181818\n         * The worst that happens here is that they get an extra browser\n         * selection when dragging, if this check fails to catch them.\n         */\n        var UA = navigator.userAgent;\n        var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n        if(isWebKit) {\n            return function (event) {\n                /* This prevents the web browser from automatically changing to\n                 * the text insertion cursor when the button is pressed. We\n                 * want to control all of the cursor setting manually through\n                 * the 'cursor' event from matplotlib */\n                event.preventDefault()\n                return fig.mouse_event(event, name);\n            };\n        } else {\n            return function (event) {\n                return fig.mouse_event(event, name);\n            };\n        }\n    }\n\n    canvas_div.addEventListener(\n        'mousedown',\n        on_mouse_event_closure('button_press')\n    );\n    canvas_div.addEventListener(\n        'mouseup',\n        on_mouse_event_closure('button_release')\n    );\n    canvas_div.addEventListener(\n        'dblclick',\n        on_mouse_event_closure('dblclick')\n    );\n    // Throttle sequential mouse events to 1 every 20ms.\n    canvas_div.addEventListener(\n        'mousemove',\n        on_mouse_event_closure('motion_notify')\n    );\n\n    canvas_div.addEventListener(\n        'mouseenter',\n        on_mouse_event_closure('figure_enter')\n    );\n    canvas_div.addEventListener(\n        'mouseleave',\n        on_mouse_event_closure('figure_leave')\n    );\n\n    canvas_div.addEventListener('wheel', function (event) {\n        if (event.deltaY < 0) {\n            event.step = 1;\n        } else {\n            event.step = -1;\n        }\n        on_mouse_event_closure('scroll')(event);\n    });\n\n    canvas_div.appendChild(canvas);\n    canvas_div.appendChild(rubberband_canvas);\n\n    this.rubberband_context = rubberband_canvas.getContext('2d');\n    this.rubberband_context.strokeStyle = '#000000';\n\n    this._resize_canvas = function (width, height, forward) {\n        if (forward) {\n            canvas_div.style.width = width + 'px';\n            canvas_div.style.height = height + 'px';\n        }\n    };\n\n    // Disable right mouse context menu.\n    canvas_div.addEventListener('contextmenu', function (_e) {\n        event.preventDefault();\n        return false;\n    });\n\n    function set_focus() {\n        canvas.focus();\n        canvas_div.focus();\n    }\n\n    window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'mpl-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'mpl-button-group';\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'mpl-button-group';\n            continue;\n        }\n\n        var button = (fig.buttons[name] = document.createElement('button'));\n        button.classList = 'mpl-widget';\n        button.setAttribute('role', 'button');\n        button.setAttribute('aria-disabled', 'false');\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n        var icon_img = document.createElement('img');\n        icon_img.src = '_images/' + image + '.png';\n        icon_img.srcset = '_images/' + image + '_large.png 2x';\n        icon_img.alt = tooltip;\n        button.appendChild(icon_img);\n\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    var fmt_picker = document.createElement('select');\n    fmt_picker.classList = 'mpl-widget';\n    toolbar.appendChild(fmt_picker);\n    this.format_dropdown = fmt_picker;\n\n    for (var ind in mpl.extensions) {\n        var fmt = mpl.extensions[ind];\n        var option = document.createElement('option');\n        option.selected = fmt === mpl.default_extension;\n        option.innerHTML = fmt;\n        fmt_picker.appendChild(option);\n    }\n\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n    // which will in turn request a refresh of the image.\n    this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n    properties['type'] = type;\n    properties['figure_id'] = this.id;\n    this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n    if (!this.waiting) {\n        this.waiting = true;\n        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    var format_dropdown = fig.format_dropdown;\n    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n    fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n    var size = msg['size'];\n    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n        fig._resize_canvas(size[0], size[1], msg['forward']);\n        fig.send_message('refresh', {});\n    }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n    var x0 = msg['x0'] / fig.ratio;\n    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n    var x1 = msg['x1'] / fig.ratio;\n    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n    x0 = Math.floor(x0) + 0.5;\n    y0 = Math.floor(y0) + 0.5;\n    x1 = Math.floor(x1) + 0.5;\n    y1 = Math.floor(y1) + 0.5;\n    var min_x = Math.min(x0, x1);\n    var min_y = Math.min(y0, y1);\n    var width = Math.abs(x1 - x0);\n    var height = Math.abs(y1 - y0);\n\n    fig.rubberband_context.clearRect(\n        0,\n        0,\n        fig.canvas.width / fig.ratio,\n        fig.canvas.height / fig.ratio\n    );\n\n    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n    // Updates the figure title.\n    fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n    fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n    fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n    // Request the server to send over a new figure.\n    fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n    fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n    for (var key in msg) {\n        if (!(key in fig.buttons)) {\n            continue;\n        }\n        fig.buttons[key].disabled = !msg[key];\n        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n    }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n    if (msg['mode'] === 'PAN') {\n        fig.buttons['Pan'].classList.add('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    } else if (msg['mode'] === 'ZOOM') {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.add('active');\n    } else {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Called whenever the canvas gets updated.\n    this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n    return function socket_on_message(evt) {\n        if (evt.data instanceof Blob) {\n            var img = evt.data;\n            if (img.type !== 'image/png') {\n                /* FIXME: We get \"Resource interpreted as Image but\n                 * transferred with MIME type text/plain:\" errors on\n                 * Chrome.  But how to set the MIME type?  It doesn't seem\n                 * to be part of the websocket stream */\n                img.type = 'image/png';\n            }\n\n            /* Free the memory for the previous frames */\n            if (fig.imageObj.src) {\n                (window.URL || window.webkitURL).revokeObjectURL(\n                    fig.imageObj.src\n                );\n            }\n\n            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n                img\n            );\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        } else if (\n            typeof evt.data === 'string' &&\n            evt.data.slice(0, 21) === 'data:image/png;base64'\n        ) {\n            fig.imageObj.src = evt.data;\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        }\n\n        var msg = JSON.parse(evt.data);\n        var msg_type = msg['type'];\n\n        // Call the  \"handle_{type}\" callback, which takes\n        // the figure and JSON message as its only arguments.\n        try {\n            var callback = fig['handle_' + msg_type];\n        } catch (e) {\n            console.log(\n                \"No handler for the '\" + msg_type + \"' message type: \",\n                msg\n            );\n            return;\n        }\n\n        if (callback) {\n            try {\n                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n                callback(fig, msg);\n            } catch (e) {\n                console.log(\n                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n                    e,\n                    e.stack,\n                    msg\n                );\n            }\n        }\n    };\n};\n\nfunction getModifiers(event) {\n    var mods = [];\n    if (event.ctrlKey) {\n        mods.push('ctrl');\n    }\n    if (event.altKey) {\n        mods.push('alt');\n    }\n    if (event.shiftKey) {\n        mods.push('shift');\n    }\n    if (event.metaKey) {\n        mods.push('meta');\n    }\n    return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n    return Object.keys(original).reduce(function (obj, key) {\n        if (typeof original[key] !== 'object') {\n            obj[key] = original[key];\n        }\n        return obj;\n    }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n    if (name === 'button_press') {\n        this.canvas.focus();\n        this.canvas_div.focus();\n    }\n\n    // from https://stackoverflow.com/q/1114465\n    var boundingRect = this.canvas.getBoundingClientRect();\n    var x = (event.clientX - boundingRect.left) * this.ratio;\n    var y = (event.clientY - boundingRect.top) * this.ratio;\n\n    this.send_message(name, {\n        x: x,\n        y: y,\n        button: event.button,\n        step: event.step,\n        modifiers: getModifiers(event),\n        guiEvent: simpleKeys(event),\n    });\n\n    return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n    // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n    // Prevent repeat events\n    if (name === 'key_press') {\n        if (event.key === this._key) {\n            return;\n        } else {\n            this._key = event.key;\n        }\n    }\n    if (name === 'key_release') {\n        this._key = null;\n    }\n\n    var value = '';\n    if (event.ctrlKey && event.key !== 'Control') {\n        value += 'ctrl+';\n    }\n    else if (event.altKey && event.key !== 'Alt') {\n        value += 'alt+';\n    }\n    else if (event.shiftKey && event.key !== 'Shift') {\n        value += 'shift+';\n    }\n\n    value += 'k' + event.key;\n\n    this._key_event_extra(event, name);\n\n    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n    return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n    if (name === 'download') {\n        this.handle_save(this, null);\n    } else {\n        this.send_message('toolbar_button', { name: name });\n    }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n    this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n    // Create a \"websocket\"-like object which calls the given IPython comm\n    // object with the appropriate methods. Currently this is a non binary\n    // socket, so there is still some room for performance tuning.\n    var ws = {};\n\n    ws.binaryType = comm.kernel.ws.binaryType;\n    ws.readyState = comm.kernel.ws.readyState;\n    function updateReadyState(_event) {\n        if (comm.kernel.ws) {\n            ws.readyState = comm.kernel.ws.readyState;\n        } else {\n            ws.readyState = 3; // Closed state.\n        }\n    }\n    comm.kernel.ws.addEventListener('open', updateReadyState);\n    comm.kernel.ws.addEventListener('close', updateReadyState);\n    comm.kernel.ws.addEventListener('error', updateReadyState);\n\n    ws.close = function () {\n        comm.close();\n    };\n    ws.send = function (m) {\n        //console.log('sending', m);\n        comm.send(m);\n    };\n    // Register the callback with on_msg.\n    comm.on_msg(function (msg) {\n        //console.log('receiving', msg['content']['data'], msg);\n        var data = msg['content']['data'];\n        if (data['blob'] !== undefined) {\n            data = {\n                data: new Blob(msg['buffers'], { type: data['blob'] }),\n            };\n        }\n        // Pass the mpl event to the overridden (by mpl) onmessage function.\n        ws.onmessage(data);\n    });\n    return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n    // This is the function which gets called when the mpl process\n    // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n    var id = msg.content.data.id;\n    // Get hold of the div created by the display call when the Comm\n    // socket was opened in Python.\n    var element = document.getElementById(id);\n    var ws_proxy = comm_websocket_adapter(comm);\n\n    function ondownload(figure, _format) {\n        window.open(figure.canvas.toDataURL());\n    }\n\n    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n    // web socket which is closed, not our websocket->open comm proxy.\n    ws_proxy.onopen();\n\n    fig.parent_element = element;\n    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n    if (!fig.cell_info) {\n        console.error('Failed to find cell for figure', id, fig);\n        return;\n    }\n    fig.cell_info[0].output_area.element.on(\n        'cleared',\n        { fig: fig },\n        fig._remove_fig_handler\n    );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n    var width = fig.canvas.width / fig.ratio;\n    fig.cell_info[0].output_area.element.off(\n        'cleared',\n        fig._remove_fig_handler\n    );\n    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n    // Update the output cell to use the data from the current canvas.\n    fig.push_to_output();\n    var dataURL = fig.canvas.toDataURL();\n    // Re-enable the keyboard manager in IPython - without this line, in FF,\n    // the notebook keyboard shortcuts fail.\n    IPython.keyboard_manager.enable();\n    fig.parent_element.innerHTML =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n    fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n    fig.send_message('closing', msg);\n    // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n    // Turn the data on the canvas into data in the output cell.\n    var width = this.canvas.width / this.ratio;\n    var dataURL = this.canvas.toDataURL();\n    this.cell_info[1]['text/html'] =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Tell IPython that the notebook contents must change.\n    IPython.notebook.set_dirty(true);\n    this.send_message('ack', {});\n    var fig = this;\n    // Wait a second, then push the new image to the DOM so\n    // that it is saved nicely (might be nice to debounce this).\n    setTimeout(function () {\n        fig.push_to_output();\n    }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'btn-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'btn-group';\n    var button;\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'btn-group';\n            continue;\n        }\n\n        button = fig.buttons[name] = document.createElement('button');\n        button.classList = 'btn btn-default';\n        button.href = '#';\n        button.title = name;\n        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    // Add the status bar.\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message pull-right';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n\n    // Add the close button to the window.\n    var buttongrp = document.createElement('div');\n    buttongrp.classList = 'btn-group inline pull-right';\n    button = document.createElement('button');\n    button.classList = 'btn btn-mini btn-primary';\n    button.href = '#';\n    button.title = 'Stop Interaction';\n    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n    button.addEventListener('click', function (_evt) {\n        fig.handle_close(fig, {});\n    });\n    button.addEventListener(\n        'mouseover',\n        on_mouseover_closure('Stop Interaction')\n    );\n    buttongrp.appendChild(button);\n    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n    var fig = event.data.fig;\n    if (event.target !== this) {\n        // Ignore bubbled events from children.\n        return;\n    }\n    fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n    // this is important to make the div 'focusable\n    el.setAttribute('tabindex', 0);\n    // reach out to IPython and tell the keyboard manager to turn it's self\n    // off when our div gets focus\n\n    // location in version 3\n    if (IPython.notebook.keyboard_manager) {\n        IPython.notebook.keyboard_manager.register_events(el);\n    } else {\n        // location in version 2\n        IPython.keyboard_manager.register_events(el);\n    }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n    // Check for shift+enter\n    if (event.shiftKey && event.which === 13) {\n        this.canvas_div.blur();\n        // select the cell after this one\n        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n        IPython.notebook.select(index + 1);\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n    // Return the cell and output element which can be found *uniquely* in the notebook.\n    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n    // IPython event is triggered only after the cells have been serialised, which for\n    // our purposes (turning an active figure into a static one), is too late.\n    var cells = IPython.notebook.get_cells();\n    var ncells = cells.length;\n    for (var i = 0; i < ncells; i++) {\n        var cell = cells[i];\n        if (cell.cell_type === 'code') {\n            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n                var data = cell.output_area.outputs[j];\n                if (data.data) {\n                    // IPython >= 3 moved mimebundle to data attribute of output\n                    data = data.data;\n                }\n                if (data['text/html'] === html_output) {\n                    return [cell, data, j];\n                }\n            }\n        }\n    }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n    IPython.notebook.kernel.comm_manager.register_target(\n        'matplotlib',\n        mpl.mpl_figure_comm\n    );\n}\n",
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div id='81365b22-19bf-43df-a4e6-90f99149a60e'></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 101338.29630859377\n",
+      "Sharpe Ratio: -1.6588513094978394\n",
+      "Max Drawdown: 2.538388732547052\n",
+      "Total Trades: 2\n",
+      "Winning Trades: 1\n",
+      "Losing Trades: 0\n",
+      "Total Return: 0.013294202280243533\n",
+      "\n",
+      "Running backtest for MacdStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 117093.09\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 117093.08969531255\n",
+      "Sharpe Ratio: 2.3151351845615338\n",
+      "Max Drawdown: 9.211955039933201\n",
+      "Total Trades: 11\n",
+      "Winning Trades: 5\n",
+      "Losing Trades: 6\n",
+      "Total Return: 0.15779907087868106\n",
+      "\n",
+      "Running backtest for StochasticOscillatorStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100279.05\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100279.050984375\n",
+      "Sharpe Ratio: -1.409165927071452\n",
+      "Max Drawdown: 8.15567929488038\n",
+      "Total Trades: 5\n",
+      "Winning Trades: 3\n",
+      "Losing Trades: 1\n",
+      "Total Return: 0.002786623599212957\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 15 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "def run_backtest(strategy_class, symbol, since):\n",
+    "    # Fetch data for backtesting\n",
+    "    data = fetch_data(symbol, since)\n",
+    "\n",
+    "    # Load and make predictions\n",
+    "    predictions = load_and_predict(data)\n",
+    "\n",
+    "    # Initialize cerebro\n",
+    "    cerebro = bt.Cerebro()\n",
+    "    \n",
+    "    # Add data feed\n",
+    "    cerebro.adddata(bt.feeds.PandasData(dataname=data))\n",
+    "    \n",
+    "    # Add strategy with predictions\n",
+    "    cerebro.addstrategy(strategy_class, predictions=predictions)\n",
+    "    \n",
+    "    # Set broker settings\n",
+    "    cerebro.broker.set_cash(100000)\n",
+    "    cerebro.broker.setcommission(commission=0.002)\n",
+    "\n",
+    "    # Add analyzers for performance metrics\n",
+    "    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')\n",
+    "    cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')\n",
+    "    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')\n",
+    "    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')\n",
+    "\n",
+    "    # Print starting conditions\n",
+    "    start_value = cerebro.broker.getvalue()\n",
+    "    print(f'Starting Portfolio Value: {start_value:.2f}')\n",
+    "\n",
+    "    # Run backtest\n",
+    "    results = cerebro.run()\n",
+    "\n",
+    "    # Print ending conditions\n",
+    "    end_value = cerebro.broker.getvalue()\n",
+    "    print(f'Ending Portfolio Value: {end_value:.2f}')\n",
+    "\n",
+    "    # Extracting backtest metrics\n",
+    "    strat = results[0]\n",
+    "\n",
+    "    # Prepare results\n",
+    "    result_dict = {\n",
+    "        \"Starting Portfolio Value\": start_value,\n",
+    "        \"Ending Portfolio Value\": end_value,\n",
+    "        \"Sharpe Ratio\": strat.analyzers.sharpe.get_analysis().get('sharperatio', 'N/A'),\n",
+    "        \"Max Drawdown\": strat.analyzers.drawdown.get_analysis().get('max', {}).get('drawdown', 'N/A'),\n",
+    "        \"Total Trades\": strat.analyzers.trades.get_analysis().get('total', {}).get('total', 'N/A'),\n",
+    "        \"Winning Trades\": strat.analyzers.trades.get_analysis().get('won', {}).get('total', 'N/A'),\n",
+    "        \"Losing Trades\": strat.analyzers.trades.get_analysis().get('lost', {}).get('total', 'N/A'),\n",
+    "        \"Total Return\": strat.analyzers.returns.get_analysis().get('rtot', 'N/A')\n",
+    "    }\n",
+    "\n",
+    "    # Plot the results\n",
+    "    cerebro.plot(style='candlestick')\n",
+    "\n",
+    "    # Print metrics\n",
+    "    print(\"Metrics:\")\n",
+    "    for key, value in result_dict.items():\n",
+    "        print(f\"{key}: {value}\")\n",
+    "\n",
+    "    return result_dict\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    symbol = 'BTC-USD'\n",
+    "    since = '2023-06-20'\n",
+    "    \n",
+    "    strategies = [RsiBollingerBandsStrategy, MacdStrategy, StochasticOscillatorStrategy]\n",
+    "    \n",
+    "    for strategy in strategies:\n",
+    "        print(f\"\\nRunning backtest for {strategy.__name__}\")\n",
+    "        run_backtest(strategy, symbol, since)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Complete code with since as starting date and end date is current date"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/json.py:101: UserWarning: Using `json`-module for json-handling. Consider installing one of `orjson`, `ujson` to speed up serialization and deserialization.\n",
+      "  warnings.warn(\n",
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running backtest for RsiBollingerBandsStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100044.12\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n    if (typeof WebSocket !== 'undefined') {\n        return WebSocket;\n    } else if (typeof MozWebSocket !== 'undefined') {\n        return MozWebSocket;\n    } else {\n        alert(\n            'Your browser does not have WebSocket support. ' +\n                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n                'Firefox 4 and 5 are also supported but you ' +\n                'have to enable WebSockets in about:config.'\n        );\n    }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n    this.id = figure_id;\n\n    this.ws = websocket;\n\n    this.supports_binary = this.ws.binaryType !== undefined;\n\n    if (!this.supports_binary) {\n        var warnings = document.getElementById('mpl-warnings');\n        if (warnings) {\n            warnings.style.display = 'block';\n            warnings.textContent =\n                'This browser does not support binary websocket messages. ' +\n                'Performance may be slow.';\n        }\n    }\n\n    this.imageObj = new Image();\n\n    this.context = undefined;\n    this.message = undefined;\n    this.canvas = undefined;\n    this.rubberband_canvas = undefined;\n    this.rubberband_context = undefined;\n    this.format_dropdown = undefined;\n\n    this.image_mode = 'full';\n\n    this.root = document.createElement('div');\n    this.root.setAttribute('style', 'display: inline-block');\n    this._root_extra_style(this.root);\n\n    parent_element.appendChild(this.root);\n\n    this._init_header(this);\n    this._init_canvas(this);\n    this._init_toolbar(this);\n\n    var fig = this;\n\n    this.waiting = false;\n\n    this.ws.onopen = function () {\n        fig.send_message('supports_binary', { value: fig.supports_binary });\n        fig.send_message('send_image_mode', {});\n        if (fig.ratio !== 1) {\n            fig.send_message('set_device_pixel_ratio', {\n                device_pixel_ratio: fig.ratio,\n            });\n        }\n        fig.send_message('refresh', {});\n    };\n\n    this.imageObj.onload = function () {\n        if (fig.image_mode === 'full') {\n            // Full images could contain transparency (where diff images\n            // almost always do), so we need to clear the canvas so that\n            // there is no ghosting.\n            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n        }\n        fig.context.drawImage(fig.imageObj, 0, 0);\n    };\n\n    this.imageObj.onunload = function () {\n        fig.ws.close();\n    };\n\n    this.ws.onmessage = this._make_on_message_function(this);\n\n    this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n    var titlebar = document.createElement('div');\n    titlebar.classList =\n        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n    var titletext = document.createElement('div');\n    titletext.classList = 'ui-dialog-title';\n    titletext.setAttribute(\n        'style',\n        'width: 100%; text-align: center; padding: 3px;'\n    );\n    titlebar.appendChild(titletext);\n    this.root.appendChild(titlebar);\n    this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n    var fig = this;\n\n    var canvas_div = (this.canvas_div = document.createElement('div'));\n    canvas_div.setAttribute('tabindex', '0');\n    canvas_div.setAttribute(\n        'style',\n        'border: 1px solid #ddd;' +\n            'box-sizing: content-box;' +\n            'clear: both;' +\n            'min-height: 1px;' +\n            'min-width: 1px;' +\n            'outline: 0;' +\n            'overflow: hidden;' +\n            'position: relative;' +\n            'resize: both;' +\n            'z-index: 2;'\n    );\n\n    function on_keyboard_event_closure(name) {\n        return function (event) {\n            return fig.key_event(event, name);\n        };\n    }\n\n    canvas_div.addEventListener(\n        'keydown',\n        on_keyboard_event_closure('key_press')\n    );\n    canvas_div.addEventListener(\n        'keyup',\n        on_keyboard_event_closure('key_release')\n    );\n\n    this._canvas_extra_style(canvas_div);\n    this.root.appendChild(canvas_div);\n\n    var canvas = (this.canvas = document.createElement('canvas'));\n    canvas.classList.add('mpl-canvas');\n    canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'pointer-events: none;' +\n            'position: relative;' +\n            'z-index: 0;'\n    );\n\n    this.context = canvas.getContext('2d');\n\n    var backingStore =\n        this.context.backingStorePixelRatio ||\n        this.context.webkitBackingStorePixelRatio ||\n        this.context.mozBackingStorePixelRatio ||\n        this.context.msBackingStorePixelRatio ||\n        this.context.oBackingStorePixelRatio ||\n        this.context.backingStorePixelRatio ||\n        1;\n\n    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n        'canvas'\n    ));\n    rubberband_canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'left: 0;' +\n            'pointer-events: none;' +\n            'position: absolute;' +\n            'top: 0;' +\n            'z-index: 1;'\n    );\n\n    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n    if (this.ResizeObserver === undefined) {\n        if (window.ResizeObserver !== undefined) {\n            this.ResizeObserver = window.ResizeObserver;\n        } else {\n            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n            this.ResizeObserver = obs.ResizeObserver;\n        }\n    }\n\n    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n        // There's no need to resize if the WebSocket is not connected:\n        // - If it is still connecting, then we will get an initial resize from\n        //   Python once it connects.\n        // - If it has disconnected, then resizing will clear the canvas and\n        //   never get anything back to refill it, so better to not resize and\n        //   keep something visible.\n        if (fig.ws.readyState != 1) {\n            return;\n        }\n        var nentries = entries.length;\n        for (var i = 0; i < nentries; i++) {\n            var entry = entries[i];\n            var width, height;\n            if (entry.contentBoxSize) {\n                if (entry.contentBoxSize instanceof Array) {\n                    // Chrome 84 implements new version of spec.\n                    width = entry.contentBoxSize[0].inlineSize;\n                    height = entry.contentBoxSize[0].blockSize;\n                } else {\n                    // Firefox implements old version of spec.\n                    width = entry.contentBoxSize.inlineSize;\n                    height = entry.contentBoxSize.blockSize;\n                }\n            } else {\n                // Chrome <84 implements even older version of spec.\n                width = entry.contentRect.width;\n                height = entry.contentRect.height;\n            }\n\n            // Keep the size of the canvas and rubber band canvas in sync with\n            // the canvas container.\n            if (entry.devicePixelContentBoxSize) {\n                // Chrome 84 implements new version of spec.\n                canvas.setAttribute(\n                    'width',\n                    entry.devicePixelContentBoxSize[0].inlineSize\n                );\n                canvas.setAttribute(\n                    'height',\n                    entry.devicePixelContentBoxSize[0].blockSize\n                );\n            } else {\n                canvas.setAttribute('width', width * fig.ratio);\n                canvas.setAttribute('height', height * fig.ratio);\n            }\n            /* This rescales the canvas back to display pixels, so that it\n             * appears correct on HiDPI screens. */\n            canvas.style.width = width + 'px';\n            canvas.style.height = height + 'px';\n\n            rubberband_canvas.setAttribute('width', width);\n            rubberband_canvas.setAttribute('height', height);\n\n            // And update the size in Python. We ignore the initial 0/0 size\n            // that occurs as the element is placed into the DOM, which should\n            // otherwise not happen due to the minimum size styling.\n            if (width != 0 && height != 0) {\n                fig.request_resize(width, height);\n            }\n        }\n    });\n    this.resizeObserverInstance.observe(canvas_div);\n\n    function on_mouse_event_closure(name) {\n        /* User Agent sniffing is bad, but WebKit is busted:\n         * https://bugs.webkit.org/show_bug.cgi?id=144526\n         * https://bugs.webkit.org/show_bug.cgi?id=181818\n         * The worst that happens here is that they get an extra browser\n         * selection when dragging, if this check fails to catch them.\n         */\n        var UA = navigator.userAgent;\n        var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n        if(isWebKit) {\n            return function (event) {\n                /* This prevents the web browser from automatically changing to\n                 * the text insertion cursor when the button is pressed. We\n                 * want to control all of the cursor setting manually through\n                 * the 'cursor' event from matplotlib */\n                event.preventDefault()\n                return fig.mouse_event(event, name);\n            };\n        } else {\n            return function (event) {\n                return fig.mouse_event(event, name);\n            };\n        }\n    }\n\n    canvas_div.addEventListener(\n        'mousedown',\n        on_mouse_event_closure('button_press')\n    );\n    canvas_div.addEventListener(\n        'mouseup',\n        on_mouse_event_closure('button_release')\n    );\n    canvas_div.addEventListener(\n        'dblclick',\n        on_mouse_event_closure('dblclick')\n    );\n    // Throttle sequential mouse events to 1 every 20ms.\n    canvas_div.addEventListener(\n        'mousemove',\n        on_mouse_event_closure('motion_notify')\n    );\n\n    canvas_div.addEventListener(\n        'mouseenter',\n        on_mouse_event_closure('figure_enter')\n    );\n    canvas_div.addEventListener(\n        'mouseleave',\n        on_mouse_event_closure('figure_leave')\n    );\n\n    canvas_div.addEventListener('wheel', function (event) {\n        if (event.deltaY < 0) {\n            event.step = 1;\n        } else {\n            event.step = -1;\n        }\n        on_mouse_event_closure('scroll')(event);\n    });\n\n    canvas_div.appendChild(canvas);\n    canvas_div.appendChild(rubberband_canvas);\n\n    this.rubberband_context = rubberband_canvas.getContext('2d');\n    this.rubberband_context.strokeStyle = '#000000';\n\n    this._resize_canvas = function (width, height, forward) {\n        if (forward) {\n            canvas_div.style.width = width + 'px';\n            canvas_div.style.height = height + 'px';\n        }\n    };\n\n    // Disable right mouse context menu.\n    canvas_div.addEventListener('contextmenu', function (_e) {\n        event.preventDefault();\n        return false;\n    });\n\n    function set_focus() {\n        canvas.focus();\n        canvas_div.focus();\n    }\n\n    window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'mpl-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'mpl-button-group';\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'mpl-button-group';\n            continue;\n        }\n\n        var button = (fig.buttons[name] = document.createElement('button'));\n        button.classList = 'mpl-widget';\n        button.setAttribute('role', 'button');\n        button.setAttribute('aria-disabled', 'false');\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n        var icon_img = document.createElement('img');\n        icon_img.src = '_images/' + image + '.png';\n        icon_img.srcset = '_images/' + image + '_large.png 2x';\n        icon_img.alt = tooltip;\n        button.appendChild(icon_img);\n\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    var fmt_picker = document.createElement('select');\n    fmt_picker.classList = 'mpl-widget';\n    toolbar.appendChild(fmt_picker);\n    this.format_dropdown = fmt_picker;\n\n    for (var ind in mpl.extensions) {\n        var fmt = mpl.extensions[ind];\n        var option = document.createElement('option');\n        option.selected = fmt === mpl.default_extension;\n        option.innerHTML = fmt;\n        fmt_picker.appendChild(option);\n    }\n\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n    // which will in turn request a refresh of the image.\n    this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n    properties['type'] = type;\n    properties['figure_id'] = this.id;\n    this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n    if (!this.waiting) {\n        this.waiting = true;\n        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    var format_dropdown = fig.format_dropdown;\n    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n    fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n    var size = msg['size'];\n    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n        fig._resize_canvas(size[0], size[1], msg['forward']);\n        fig.send_message('refresh', {});\n    }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n    var x0 = msg['x0'] / fig.ratio;\n    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n    var x1 = msg['x1'] / fig.ratio;\n    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n    x0 = Math.floor(x0) + 0.5;\n    y0 = Math.floor(y0) + 0.5;\n    x1 = Math.floor(x1) + 0.5;\n    y1 = Math.floor(y1) + 0.5;\n    var min_x = Math.min(x0, x1);\n    var min_y = Math.min(y0, y1);\n    var width = Math.abs(x1 - x0);\n    var height = Math.abs(y1 - y0);\n\n    fig.rubberband_context.clearRect(\n        0,\n        0,\n        fig.canvas.width / fig.ratio,\n        fig.canvas.height / fig.ratio\n    );\n\n    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n    // Updates the figure title.\n    fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n    fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n    fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n    // Request the server to send over a new figure.\n    fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n    fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n    for (var key in msg) {\n        if (!(key in fig.buttons)) {\n            continue;\n        }\n        fig.buttons[key].disabled = !msg[key];\n        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n    }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n    if (msg['mode'] === 'PAN') {\n        fig.buttons['Pan'].classList.add('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    } else if (msg['mode'] === 'ZOOM') {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.add('active');\n    } else {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Called whenever the canvas gets updated.\n    this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n    return function socket_on_message(evt) {\n        if (evt.data instanceof Blob) {\n            var img = evt.data;\n            if (img.type !== 'image/png') {\n                /* FIXME: We get \"Resource interpreted as Image but\n                 * transferred with MIME type text/plain:\" errors on\n                 * Chrome.  But how to set the MIME type?  It doesn't seem\n                 * to be part of the websocket stream */\n                img.type = 'image/png';\n            }\n\n            /* Free the memory for the previous frames */\n            if (fig.imageObj.src) {\n                (window.URL || window.webkitURL).revokeObjectURL(\n                    fig.imageObj.src\n                );\n            }\n\n            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n                img\n            );\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        } else if (\n            typeof evt.data === 'string' &&\n            evt.data.slice(0, 21) === 'data:image/png;base64'\n        ) {\n            fig.imageObj.src = evt.data;\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        }\n\n        var msg = JSON.parse(evt.data);\n        var msg_type = msg['type'];\n\n        // Call the  \"handle_{type}\" callback, which takes\n        // the figure and JSON message as its only arguments.\n        try {\n            var callback = fig['handle_' + msg_type];\n        } catch (e) {\n            console.log(\n                \"No handler for the '\" + msg_type + \"' message type: \",\n                msg\n            );\n            return;\n        }\n\n        if (callback) {\n            try {\n                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n                callback(fig, msg);\n            } catch (e) {\n                console.log(\n                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n                    e,\n                    e.stack,\n                    msg\n                );\n            }\n        }\n    };\n};\n\nfunction getModifiers(event) {\n    var mods = [];\n    if (event.ctrlKey) {\n        mods.push('ctrl');\n    }\n    if (event.altKey) {\n        mods.push('alt');\n    }\n    if (event.shiftKey) {\n        mods.push('shift');\n    }\n    if (event.metaKey) {\n        mods.push('meta');\n    }\n    return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n    return Object.keys(original).reduce(function (obj, key) {\n        if (typeof original[key] !== 'object') {\n            obj[key] = original[key];\n        }\n        return obj;\n    }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n    if (name === 'button_press') {\n        this.canvas.focus();\n        this.canvas_div.focus();\n    }\n\n    // from https://stackoverflow.com/q/1114465\n    var boundingRect = this.canvas.getBoundingClientRect();\n    var x = (event.clientX - boundingRect.left) * this.ratio;\n    var y = (event.clientY - boundingRect.top) * this.ratio;\n\n    this.send_message(name, {\n        x: x,\n        y: y,\n        button: event.button,\n        step: event.step,\n        modifiers: getModifiers(event),\n        guiEvent: simpleKeys(event),\n    });\n\n    return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n    // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n    // Prevent repeat events\n    if (name === 'key_press') {\n        if (event.key === this._key) {\n            return;\n        } else {\n            this._key = event.key;\n        }\n    }\n    if (name === 'key_release') {\n        this._key = null;\n    }\n\n    var value = '';\n    if (event.ctrlKey && event.key !== 'Control') {\n        value += 'ctrl+';\n    }\n    else if (event.altKey && event.key !== 'Alt') {\n        value += 'alt+';\n    }\n    else if (event.shiftKey && event.key !== 'Shift') {\n        value += 'shift+';\n    }\n\n    value += 'k' + event.key;\n\n    this._key_event_extra(event, name);\n\n    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n    return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n    if (name === 'download') {\n        this.handle_save(this, null);\n    } else {\n        this.send_message('toolbar_button', { name: name });\n    }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n    this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n    // Create a \"websocket\"-like object which calls the given IPython comm\n    // object with the appropriate methods. Currently this is a non binary\n    // socket, so there is still some room for performance tuning.\n    var ws = {};\n\n    ws.binaryType = comm.kernel.ws.binaryType;\n    ws.readyState = comm.kernel.ws.readyState;\n    function updateReadyState(_event) {\n        if (comm.kernel.ws) {\n            ws.readyState = comm.kernel.ws.readyState;\n        } else {\n            ws.readyState = 3; // Closed state.\n        }\n    }\n    comm.kernel.ws.addEventListener('open', updateReadyState);\n    comm.kernel.ws.addEventListener('close', updateReadyState);\n    comm.kernel.ws.addEventListener('error', updateReadyState);\n\n    ws.close = function () {\n        comm.close();\n    };\n    ws.send = function (m) {\n        //console.log('sending', m);\n        comm.send(m);\n    };\n    // Register the callback with on_msg.\n    comm.on_msg(function (msg) {\n        //console.log('receiving', msg['content']['data'], msg);\n        var data = msg['content']['data'];\n        if (data['blob'] !== undefined) {\n            data = {\n                data: new Blob(msg['buffers'], { type: data['blob'] }),\n            };\n        }\n        // Pass the mpl event to the overridden (by mpl) onmessage function.\n        ws.onmessage(data);\n    });\n    return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n    // This is the function which gets called when the mpl process\n    // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n    var id = msg.content.data.id;\n    // Get hold of the div created by the display call when the Comm\n    // socket was opened in Python.\n    var element = document.getElementById(id);\n    var ws_proxy = comm_websocket_adapter(comm);\n\n    function ondownload(figure, _format) {\n        window.open(figure.canvas.toDataURL());\n    }\n\n    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n    // web socket which is closed, not our websocket->open comm proxy.\n    ws_proxy.onopen();\n\n    fig.parent_element = element;\n    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n    if (!fig.cell_info) {\n        console.error('Failed to find cell for figure', id, fig);\n        return;\n    }\n    fig.cell_info[0].output_area.element.on(\n        'cleared',\n        { fig: fig },\n        fig._remove_fig_handler\n    );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n    var width = fig.canvas.width / fig.ratio;\n    fig.cell_info[0].output_area.element.off(\n        'cleared',\n        fig._remove_fig_handler\n    );\n    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n    // Update the output cell to use the data from the current canvas.\n    fig.push_to_output();\n    var dataURL = fig.canvas.toDataURL();\n    // Re-enable the keyboard manager in IPython - without this line, in FF,\n    // the notebook keyboard shortcuts fail.\n    IPython.keyboard_manager.enable();\n    fig.parent_element.innerHTML =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n    fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n    fig.send_message('closing', msg);\n    // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n    // Turn the data on the canvas into data in the output cell.\n    var width = this.canvas.width / this.ratio;\n    var dataURL = this.canvas.toDataURL();\n    this.cell_info[1]['text/html'] =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Tell IPython that the notebook contents must change.\n    IPython.notebook.set_dirty(true);\n    this.send_message('ack', {});\n    var fig = this;\n    // Wait a second, then push the new image to the DOM so\n    // that it is saved nicely (might be nice to debounce this).\n    setTimeout(function () {\n        fig.push_to_output();\n    }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'btn-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'btn-group';\n    var button;\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'btn-group';\n            continue;\n        }\n\n        button = fig.buttons[name] = document.createElement('button');\n        button.classList = 'btn btn-default';\n        button.href = '#';\n        button.title = name;\n        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    // Add the status bar.\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message pull-right';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n\n    // Add the close button to the window.\n    var buttongrp = document.createElement('div');\n    buttongrp.classList = 'btn-group inline pull-right';\n    button = document.createElement('button');\n    button.classList = 'btn btn-mini btn-primary';\n    button.href = '#';\n    button.title = 'Stop Interaction';\n    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n    button.addEventListener('click', function (_evt) {\n        fig.handle_close(fig, {});\n    });\n    button.addEventListener(\n        'mouseover',\n        on_mouseover_closure('Stop Interaction')\n    );\n    buttongrp.appendChild(button);\n    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n    var fig = event.data.fig;\n    if (event.target !== this) {\n        // Ignore bubbled events from children.\n        return;\n    }\n    fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n    // this is important to make the div 'focusable\n    el.setAttribute('tabindex', 0);\n    // reach out to IPython and tell the keyboard manager to turn it's self\n    // off when our div gets focus\n\n    // location in version 3\n    if (IPython.notebook.keyboard_manager) {\n        IPython.notebook.keyboard_manager.register_events(el);\n    } else {\n        // location in version 2\n        IPython.keyboard_manager.register_events(el);\n    }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n    // Check for shift+enter\n    if (event.shiftKey && event.which === 13) {\n        this.canvas_div.blur();\n        // select the cell after this one\n        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n        IPython.notebook.select(index + 1);\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n    // Return the cell and output element which can be found *uniquely* in the notebook.\n    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n    // IPython event is triggered only after the cells have been serialised, which for\n    // our purposes (turning an active figure into a static one), is too late.\n    var cells = IPython.notebook.get_cells();\n    var ncells = cells.length;\n    for (var i = 0; i < ncells; i++) {\n        var cell = cells[i];\n        if (cell.cell_type === 'code') {\n            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n                var data = cell.output_area.outputs[j];\n                if (data.data) {\n                    // IPython >= 3 moved mimebundle to data attribute of output\n                    data = data.data;\n                }\n                if (data['text/html'] === html_output) {\n                    return [cell, data, j];\n                }\n            }\n        }\n    }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n    IPython.notebook.kernel.comm_manager.register_target(\n        'matplotlib',\n        mpl.mpl_figure_comm\n    );\n}\n",
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div id='fde0bdfd-a5b4-47b9-8a9d-2e7438a270ae'></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100044.11551171874\n",
+      "Sharpe Ratio: -44.33552762009954\n",
+      "Max Drawdown: 0.178009113397425\n",
+      "Total Trades: 1\n",
+      "Winning Trades: 1\n",
+      "Losing Trades: 0\n",
+      "Total Return: 0.00044105783687816173\n",
+      "Running backtest for MacdStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100927.54\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100927.54213549806\n",
+      "Sharpe Ratio: -1.2165196237868399\n",
+      "Max Drawdown: 1.3007929155129758\n",
+      "Total Trades: 13\n",
+      "Winning Trades: 4\n",
+      "Losing Trades: 9\n",
+      "Total Return: 0.009232668796317978\n",
+      "Running backtest for StochasticOscillatorStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100740.58\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100740.57570678712\n",
+      "Sharpe Ratio: -1.184578981873076\n",
+      "Max Drawdown: 0.34094949414063014\n",
+      "Total Trades: 5\n",
+      "Winning Trades: 3\n",
+      "Losing Trades: 1\n",
+      "Total Return: 0.0073784690915939906\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 15 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import sys \n",
+    "import matplotlib.pyplot as plt\n",
+    "root_path = os.path.abspath(os.path.join(os.getcwd(), './uni2ts/src'))\n",
+    "sys.path.append(root_path)\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from einops import rearrange\n",
+    "from gluonts.dataset.pandas import PandasDataset\n",
+    "from gluonts.dataset.split import split\n",
+    "from gluonts.torch.model.predictor import PyTorchPredictor\n",
+    "import yfinance as yf\n",
+    "\n",
+    "from uni2ts.eval_util.plot import plot_single\n",
+    "from uni2ts.model.moirai import MoiraiForecast, MoiraiModule\n",
+    "import backtrader as bt\n",
+    "\n",
+    "# Step 1: Fetch Data from Yahoo Finance\n",
+    "def fetch_data(symbol, since):\n",
+    "    try:\n",
+    "        ticker = yf.Ticker(symbol)\n",
+    "        ohlcv = ticker.history(period='1d', start=since)\n",
+    "        ohlcv.reset_index(inplace=True)\n",
+    "        ohlcv['timestamp'] = pd.to_datetime(ohlcv['Date'])\n",
+    "        ohlcv.set_index('timestamp', inplace=True)\n",
+    "        ohlcv = ohlcv[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+    "        ohlcv.rename(columns={'Open': 'open', 'High': 'high', 'Low': 'low', 'Close': 'close', 'Volume': 'volume'}, inplace=True)\n",
+    "        \n",
+    "        # Ensure the data is uniformly spaced by resampling\n",
+    "        ohlcv = ohlcv.resample('D').ffill()\n",
+    "        \n",
+    "        return ohlcv\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error fetching data for {symbol}: {str(e)}\")\n",
+    "        return None\n",
+    "\n",
+    "def load_and_predict(data):\n",
+    "    # Use only the 'close' price for forecasting\n",
+    "    df = data[['close']].rename(columns={'close': 'target'})\n",
+    "\n",
+    "    # Ensure data is sorted\n",
+    "    df = df.sort_index()\n",
+    "\n",
+    "    # Step 2: Prepare the Data for the Model\n",
+    "    # Convert into GluonTS dataset\n",
+    "    ds = PandasDataset(dict(df), freq=\"D\")\n",
+    "\n",
+    "    # Split into train/test set\n",
+    "    TEST = 100  # Define the length of the test set\n",
+    "    PDT = 20  # Define the prediction length\n",
+    "    train, test_template = split(ds, offset=-TEST)\n",
+    "\n",
+    "    # Ensure the length of the dataset is sufficient for rolling window evaluation\n",
+    "    total_length = len(df)\n",
+    "    if total_length < TEST + PDT:\n",
+    "        raise ValueError(f\"Not enough data points. Total length: {total_length}, TEST: {TEST}, PDT: {PDT}\")\n",
+    "\n",
+    "    # Construct rolling window evaluation\n",
+    "    test_data = test_template.generate_instances(\n",
+    "        prediction_length=PDT,\n",
+    "        windows=TEST // PDT,\n",
+    "        distance=PDT\n",
+    "    )\n",
+    "\n",
+    "    # Step 3: Load the Model and Make Predictions\n",
+    "    SIZE = \"small\"  # Model size\n",
+    "    CTX = 200  # Context length\n",
+    "    PSZ = \"auto\"  # Patch size\n",
+    "    BSZ = 32  # Batch size\n",
+    "\n",
+    "    # Prepare pre-trained model by downloading model weights from Hugging Face hub\n",
+    "    model = MoiraiForecast(\n",
+    "        module=MoiraiModule.from_pretrained(f\"Salesforce/moirai-1.0-R-{SIZE}\"),\n",
+    "        prediction_length=PDT,\n",
+    "        context_length=CTX,\n",
+    "        patch_size=PSZ,\n",
+    "        num_samples=100,\n",
+    "        target_dim=1,\n",
+    "        feat_dynamic_real_dim=ds.num_feat_dynamic_real,\n",
+    "        past_feat_dynamic_real_dim=ds.num_past_feat_dynamic_real,\n",
+    "    )\n",
+    "\n",
+    "    predictor = model.create_predictor(batch_size=BSZ)\n",
+    "    forecasts = predictor.predict(test_data.input)\n",
+    "\n",
+    "    # Step 4: Plot the Results\n",
+    "    input_it = iter(test_data.input)\n",
+    "    label_it = iter(test_data.label)\n",
+    "    forecast_it = iter(forecasts)\n",
+    "\n",
+    "    try:\n",
+    "        inp = next(input_it)\n",
+    "        label = next(label_it)\n",
+    "        forecast = next(forecast_it)\n",
+    "\n",
+    "        plot_single(\n",
+    "            inp, \n",
+    "            label, \n",
+    "            forecast, \n",
+    "            context_length=CTX,\n",
+    "            name=\"pred\",\n",
+    "            show_label=True,\n",
+    "        )\n",
+    "        plt.show()\n",
+    "    except StopIteration:\n",
+    "        print(\"Error: Not enough data points to generate forecasts.\")\n",
+    "    \n",
+    "    return forecasts\n",
+    "\n",
+    "# Define the strategies\n",
+    "class RsiBollingerBandsStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('rsi_period', 14),\n",
+    "        ('bb_period', 20),\n",
+    "        ('bb_dev', 2),\n",
+    "        ('oversold', 30),\n",
+    "        ('overbought', 70),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.rsi = bt.indicators.RelativeStrengthIndex(period=self.params.rsi_period)\n",
+    "        self.bbands = bt.indicators.BollingerBands(period=self.params.bb_period, devfactor=self.params.bb_dev)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.rsi < self.params.oversold and self.data.close <= self.bbands.lines.bot:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.rsi > self.params.overbought or self.data.close >= self.bbands.lines.top:\n",
+    "                self.sell()\n",
+    "        \n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class MacdStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('macd1_period', 12),\n",
+    "        ('macd2_period', 26),\n",
+    "        ('signal_period', 9),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.macd = bt.indicators.MACDHisto(period_me1=self.params.macd1_period, period_me2=self.params.macd2_period, period_signal=self.params.signal_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.macd.lines.histo[0] > 0 and self.macd.lines.histo[-1] <= 0:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.macd.lines.histo[0] < 0 and self.macd.lines.histo[-1] >= 0:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class StochasticOscillatorStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('stoch_period', 14),\n",
+    "        ('stoch_low', 20),\n",
+    "        ('stoch_high', 80),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.stoch = bt.indicators.Stochastic(period=self.params.stoch_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.stoch.lines.percK[0] < self.params.stoch_low and self.stoch.lines.percK[-1] >= self.params.stoch_low:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.stoch.lines.percK[0] > self.params.stoch_high and self.stoch.lines.percK[-1] <= self.params.stoch_high:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "def run_backtest(strategy_class, symbol, since):\n",
+    "    # Fetch data for backtesting\n",
+    "    data = fetch_data(symbol, since)\n",
+    "\n",
+    "    # Load and make predictions\n",
+    "    predictions = load_and_predict(data)\n",
+    "\n",
+    "    # Initialize cerebro\n",
+    "    cerebro = bt.Cerebro()\n",
+    "    \n",
+    "    # Add data feed\n",
+    "    cerebro.adddata(bt.feeds.PandasData(dataname=data))\n",
+    "    \n",
+    "    # Add strategy with predictions\n",
+    "    cerebro.addstrategy(strategy_class, predictions=predictions)\n",
+    "    \n",
+    "    # Set broker settings\n",
+    "    cerebro.broker.set_cash(100000)\n",
+    "    cerebro.broker.setcommission(commission=0.002)\n",
+    "\n",
+    "    # Add analyzers for performance metrics\n",
+    "    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')\n",
+    "    cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')\n",
+    "    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')\n",
+    "    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')\n",
+    "\n",
+    "    # Print starting conditions\n",
+    "    start_value = cerebro.broker.getvalue()\n",
+    "    print(f'Starting Portfolio Value: {start_value:.2f}')\n",
+    "\n",
+    "    # Run backtest\n",
+    "    results = cerebro.run()\n",
+    "\n",
+    "    # Print ending conditions\n",
+    "    end_value = cerebro.broker.getvalue()\n",
+    "    print(f'Ending Portfolio Value: {end_value:.2f}')\n",
+    "\n",
+    "    # Extracting backtest metrics\n",
+    "    strat = results[0]\n",
+    "\n",
+    "    # Prepare results\n",
+    "    result_dict = {\n",
+    "        \"Starting Portfolio Value\": start_value,\n",
+    "        \"Ending Portfolio Value\": end_value,\n",
+    "        \"Sharpe Ratio\": strat.analyzers.sharpe.get_analysis().get('sharperatio', 'N/A'),\n",
+    "        \"Max Drawdown\": strat.analyzers.drawdown.get_analysis().get('max', {}).get('drawdown', 'N/A'),\n",
+    "        \"Total Trades\": strat.analyzers.trades.get_analysis().get('total', {}).get('total', 'N/A'),\n",
+    "        \"Winning Trades\": strat.analyzers.trades.get_analysis().get('won', {}).get('total', 'N/A'),\n",
+    "        \"Losing Trades\": strat.analyzers.trades.get_analysis().get('lost', {}).get('total', 'N/A'),\n",
+    "        \"Total Return\": strat.analyzers.returns.get_analysis().get('rtot', 'N/A')\n",
+    "    }\n",
+    "\n",
+    "    # Plot the results\n",
+    "    cerebro.plot(style='candlestick')\n",
+    "\n",
+    "    # Print metrics\n",
+    "    print(\"Metrics:\")\n",
+    "    for key, value in result_dict.items():\n",
+    "        print(f\"{key}: {value}\")\n",
+    "\n",
+    "    return result_dict\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    symbol = 'ETH-USD'\n",
+    "    since = '2023-06-20'\n",
+    "    \n",
+    "    strategies = [RsiBollingerBandsStrategy, MacdStrategy, StochasticOscillatorStrategy]\n",
+    "    \n",
+    "    for strategy in strategies:\n",
+    "        print(f\"Running backtest for {strategy.__name__}\")\n",
+    "        run_backtest(strategy, symbol, since)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Complete code with start date and end date is specified"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/json.py:101: UserWarning: Using `json`-module for json-handling. Consider installing one of `orjson`, `ujson` to speed up serialization and deserialization.\n",
+      "  warnings.warn(\n",
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running backtest for RsiBollingerBandsStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100044.12\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n    if (typeof WebSocket !== 'undefined') {\n        return WebSocket;\n    } else if (typeof MozWebSocket !== 'undefined') {\n        return MozWebSocket;\n    } else {\n        alert(\n            'Your browser does not have WebSocket support. ' +\n                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n                'Firefox 4 and 5 are also supported but you ' +\n                'have to enable WebSockets in about:config.'\n        );\n    }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n    this.id = figure_id;\n\n    this.ws = websocket;\n\n    this.supports_binary = this.ws.binaryType !== undefined;\n\n    if (!this.supports_binary) {\n        var warnings = document.getElementById('mpl-warnings');\n        if (warnings) {\n            warnings.style.display = 'block';\n            warnings.textContent =\n                'This browser does not support binary websocket messages. ' +\n                'Performance may be slow.';\n        }\n    }\n\n    this.imageObj = new Image();\n\n    this.context = undefined;\n    this.message = undefined;\n    this.canvas = undefined;\n    this.rubberband_canvas = undefined;\n    this.rubberband_context = undefined;\n    this.format_dropdown = undefined;\n\n    this.image_mode = 'full';\n\n    this.root = document.createElement('div');\n    this.root.setAttribute('style', 'display: inline-block');\n    this._root_extra_style(this.root);\n\n    parent_element.appendChild(this.root);\n\n    this._init_header(this);\n    this._init_canvas(this);\n    this._init_toolbar(this);\n\n    var fig = this;\n\n    this.waiting = false;\n\n    this.ws.onopen = function () {\n        fig.send_message('supports_binary', { value: fig.supports_binary });\n        fig.send_message('send_image_mode', {});\n        if (fig.ratio !== 1) {\n            fig.send_message('set_device_pixel_ratio', {\n                device_pixel_ratio: fig.ratio,\n            });\n        }\n        fig.send_message('refresh', {});\n    };\n\n    this.imageObj.onload = function () {\n        if (fig.image_mode === 'full') {\n            // Full images could contain transparency (where diff images\n            // almost always do), so we need to clear the canvas so that\n            // there is no ghosting.\n            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n        }\n        fig.context.drawImage(fig.imageObj, 0, 0);\n    };\n\n    this.imageObj.onunload = function () {\n        fig.ws.close();\n    };\n\n    this.ws.onmessage = this._make_on_message_function(this);\n\n    this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n    var titlebar = document.createElement('div');\n    titlebar.classList =\n        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n    var titletext = document.createElement('div');\n    titletext.classList = 'ui-dialog-title';\n    titletext.setAttribute(\n        'style',\n        'width: 100%; text-align: center; padding: 3px;'\n    );\n    titlebar.appendChild(titletext);\n    this.root.appendChild(titlebar);\n    this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n    var fig = this;\n\n    var canvas_div = (this.canvas_div = document.createElement('div'));\n    canvas_div.setAttribute('tabindex', '0');\n    canvas_div.setAttribute(\n        'style',\n        'border: 1px solid #ddd;' +\n            'box-sizing: content-box;' +\n            'clear: both;' +\n            'min-height: 1px;' +\n            'min-width: 1px;' +\n            'outline: 0;' +\n            'overflow: hidden;' +\n            'position: relative;' +\n            'resize: both;' +\n            'z-index: 2;'\n    );\n\n    function on_keyboard_event_closure(name) {\n        return function (event) {\n            return fig.key_event(event, name);\n        };\n    }\n\n    canvas_div.addEventListener(\n        'keydown',\n        on_keyboard_event_closure('key_press')\n    );\n    canvas_div.addEventListener(\n        'keyup',\n        on_keyboard_event_closure('key_release')\n    );\n\n    this._canvas_extra_style(canvas_div);\n    this.root.appendChild(canvas_div);\n\n    var canvas = (this.canvas = document.createElement('canvas'));\n    canvas.classList.add('mpl-canvas');\n    canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'pointer-events: none;' +\n            'position: relative;' +\n            'z-index: 0;'\n    );\n\n    this.context = canvas.getContext('2d');\n\n    var backingStore =\n        this.context.backingStorePixelRatio ||\n        this.context.webkitBackingStorePixelRatio ||\n        this.context.mozBackingStorePixelRatio ||\n        this.context.msBackingStorePixelRatio ||\n        this.context.oBackingStorePixelRatio ||\n        this.context.backingStorePixelRatio ||\n        1;\n\n    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n        'canvas'\n    ));\n    rubberband_canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'left: 0;' +\n            'pointer-events: none;' +\n            'position: absolute;' +\n            'top: 0;' +\n            'z-index: 1;'\n    );\n\n    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n    if (this.ResizeObserver === undefined) {\n        if (window.ResizeObserver !== undefined) {\n            this.ResizeObserver = window.ResizeObserver;\n        } else {\n            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n            this.ResizeObserver = obs.ResizeObserver;\n        }\n    }\n\n    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n        // There's no need to resize if the WebSocket is not connected:\n        // - If it is still connecting, then we will get an initial resize from\n        //   Python once it connects.\n        // - If it has disconnected, then resizing will clear the canvas and\n        //   never get anything back to refill it, so better to not resize and\n        //   keep something visible.\n        if (fig.ws.readyState != 1) {\n            return;\n        }\n        var nentries = entries.length;\n        for (var i = 0; i < nentries; i++) {\n            var entry = entries[i];\n            var width, height;\n            if (entry.contentBoxSize) {\n                if (entry.contentBoxSize instanceof Array) {\n                    // Chrome 84 implements new version of spec.\n                    width = entry.contentBoxSize[0].inlineSize;\n                    height = entry.contentBoxSize[0].blockSize;\n                } else {\n                    // Firefox implements old version of spec.\n                    width = entry.contentBoxSize.inlineSize;\n                    height = entry.contentBoxSize.blockSize;\n                }\n            } else {\n                // Chrome <84 implements even older version of spec.\n                width = entry.contentRect.width;\n                height = entry.contentRect.height;\n            }\n\n            // Keep the size of the canvas and rubber band canvas in sync with\n            // the canvas container.\n            if (entry.devicePixelContentBoxSize) {\n                // Chrome 84 implements new version of spec.\n                canvas.setAttribute(\n                    'width',\n                    entry.devicePixelContentBoxSize[0].inlineSize\n                );\n                canvas.setAttribute(\n                    'height',\n                    entry.devicePixelContentBoxSize[0].blockSize\n                );\n            } else {\n                canvas.setAttribute('width', width * fig.ratio);\n                canvas.setAttribute('height', height * fig.ratio);\n            }\n            /* This rescales the canvas back to display pixels, so that it\n             * appears correct on HiDPI screens. */\n            canvas.style.width = width + 'px';\n            canvas.style.height = height + 'px';\n\n            rubberband_canvas.setAttribute('width', width);\n            rubberband_canvas.setAttribute('height', height);\n\n            // And update the size in Python. We ignore the initial 0/0 size\n            // that occurs as the element is placed into the DOM, which should\n            // otherwise not happen due to the minimum size styling.\n            if (width != 0 && height != 0) {\n                fig.request_resize(width, height);\n            }\n        }\n    });\n    this.resizeObserverInstance.observe(canvas_div);\n\n    function on_mouse_event_closure(name) {\n        /* User Agent sniffing is bad, but WebKit is busted:\n         * https://bugs.webkit.org/show_bug.cgi?id=144526\n         * https://bugs.webkit.org/show_bug.cgi?id=181818\n         * The worst that happens here is that they get an extra browser\n         * selection when dragging, if this check fails to catch them.\n         */\n        var UA = navigator.userAgent;\n        var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n        if(isWebKit) {\n            return function (event) {\n                /* This prevents the web browser from automatically changing to\n                 * the text insertion cursor when the button is pressed. We\n                 * want to control all of the cursor setting manually through\n                 * the 'cursor' event from matplotlib */\n                event.preventDefault()\n                return fig.mouse_event(event, name);\n            };\n        } else {\n            return function (event) {\n                return fig.mouse_event(event, name);\n            };\n        }\n    }\n\n    canvas_div.addEventListener(\n        'mousedown',\n        on_mouse_event_closure('button_press')\n    );\n    canvas_div.addEventListener(\n        'mouseup',\n        on_mouse_event_closure('button_release')\n    );\n    canvas_div.addEventListener(\n        'dblclick',\n        on_mouse_event_closure('dblclick')\n    );\n    // Throttle sequential mouse events to 1 every 20ms.\n    canvas_div.addEventListener(\n        'mousemove',\n        on_mouse_event_closure('motion_notify')\n    );\n\n    canvas_div.addEventListener(\n        'mouseenter',\n        on_mouse_event_closure('figure_enter')\n    );\n    canvas_div.addEventListener(\n        'mouseleave',\n        on_mouse_event_closure('figure_leave')\n    );\n\n    canvas_div.addEventListener('wheel', function (event) {\n        if (event.deltaY < 0) {\n            event.step = 1;\n        } else {\n            event.step = -1;\n        }\n        on_mouse_event_closure('scroll')(event);\n    });\n\n    canvas_div.appendChild(canvas);\n    canvas_div.appendChild(rubberband_canvas);\n\n    this.rubberband_context = rubberband_canvas.getContext('2d');\n    this.rubberband_context.strokeStyle = '#000000';\n\n    this._resize_canvas = function (width, height, forward) {\n        if (forward) {\n            canvas_div.style.width = width + 'px';\n            canvas_div.style.height = height + 'px';\n        }\n    };\n\n    // Disable right mouse context menu.\n    canvas_div.addEventListener('contextmenu', function (_e) {\n        event.preventDefault();\n        return false;\n    });\n\n    function set_focus() {\n        canvas.focus();\n        canvas_div.focus();\n    }\n\n    window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'mpl-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'mpl-button-group';\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'mpl-button-group';\n            continue;\n        }\n\n        var button = (fig.buttons[name] = document.createElement('button'));\n        button.classList = 'mpl-widget';\n        button.setAttribute('role', 'button');\n        button.setAttribute('aria-disabled', 'false');\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n        var icon_img = document.createElement('img');\n        icon_img.src = '_images/' + image + '.png';\n        icon_img.srcset = '_images/' + image + '_large.png 2x';\n        icon_img.alt = tooltip;\n        button.appendChild(icon_img);\n\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    var fmt_picker = document.createElement('select');\n    fmt_picker.classList = 'mpl-widget';\n    toolbar.appendChild(fmt_picker);\n    this.format_dropdown = fmt_picker;\n\n    for (var ind in mpl.extensions) {\n        var fmt = mpl.extensions[ind];\n        var option = document.createElement('option');\n        option.selected = fmt === mpl.default_extension;\n        option.innerHTML = fmt;\n        fmt_picker.appendChild(option);\n    }\n\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n    // which will in turn request a refresh of the image.\n    this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n    properties['type'] = type;\n    properties['figure_id'] = this.id;\n    this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n    if (!this.waiting) {\n        this.waiting = true;\n        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    var format_dropdown = fig.format_dropdown;\n    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n    fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n    var size = msg['size'];\n    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n        fig._resize_canvas(size[0], size[1], msg['forward']);\n        fig.send_message('refresh', {});\n    }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n    var x0 = msg['x0'] / fig.ratio;\n    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n    var x1 = msg['x1'] / fig.ratio;\n    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n    x0 = Math.floor(x0) + 0.5;\n    y0 = Math.floor(y0) + 0.5;\n    x1 = Math.floor(x1) + 0.5;\n    y1 = Math.floor(y1) + 0.5;\n    var min_x = Math.min(x0, x1);\n    var min_y = Math.min(y0, y1);\n    var width = Math.abs(x1 - x0);\n    var height = Math.abs(y1 - y0);\n\n    fig.rubberband_context.clearRect(\n        0,\n        0,\n        fig.canvas.width / fig.ratio,\n        fig.canvas.height / fig.ratio\n    );\n\n    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n    // Updates the figure title.\n    fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n    fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n    fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n    // Request the server to send over a new figure.\n    fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n    fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n    for (var key in msg) {\n        if (!(key in fig.buttons)) {\n            continue;\n        }\n        fig.buttons[key].disabled = !msg[key];\n        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n    }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n    if (msg['mode'] === 'PAN') {\n        fig.buttons['Pan'].classList.add('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    } else if (msg['mode'] === 'ZOOM') {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.add('active');\n    } else {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Called whenever the canvas gets updated.\n    this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n    return function socket_on_message(evt) {\n        if (evt.data instanceof Blob) {\n            var img = evt.data;\n            if (img.type !== 'image/png') {\n                /* FIXME: We get \"Resource interpreted as Image but\n                 * transferred with MIME type text/plain:\" errors on\n                 * Chrome.  But how to set the MIME type?  It doesn't seem\n                 * to be part of the websocket stream */\n                img.type = 'image/png';\n            }\n\n            /* Free the memory for the previous frames */\n            if (fig.imageObj.src) {\n                (window.URL || window.webkitURL).revokeObjectURL(\n                    fig.imageObj.src\n                );\n            }\n\n            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n                img\n            );\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        } else if (\n            typeof evt.data === 'string' &&\n            evt.data.slice(0, 21) === 'data:image/png;base64'\n        ) {\n            fig.imageObj.src = evt.data;\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        }\n\n        var msg = JSON.parse(evt.data);\n        var msg_type = msg['type'];\n\n        // Call the  \"handle_{type}\" callback, which takes\n        // the figure and JSON message as its only arguments.\n        try {\n            var callback = fig['handle_' + msg_type];\n        } catch (e) {\n            console.log(\n                \"No handler for the '\" + msg_type + \"' message type: \",\n                msg\n            );\n            return;\n        }\n\n        if (callback) {\n            try {\n                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n                callback(fig, msg);\n            } catch (e) {\n                console.log(\n                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n                    e,\n                    e.stack,\n                    msg\n                );\n            }\n        }\n    };\n};\n\nfunction getModifiers(event) {\n    var mods = [];\n    if (event.ctrlKey) {\n        mods.push('ctrl');\n    }\n    if (event.altKey) {\n        mods.push('alt');\n    }\n    if (event.shiftKey) {\n        mods.push('shift');\n    }\n    if (event.metaKey) {\n        mods.push('meta');\n    }\n    return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n    return Object.keys(original).reduce(function (obj, key) {\n        if (typeof original[key] !== 'object') {\n            obj[key] = original[key];\n        }\n        return obj;\n    }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n    if (name === 'button_press') {\n        this.canvas.focus();\n        this.canvas_div.focus();\n    }\n\n    // from https://stackoverflow.com/q/1114465\n    var boundingRect = this.canvas.getBoundingClientRect();\n    var x = (event.clientX - boundingRect.left) * this.ratio;\n    var y = (event.clientY - boundingRect.top) * this.ratio;\n\n    this.send_message(name, {\n        x: x,\n        y: y,\n        button: event.button,\n        step: event.step,\n        modifiers: getModifiers(event),\n        guiEvent: simpleKeys(event),\n    });\n\n    return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n    // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n    // Prevent repeat events\n    if (name === 'key_press') {\n        if (event.key === this._key) {\n            return;\n        } else {\n            this._key = event.key;\n        }\n    }\n    if (name === 'key_release') {\n        this._key = null;\n    }\n\n    var value = '';\n    if (event.ctrlKey && event.key !== 'Control') {\n        value += 'ctrl+';\n    }\n    else if (event.altKey && event.key !== 'Alt') {\n        value += 'alt+';\n    }\n    else if (event.shiftKey && event.key !== 'Shift') {\n        value += 'shift+';\n    }\n\n    value += 'k' + event.key;\n\n    this._key_event_extra(event, name);\n\n    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n    return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n    if (name === 'download') {\n        this.handle_save(this, null);\n    } else {\n        this.send_message('toolbar_button', { name: name });\n    }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n    this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n    // Create a \"websocket\"-like object which calls the given IPython comm\n    // object with the appropriate methods. Currently this is a non binary\n    // socket, so there is still some room for performance tuning.\n    var ws = {};\n\n    ws.binaryType = comm.kernel.ws.binaryType;\n    ws.readyState = comm.kernel.ws.readyState;\n    function updateReadyState(_event) {\n        if (comm.kernel.ws) {\n            ws.readyState = comm.kernel.ws.readyState;\n        } else {\n            ws.readyState = 3; // Closed state.\n        }\n    }\n    comm.kernel.ws.addEventListener('open', updateReadyState);\n    comm.kernel.ws.addEventListener('close', updateReadyState);\n    comm.kernel.ws.addEventListener('error', updateReadyState);\n\n    ws.close = function () {\n        comm.close();\n    };\n    ws.send = function (m) {\n        //console.log('sending', m);\n        comm.send(m);\n    };\n    // Register the callback with on_msg.\n    comm.on_msg(function (msg) {\n        //console.log('receiving', msg['content']['data'], msg);\n        var data = msg['content']['data'];\n        if (data['blob'] !== undefined) {\n            data = {\n                data: new Blob(msg['buffers'], { type: data['blob'] }),\n            };\n        }\n        // Pass the mpl event to the overridden (by mpl) onmessage function.\n        ws.onmessage(data);\n    });\n    return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n    // This is the function which gets called when the mpl process\n    // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n    var id = msg.content.data.id;\n    // Get hold of the div created by the display call when the Comm\n    // socket was opened in Python.\n    var element = document.getElementById(id);\n    var ws_proxy = comm_websocket_adapter(comm);\n\n    function ondownload(figure, _format) {\n        window.open(figure.canvas.toDataURL());\n    }\n\n    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n    // web socket which is closed, not our websocket->open comm proxy.\n    ws_proxy.onopen();\n\n    fig.parent_element = element;\n    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n    if (!fig.cell_info) {\n        console.error('Failed to find cell for figure', id, fig);\n        return;\n    }\n    fig.cell_info[0].output_area.element.on(\n        'cleared',\n        { fig: fig },\n        fig._remove_fig_handler\n    );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n    var width = fig.canvas.width / fig.ratio;\n    fig.cell_info[0].output_area.element.off(\n        'cleared',\n        fig._remove_fig_handler\n    );\n    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n    // Update the output cell to use the data from the current canvas.\n    fig.push_to_output();\n    var dataURL = fig.canvas.toDataURL();\n    // Re-enable the keyboard manager in IPython - without this line, in FF,\n    // the notebook keyboard shortcuts fail.\n    IPython.keyboard_manager.enable();\n    fig.parent_element.innerHTML =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n    fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n    fig.send_message('closing', msg);\n    // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n    // Turn the data on the canvas into data in the output cell.\n    var width = this.canvas.width / this.ratio;\n    var dataURL = this.canvas.toDataURL();\n    this.cell_info[1]['text/html'] =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Tell IPython that the notebook contents must change.\n    IPython.notebook.set_dirty(true);\n    this.send_message('ack', {});\n    var fig = this;\n    // Wait a second, then push the new image to the DOM so\n    // that it is saved nicely (might be nice to debounce this).\n    setTimeout(function () {\n        fig.push_to_output();\n    }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'btn-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'btn-group';\n    var button;\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'btn-group';\n            continue;\n        }\n\n        button = fig.buttons[name] = document.createElement('button');\n        button.classList = 'btn btn-default';\n        button.href = '#';\n        button.title = name;\n        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    // Add the status bar.\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message pull-right';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n\n    // Add the close button to the window.\n    var buttongrp = document.createElement('div');\n    buttongrp.classList = 'btn-group inline pull-right';\n    button = document.createElement('button');\n    button.classList = 'btn btn-mini btn-primary';\n    button.href = '#';\n    button.title = 'Stop Interaction';\n    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n    button.addEventListener('click', function (_evt) {\n        fig.handle_close(fig, {});\n    });\n    button.addEventListener(\n        'mouseover',\n        on_mouseover_closure('Stop Interaction')\n    );\n    buttongrp.appendChild(button);\n    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n    var fig = event.data.fig;\n    if (event.target !== this) {\n        // Ignore bubbled events from children.\n        return;\n    }\n    fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n    // this is important to make the div 'focusable\n    el.setAttribute('tabindex', 0);\n    // reach out to IPython and tell the keyboard manager to turn it's self\n    // off when our div gets focus\n\n    // location in version 3\n    if (IPython.notebook.keyboard_manager) {\n        IPython.notebook.keyboard_manager.register_events(el);\n    } else {\n        // location in version 2\n        IPython.keyboard_manager.register_events(el);\n    }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n    // Check for shift+enter\n    if (event.shiftKey && event.which === 13) {\n        this.canvas_div.blur();\n        // select the cell after this one\n        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n        IPython.notebook.select(index + 1);\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n    // Return the cell and output element which can be found *uniquely* in the notebook.\n    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n    // IPython event is triggered only after the cells have been serialised, which for\n    // our purposes (turning an active figure into a static one), is too late.\n    var cells = IPython.notebook.get_cells();\n    var ncells = cells.length;\n    for (var i = 0; i < ncells; i++) {\n        var cell = cells[i];\n        if (cell.cell_type === 'code') {\n            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n                var data = cell.output_area.outputs[j];\n                if (data.data) {\n                    // IPython >= 3 moved mimebundle to data attribute of output\n                    data = data.data;\n                }\n                if (data['text/html'] === html_output) {\n                    return [cell, data, j];\n                }\n            }\n        }\n    }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n    IPython.notebook.kernel.comm_manager.register_target(\n        'matplotlib',\n        mpl.mpl_figure_comm\n    );\n}\n",
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div id='1d3b1eff-9704-4abc-bf1d-642c294c4823'></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100044.11551171874\n",
+      "Sharpe Ratio: -44.33552762009954\n",
+      "Max Drawdown: 0.178009113397425\n",
+      "Total Trades: 1\n",
+      "Winning Trades: 1\n",
+      "Losing Trades: 0\n",
+      "Total Return: 0.00044105783687816173\n",
+      "Running backtest for MacdStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100927.54\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100927.54213549806\n",
+      "Sharpe Ratio: -1.2165196237868399\n",
+      "Max Drawdown: 1.3007929155129758\n",
+      "Total Trades: 13\n",
+      "Winning Trades: 4\n",
+      "Losing Trades: 9\n",
+      "Total Return: 0.009232668796317978\n",
+      "Running backtest for StochasticOscillatorStrategy\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/Air/crypto-trading-backtesting/.crypto/lib/python3.11/site-packages/gluonts/dataset/pandas.py:174: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n",
+      "  df = df.to_period(freq=self.freq)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Portfolio Value: 100000.00\n",
+      "Ending Portfolio Value: 100922.40\n",
+      "Metrics:\n",
+      "Starting Portfolio Value: 100000\n",
+      "Ending Portfolio Value: 100922.39797241212\n",
+      "Sharpe Ratio: -0.8647908600419059\n",
+      "Max Drawdown: 0.34094949414063014\n",
+      "Total Trades: 5\n",
+      "Winning Trades: 3\n",
+      "Losing Trades: 1\n",
+      "Total Return: 0.009181698624275226\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 15 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import sys \n",
+    "root_path = os.path.abspath(os.path.join(os.getcwd(), './uni2ts/src'))\n",
+    "sys.path.append(root_path)\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from einops import rearrange\n",
+    "from gluonts.dataset.pandas import PandasDataset\n",
+    "from gluonts.dataset.split import split\n",
+    "from gluonts.torch.model.predictor import PyTorchPredictor\n",
+    "import yfinance as yf\n",
+    "\n",
+    "from uni2ts.eval_util.plot import plot_single\n",
+    "from uni2ts.model.moirai import MoiraiForecast, MoiraiModule\n",
+    "import backtrader as bt\n",
+    "\n",
+    "# Step 1: Fetch Data from Yahoo Finance\n",
+    "def fetch_data(symbol, start_date, end_date):\n",
+    "    try:\n",
+    "        ticker = yf.Ticker(symbol)\n",
+    "        ohlcv = ticker.history(start=start_date, end=end_date)\n",
+    "        ohlcv.reset_index(inplace=True)\n",
+    "        ohlcv['timestamp'] = pd.to_datetime(ohlcv['Date'])\n",
+    "        ohlcv.set_index('timestamp', inplace=True)\n",
+    "        ohlcv = ohlcv[['Open', 'High', 'Low', 'Close', 'Volume']]\n",
+    "        ohlcv.rename(columns={'Open': 'open', 'High': 'high', 'Low': 'low', 'Close': 'close', 'Volume': 'volume'}, inplace=True)\n",
+    "        \n",
+    "        # Ensure the data is uniformly spaced by resampling\n",
+    "        ohlcv = ohlcv.resample('D').ffill()\n",
+    "        \n",
+    "        return ohlcv\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error fetching data for {symbol}: {str(e)}\")\n",
+    "        return None\n",
+    "\n",
+    "def load_and_predict(data):\n",
+    "    # Use only the 'close' price for forecasting\n",
+    "    df = data[['close']].rename(columns={'close': 'target'})\n",
+    "\n",
+    "    # Ensure data is sorted\n",
+    "    df = df.sort_index()\n",
+    "\n",
+    "    # Step 2: Prepare the Data for the Model\n",
+    "    # Convert into GluonTS dataset\n",
+    "    ds = PandasDataset(dict(df), freq=\"D\")\n",
+    "\n",
+    "    # Split into train/test set\n",
+    "    TEST = 100  # Define the length of the test set\n",
+    "    PDT = 20  # Define the prediction length\n",
+    "    train, test_template = split(ds, offset=-TEST)\n",
+    "\n",
+    "    # Ensure the length of the dataset is sufficient for rolling window evaluation\n",
+    "    total_length = len(df)\n",
+    "    if total_length < TEST + PDT:\n",
+    "        raise ValueError(f\"Not enough data points. Total length: {total_length}, TEST: {TEST}, PDT: {PDT}\")\n",
+    "\n",
+    "    # Construct rolling window evaluation\n",
+    "    test_data = test_template.generate_instances(\n",
+    "        prediction_length=PDT,\n",
+    "        windows=TEST // PDT,\n",
+    "        distance=PDT\n",
+    "    )\n",
+    "\n",
+    "    # Step 3: Load the Model and Make Predictions\n",
+    "    SIZE = \"small\"  # Model size\n",
+    "    CTX = 200  # Context length\n",
+    "    PSZ = \"auto\"  # Patch size\n",
+    "    BSZ = 32  # Batch size\n",
+    "\n",
+    "    # Prepare pre-trained model by downloading model weights from Hugging Face hub\n",
+    "    model = MoiraiForecast(\n",
+    "        module=MoiraiModule.from_pretrained(f\"Salesforce/moirai-1.0-R-{SIZE}\"),\n",
+    "        prediction_length=PDT,\n",
+    "        context_length=CTX,\n",
+    "        patch_size=PSZ,\n",
+    "        num_samples=100,\n",
+    "        target_dim=1,\n",
+    "        feat_dynamic_real_dim=ds.num_feat_dynamic_real,\n",
+    "        past_feat_dynamic_real_dim=ds.num_past_feat_dynamic_real,\n",
+    "    )\n",
+    "\n",
+    "    predictor = model.create_predictor(batch_size=BSZ)\n",
+    "    forecasts = predictor.predict(test_data.input)\n",
+    "\n",
+    "    # Step 4: Plot the Results\n",
+    "    input_it = iter(test_data.input)\n",
+    "    label_it = iter(test_data.label)\n",
+    "    forecast_it = iter(forecasts)\n",
+    "\n",
+    "    try:\n",
+    "        inp = next(input_it)\n",
+    "        label = next(label_it)\n",
+    "        forecast = next(forecast_it)\n",
+    "\n",
+    "        plot_single(\n",
+    "            inp, \n",
+    "            label, \n",
+    "            forecast, \n",
+    "            context_length=CTX,\n",
+    "            name=\"pred\",\n",
+    "            show_label=True,\n",
+    "        )\n",
+    "        plt.show()\n",
+    "    except StopIteration:\n",
+    "        print(\"Error: Not enough data points to generate forecasts.\")\n",
+    "    \n",
+    "    return forecasts\n",
+    "\n",
+    "# Define the strategies\n",
+    "class RsiBollingerBandsStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('rsi_period', 14),\n",
+    "        ('bb_period', 20),\n",
+    "        ('bb_dev', 2),\n",
+    "        ('oversold', 30),\n",
+    "        ('overbought', 70),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.rsi = bt.indicators.RelativeStrengthIndex(period=self.params.rsi_period)\n",
+    "        self.bbands = bt.indicators.BollingerBands(period=self.params.bb_period, devfactor=self.params.bb_dev)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.rsi < self.params.oversold and self.data.close <= self.bbands.lines.bot:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.rsi > self.params.overbought or self.data.close >= self.bbands.lines.top:\n",
+    "                self.sell()\n",
+    "        \n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class MacdStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('macd1_period', 12),\n",
+    "        ('macd2_period', 26),\n",
+    "        ('signal_period', 9),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.macd = bt.indicators.MACDHisto(period_me1=self.params.macd1_period, period_me2=self.params.macd2_period, period_signal=self.params.signal_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.macd.lines.histo[0] > 0 and self.macd.lines.histo[-1] <= 0:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.macd.lines.histo[0] < 0 and self.macd.lines.histo[-1] >= 0:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "class StochasticOscillatorStrategy(bt.Strategy):\n",
+    "    params = (\n",
+    "        ('stoch_period', 14),\n",
+    "        ('stoch_low', 20),\n",
+    "        ('stoch_high', 80),\n",
+    "    )\n",
+    "\n",
+    "    def __init__(self, predictions):\n",
+    "        self.stoch = bt.indicators.Stochastic(period=self.params.stoch_period)\n",
+    "        self.predictions = predictions\n",
+    "        self.current_prediction = next(iter(self.predictions))\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.stoch.lines.percK[0] < self.params.stoch_low and self.stoch.lines.percK[-1] >= self.params.stoch_low:\n",
+    "                self.buy()\n",
+    "        else:\n",
+    "            if self.stoch.lines.percK[0] > self.params.stoch_high and self.stoch.lines.percK[-1] <= self.params.stoch_high:\n",
+    "                self.sell()\n",
+    "\n",
+    "        # Move to the next prediction if available\n",
+    "        try:\n",
+    "            self.current_prediction = next(iter(self.predictions))\n",
+    "        except StopIteration:\n",
+    "            pass\n",
+    "\n",
+    "def run_backtest(strategy_class, symbol, start_date, end_date):\n",
+    "    # Fetch data for backtesting\n",
+    "    data = fetch_data(symbol, start_date, end_date)\n",
+    "\n",
+    "    # Load and make predictions\n",
+    "    predictions = load_and_predict(data)\n",
+    "\n",
+    "    # Initialize cerebro\n",
+    "    cerebro = bt.Cerebro()\n",
+    "    \n",
+    "    # Add data feed\n",
+    "    cerebro.adddata(bt.feeds.PandasData(dataname=data))\n",
+    "    \n",
+    "    # Add strategy with predictions\n",
+    "    cerebro.addstrategy(strategy_class, predictions=predictions)\n",
+    "    \n",
+    "    # Set broker settings\n",
+    "    cerebro.broker.set_cash(100000)\n",
+    "    cerebro.broker.setcommission(commission=0.002)\n",
+    "\n",
+    "    # Add analyzers for performance metrics\n",
+    "    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')\n",
+    "    cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')\n",
+    "    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')\n",
+    "    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')\n",
+    "\n",
+    "    # Print starting conditions\n",
+    "    start_value = cerebro.broker.getvalue()\n",
+    "    print(f'Starting Portfolio Value: {start_value:.2f}')\n",
+    "\n",
+    "    # Run backtest\n",
+    "    results = cerebro.run()\n",
+    "\n",
+    "    # Print ending conditions\n",
+    "    end_value = cerebro.broker.getvalue()\n",
+    "    print(f'Ending Portfolio Value: {end_value:.2f}')\n",
+    "\n",
+    "    # Extracting backtest metrics\n",
+    "    strat = results[0]\n",
+    "\n",
+    "    # Prepare results\n",
+    "    result_dict = {\n",
+    "        \"Starting Portfolio Value\": start_value,\n",
+    "        \"Ending Portfolio Value\": end_value,\n",
+    "        \"Sharpe Ratio\": strat.analyzers.sharpe.get_analysis().get('sharperatio', 'N/A'),\n",
+    "        \"Max Drawdown\": strat.analyzers.drawdown.get_analysis().get('max', {}).get('drawdown', 'N/A'),\n",
+    "        \"Total Trades\": strat.analyzers.trades.get_analysis().get('total', {}).get('total', 'N/A'),\n",
+    "        \"Winning Trades\": strat.analyzers.trades.get_analysis().get('won', {}).get('total', 'N/A'),\n",
+    "        \"Losing Trades\": strat.analyzers.trades.get_analysis().get('lost', {}).get('total', 'N/A'),\n",
+    "        \"Total Return\": strat.analyzers.returns.get_analysis().get('rtot', 'N/A')\n",
+    "    }\n",
+    "\n",
+    "    # Plot the results\n",
+    "    cerebro.plot(style='candlestick')\n",
+    "\n",
+    "    # Print metrics\n",
+    "    print(\"Metrics:\")\n",
+    "    for key, value in result_dict.items():\n",
+    "        print(f\"{key}: {value}\")\n",
+    "\n",
+    "    return result_dict\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    symbol = 'ETH-USD'\n",
+    "    start_date = '2023-06-20'\n",
+    "    end_date = '2024-06-20'\n",
+    "    \n",
+    "    strategies = [RsiBollingerBandsStrategy, MacdStrategy, StochasticOscillatorStrategy]\n",
+    "    \n",
+    "    for strategy in strategies:\n",
+    "        print(f\"Running backtest for {strategy.__name__}\")\n",
+    "        run_backtest(strategy, symbol, start_date, end_date)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".crypto",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/uni2ts b/notebooks/uni2ts
new file mode 160000
index 0000000..fac7a93
--- /dev/null
+++ b/notebooks/uni2ts
@@ -0,0 +1 @@
+Subproject commit fac7a937cba55a318fba6897e27a748d2403d07d