docs/tutorials/trading_index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `trading_index`\n",
    "\n",
    "This tutorial shows all the ins and outs of the calendars' `trading_index` method. (For other calendar methods see the [calendar_methods.ipynb](./calendar_methods.ipynb) tutorial.)\n",
    "\n",
    "The [What does it do?](#What-does-it-do?) section explains basic usage. The following sections then explore the method's arguments and options:\n",
    "\n",
    "* [`intervals`](#intervals)\n",
    "* [`period`](#period)\n",
    "* [`closed`](#closed)\n",
    "* [`force_close`, `force_break_close` and `force`](#force_close,-force_break_close-and-force)\n",
    "* [`ignore_breaks`](#ignore_breaks)\n",
    "* [`align` and `align_pm`](#align-and-align_pm)\n",
    "* [`start` and `end` as times](#start-and-end-as-times)\n",
    "\n",
    "The final section covers [overlapping indices](#Overlapping-indices)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup\n",
    "import exchange_calendars as xcals\n",
    "import pandas as pd\n",
    "\n",
    "hkg = xcals.get_calendar(\"XHKG\") # Hong Kong Stock Exchange\n",
    "start = \"2021-12-23\"\n",
    "end = \"2021-12-28\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>break_start</th>\n",
       "      <th>break_end</th>\n",
       "      <th>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-12-23</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-24</th>\n",
       "      <td>2021-12-24 01:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-24 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-28</th>\n",
       "      <td>2021-12-28 01:30:00+00:00</td>\n",
       "      <td>2021-12-28 04:00:00+00:00</td>\n",
       "      <td>2021-12-28 05:00:00+00:00</td>\n",
       "      <td>2021-12-28 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2021-12-23 2021-12-23 01:30:00+00:00 2021-12-23 04:00:00+00:00   \n",
       "2021-12-24 2021-12-24 01:30:00+00:00                       NaT   \n",
       "2021-12-28 2021-12-28 01:30:00+00:00 2021-12-28 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2021-12-23 2021-12-23 05:00:00+00:00 2021-12-23 08:00:00+00:00  \n",
       "2021-12-24                       NaT 2021-12-24 04:00:00+00:00  \n",
       "2021-12-28 2021-12-28 05:00:00+00:00 2021-12-28 08:00:00+00:00  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "schedule = hkg.schedule.loc[start:end]\n",
    "schedule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What does it do?\n",
    "\n",
    "`trading_index` creates a trading index at a given period over a range of sessions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:00:00+00:00',\n",
       "               '2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00', '2021-12-24 01:30:00+00:00',\n",
       "               '2021-12-24 02:00:00+00:00', '2021-12-24 02:30:00+00:00',\n",
       "               '2021-12-24 03:00:00+00:00', '2021-12-24 03:30:00+00:00',\n",
       "               '2021-12-28 01:30:00+00:00', '2021-12-28 02:00:00+00:00',\n",
       "               '2021-12-28 02:30:00+00:00', '2021-12-28 03:00:00+00:00',\n",
       "               '2021-12-28 03:30:00+00:00', '2021-12-28 05:00:00+00:00',\n",
       "               '2021-12-28 05:30:00+00:00', '2021-12-28 06:00:00+00:00',\n",
       "               '2021-12-28 06:30:00+00:00', '2021-12-28 07:00:00+00:00',\n",
       "               '2021-12-28 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, end, \"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or over a single session, if `start` and `end` are passed as the same session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:00:00+00:00',\n",
       "               '2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start=start, end=start, period=\"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or between times, if `start` and `end` are passed as times (as opposed to dates)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00', '2021-12-24 01:30:00+00:00',\n",
       "               '2021-12-24 02:00:00+00:00', '2021-12-24 02:30:00+00:00',\n",
       "               '2021-12-24 03:00:00+00:00', '2021-12-24 03:30:00+00:00',\n",
       "               '2021-12-28 01:30:00+00:00', '2021-12-28 02:00:00+00:00',\n",
       "               '2021-12-28 02:30:00+00:00', '2021-12-28 03:00:00+00:00',\n",
       "               '2021-12-28 03:30:00+00:00', '2021-12-28 05:00:00+00:00',\n",
       "               '2021-12-28 05:30:00+00:00', '2021-12-28 06:00:00+00:00',\n",
       "               '2021-12-28 06:30:00+00:00', '2021-12-28 07:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start_min = \"2021-12-23 02:30\"\n",
    "end_min = \"2021-12-28 07:00\"\n",
    "hkg.trading_index(start=start_min, end=end_min, period=\"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `start` can be passed as a time and `end` as a date, or vice-versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start=start_min, end=start, period=\"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the '[`start` and `end` as times](#start-and-end-as-times)' section for further notes on how the first and last indices are defined when `start` and/or `end` are passed as times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `intervals`\n",
    "\n",
    "By passing `intervals` as `False` the index can be output as a `DatetimeIndex`, as shown above. Although by default the index is output as an `IntervalIndex`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntervalIndex([[2021-12-23 01:30:00, 2021-12-23 02:00:00), [2021-12-23 02:00:00, 2021-12-23 02:30:00), [2021-12-23 02:30:00, 2021-12-23 03:00:00), [2021-12-23 03:00:00, 2021-12-23 03:30:00), [2021-12-23 03:30:00, 2021-12-23 04:00:00) ... [2021-12-23 05:30:00, 2021-12-23 06:00:00), [2021-12-23 06:00:00, 2021-12-23 06:30:00), [2021-12-23 06:30:00, 2021-12-23 07:00:00), [2021-12-23 07:00:00, 2021-12-23 07:30:00), [2021-12-23 07:30:00, 2021-12-23 08:00:00)], dtype='interval[datetime64[ns, UTC], left]')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"30min\")\n",
    "index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make that a bit more readable by setting it to the index of a `DataFrame`, and have columns showing the index's left and right sides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:00:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:00:00, 2021-12-23 02:30:00)</th>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:30:00, 2021-12-23 03:00:00)</th>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:00:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:00:00, 2021-12-23 07:30:00)</th>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:00:00+00:00   \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 02:30:00+00:00   \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:00:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 06:30:00+00:00   \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:00:00+00:00   \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 07:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 02:00:00+00:00  \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:30:00+00:00  \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 03:00:00+00:00  \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:30:00+00:00  \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def show_as_df(index: pd.IntervalIndex) -> pd.DataFrame:\n",
    "    index.name = \"IntervalIndex\"\n",
    "    return pd.DataFrame(\n",
    "        dict(left_side=index.left, right_side=index.right),\n",
    "        index=index\n",
    "    )\n",
    "\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `period`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The trading index represents sessions and subsessions as a number of discrete periods of a given length.\n",
    "\n",
    "When output as an `IntervalIndex` each indice represents a discrete period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Interval('2021-12-23 01:30:00', '2021-12-23 02:00:00', closed='left')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The length of each period for the example above is 30 minutes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:30:00', '0 days 00:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00', '0 days 00:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00', '0 days 00:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00', '0 days 00:30:00'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index.length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The period length is defined by the `period` argument which can be passed as the third positional argument or as a keyword argument. `period` can take either a `pd.Timedelta` or a string representing a pandas frequency. All the following are valid inputs representing a period length of 1 hour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "periods = [\n",
    "    pd.Timedelta(hours=1),\n",
    "    pd.Timedelta(1, \"H\"),\n",
    "    pd.Timedelta(60, \"min\"),\n",
    "    pd.Timedelta(60, \"T\"),\n",
    "    \"1H\",\n",
    "    \"1h\",\n",
    "    \"60T\",\n",
    "    \"60min\",\n",
    "    \"3600s\"   \n",
    "]\n",
    "\n",
    "indexes = [ hkg.trading_index(start, start, period) for period in periods ]\n",
    "for i, index in enumerate(indexes):\n",
    "    pd.testing.assert_index_equal(index, indexes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:30:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:30:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:30:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:00:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:30:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:30:00) 2021-12-23 02:30:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:30:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:00:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 07:00:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 07:00:00, 2021-12-23 08:00:00) 2021-12-23 07:00:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:30:00) 2021-12-23 02:30:00+00:00  \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:30:00) 2021-12-23 04:30:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  \n",
       "[2021-12-23 07:00:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The maximum `period` is one day, in which case the trading index is returned as a `DatetimeIndex` of sessions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23', '2021-12-24', '2021-12-28'], dtype='datetime64[ns]', freq='C')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, end, \"1D\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the other extreme, the period can be go all the way down to miliseconds to create a high frequency trading index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntervalIndex([[2021-12-23 01:30:00, 2021-12-23 01:30:00.001000), [2021-12-23 01:30:00.001000, 2021-12-23 01:30:00.002000), [2021-12-23 01:30:00.002000, 2021-12-23 01:30:00.003000), [2021-12-23 01:30:00.003000, 2021-12-23 01:30:00.004000), [2021-12-23 01:30:00.004000, 2021-12-23 01:30:00.005000) ... [2021-12-23 07:59:59.995000, 2021-12-23 07:59:59.996000), [2021-12-23 07:59:59.996000, 2021-12-23 07:59:59.997000), [2021-12-23 07:59:59.997000, 2021-12-23 07:59:59.998000), [2021-12-23 07:59:59.998000, 2021-12-23 07:59:59.999000), [2021-12-23 07:59:59.999000, 2021-12-23 08:00:00)], dtype='interval[datetime64[ns, UTC], left]', length=19800000)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "high_freq = hkg.trading_index(start, start, \"1ms\")\n",
    "high_freq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a lot of indices..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19800000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(high_freq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the index is output as a `DatetimeIndex` the indices represent period bounds. Accordingly, the period length is given by the distance between consecutive indices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = hkg.trading_index(start, start, \"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 00:30:00', '0 days 00:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00', '0 days 01:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00', '0 days 00:30:00', '0 days 00:30:00',\n",
       "                '0 days 00:30:00'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[1:] - index[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Huh? Why's there an hour and a half in there? Let's have a look at that index..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:00:00+00:00',\n",
       "               '2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>break_start</th>\n",
       "      <th>break_end</th>\n",
       "      <th>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-12-23</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2021-12-23 2021-12-23 01:30:00+00:00 2021-12-23 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2021-12-23 2021-12-23 05:00:00+00:00 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recall\n",
    "schedule.iloc[[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hong Kong has a lunch break. The trading index covers the morning subsession starting with the open, and then the afternoon subsession starting with the break-end. The hour and a half represents the difference between the last indice of the morning subsession and the first indice of the afternoon subsession. (See [`ignore_breaks`](#ignore_breaks) for how to treat sessions as continuous.)\n",
    "\n",
    "Ok, fine, but why hasn't the index included indices for 04:00 or 08:00? That's because it's `closed` on the \"left\" (by default)..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `closed`\n",
    "\n",
    "The `closed` parameter has a different effect depending on whether the index is being output as an `IntervalIndex` (default) or `DatetimeIndex` (i.e. `intervals=False`).\n",
    "\n",
    "If the index is being output as an `IntervalIndex` then `closed` can take either \"left\" (default) or \"right\". This value is simply passed through to the `closed` parameter of the `IntervalIndex` (to define the side on which all the intervals should be closed). In this case `closed` has no other effect.\n",
    "\n",
    "If the index is being output as an `DatetimeIndex` then `closed` can take either \"left\", \"right\", \"both\" or \"neither\". In this case `closed` determines **the side of each implied period that an indice should be defined on**. The consequence of each value is best understood by considering whether or not the left side of the first implied period and/or the right side of last implied period are included as indices:\n",
    "* \"left\" (default) - include left side of first period, do not include right side of last period.\n",
    "* \"right\" - do not include left side of first period, include right side of last period.\n",
    "* \"both\" - include both left side of first period and right side of last period.\n",
    "* \"neither\" - do not include either left side of first period or right side of last period.\n",
    "\n",
    "So, going back to the prior example, passing `closed` as right will include the 04:00 and 08:00 indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 02:00:00+00:00', '2021-12-23 02:30:00+00:00',\n",
       "               '2021-12-23 03:00:00+00:00', '2021-12-23 03:30:00+00:00',\n",
       "               '2021-12-23 04:00:00+00:00', '2021-12-23 05:30:00+00:00',\n",
       "               '2021-12-23 06:00:00+00:00', '2021-12-23 06:30:00+00:00',\n",
       "               '2021-12-23 07:00:00+00:00', '2021-12-23 07:30:00+00:00',\n",
       "               '2021-12-23 08:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"30min\", closed=\"right\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although now that only the right sides of the implied periods are being defined - the open (01:30) and start of the afternoon subsession (05:00) are not included...\n",
    "\n",
    "`closed` can be passed as \"both\" to include both the left and the right side of each implied interval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:00:00+00:00',\n",
       "               '2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 04:00:00+00:00',\n",
       "               '2021-12-23 05:00:00+00:00', '2021-12-23 05:30:00+00:00',\n",
       "               '2021-12-23 06:00:00+00:00', '2021-12-23 06:30:00+00:00',\n",
       "               '2021-12-23 07:00:00+00:00', '2021-12-23 07:30:00+00:00',\n",
       "               '2021-12-23 08:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"30min\", closed=\"both\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if you have a use case where you don't require either the left side of a (sub)session's first period or the right side of its last one, then you're after \"neither\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 02:00:00+00:00', '2021-12-23 02:30:00+00:00',\n",
       "               '2021-12-23 03:00:00+00:00', '2021-12-23 03:30:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"30min\", closed=\"neither\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `force_close`, `force_break_close` and `force`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:50:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:50:00, 2021-12-23 04:10:00)</th>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "      <td>2021-12-23 04:10:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:20:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:20:00, 2021-12-23 07:40:00)</th>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:40:00, 2021-12-23 09:00:00)</th>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "      <td>2021-12-23 09:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:10:00) 2021-12-23 02:50:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 06:20:00+00:00   \n",
       "[2021-12-23 07:40:00, 2021-12-23 09:00:00) 2021-12-23 07:40:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 02:50:00+00:00  \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:10:00) 2021-12-23 04:10:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 06:20:00+00:00  \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 07:40:00+00:00  \n",
       "[2021-12-23 07:40:00, 2021-12-23 09:00:00) 2021-12-23 09:00:00+00:00  "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"80T\")\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specifically, consider the last indice of the morning subsession against the break-start time..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>break_start</th>\n",
       "      <th>break_end</th>\n",
       "      <th>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-12-23</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2021-12-23 2021-12-23 01:30:00+00:00 2021-12-23 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2021-12-23 2021-12-23 05:00:00+00:00 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "schedule.iloc[[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Interval('2021-12-23 02:50:00', '2021-12-23 04:10:00', closed='left')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be seen that whilst this indice represents, like all the others, a period of 80 minutes, only the first 70 minutes of these actually represent a trading period, with the last 10 minutes, from 04:00 to 04:10, falling within the subsequent break.\n",
    "\n",
    "Similarly, it can be see that the last indice includes a full hour (08:00 - 09:00) that falls after the close.\n",
    "\n",
    "**The final indice of a (sub)session will always include a non-trading period whenever the period length is not a factor of the (sub)session duration.**\n",
    "\n",
    "The `force_close` and `force_break_close` options are provided to force the right side of the final period to, respectively, the session / morning subsession close."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:50:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:50:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:20:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:20:00, 2021-12-23 07:40:00)</th>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:40:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 02:50:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 06:20:00+00:00   \n",
       "[2021-12-23 07:40:00, 2021-12-23 08:00:00) 2021-12-23 07:40:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 02:50:00+00:00  \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 06:20:00+00:00  \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 07:40:00+00:00  \n",
       "[2021-12-23 07:40:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(\n",
    "    start, start, \"80T\", force_close=True, force_break_close=True\n",
    ")\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these options can be used independently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:50:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:50:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:20:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:20:00, 2021-12-23 07:40:00)</th>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:40:00, 2021-12-23 09:00:00)</th>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "      <td>2021-12-23 09:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 02:50:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 06:20:00+00:00   \n",
       "[2021-12-23 07:40:00, 2021-12-23 09:00:00) 2021-12-23 07:40:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 02:50:00+00:00  \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 06:20:00+00:00  \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 07:40:00+00:00  \n",
       "[2021-12-23 07:40:00, 2021-12-23 09:00:00) 2021-12-23 09:00:00+00:00  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"80T\", force_break_close=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are going to set both `force_close` and `force_break_close` to the same value then you're better off passing just the `force` convenience option. If passed, `force` sets both `force_close` and `force_break_close` (anything passed to either will be overriden)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:50:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:50:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 02:50:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:20:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:20:00, 2021-12-23 07:40:00)</th>\n",
       "      <td>2021-12-23 06:20:00+00:00</td>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:40:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:40:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 02:50:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 06:20:00+00:00   \n",
       "[2021-12-23 07:40:00, 2021-12-23 08:00:00) 2021-12-23 07:40:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:50:00) 2021-12-23 02:50:00+00:00  \n",
       "[2021-12-23 02:50:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:20:00) 2021-12-23 06:20:00+00:00  \n",
       "[2021-12-23 06:20:00, 2021-12-23 07:40:00) 2021-12-23 07:40:00+00:00  \n",
       "[2021-12-23 07:40:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"80T\", force=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An obvious consequence of forcing the close is that any indice that's forced will have a shorter period length than `period`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 01:20:00', '0 days 01:10:00', '0 days 01:20:00',\n",
       "                '0 days 01:20:00', '0 days 00:20:00'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index.length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**If having indices that represent only trading periods is more important to you than having them all relfect the same period length, then forcing the close is the way to go.**\n",
    "\n",
    "The force close options can also be employed when creating `DatetimeIndex`.\n",
    "\n",
    "When `closed` is either \"right\" or \"both\" the effect will be similar to that for the `IntervalIndex`, in that if the (sub)sessions' last indices otherwise fall later than the close they will be curtailed to the close."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 02:50:00+00:00', '2021-12-23 04:10:00+00:00',\n",
       "               '2021-12-23 06:20:00+00:00', '2021-12-23 07:40:00+00:00',\n",
       "               '2021-12-23 08:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB forcing only the session close, not the break\n",
    "hkg.trading_index(start, start, \"80T\", closed=\"right\", force_close=True, intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `closed` is either \"left\" or \"neither\" then `force` has no effect as there cannot be an indice to the right of the close to force."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:50:00+00:00',\n",
       "               '2021-12-23 05:00:00+00:00', '2021-12-23 06:20:00+00:00',\n",
       "               '2021-12-23 07:40:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"80T\", closed=\"left\", force=True, intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recalling the question of why 04:00 and 08:00 aren't included when doing this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:00:00+00:00',\n",
       "               '2021-12-23 02:30:00+00:00', '2021-12-23 03:00:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 05:30:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 06:30:00+00:00', '2021-12-23 07:00:00+00:00',\n",
       "               '2021-12-23 07:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"30min\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing `closed` as \"both\" and `force` as `True` will always include the closes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 01:30:00+00:00', '2021-12-23 02:30:00+00:00',\n",
       "               '2021-12-23 03:30:00+00:00', '2021-12-23 04:00:00+00:00',\n",
       "               '2021-12-23 05:00:00+00:00', '2021-12-23 06:00:00+00:00',\n",
       "               '2021-12-23 07:00:00+00:00', '2021-12-23 08:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"1H\", closed=\"both\", force=True, intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### `ignore_breaks`\n",
    "\n",
    "`ignore_breaks` provides for ignoring any session breaks and instead treating every session as if it were continuous. The following shows how by default `ignore_breaks` is `False` such that non-trading indices are not introduced within breaks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>break_start</th>\n",
       "      <th>break_end</th>\n",
       "      <th>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-12-23</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2021-12-23 2021-12-23 01:30:00+00:00 2021-12-23 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2021-12-23 2021-12-23 05:00:00+00:00 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "schedule.iloc[[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:00:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:00:00, 2021-12-23 02:30:00)</th>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:30:00, 2021-12-23 03:00:00)</th>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:00:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:00:00, 2021-12-23 07:30:00)</th>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:00:00+00:00   \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 02:30:00+00:00   \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:00:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 06:30:00+00:00   \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:00:00+00:00   \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 07:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 02:00:00+00:00  \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:30:00+00:00  \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 03:00:00+00:00  \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:30:00+00:00  \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"30T\")\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that above there are no indices between the 04:00 close of the morning session and the 05:00 open of the afternoon session.\n",
    "\n",
    "Passing `ignore_breaks` as True will include indices through any break."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:00:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:00:00, 2021-12-23 02:30:00)</th>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:30:00, 2021-12-23 03:00:00)</th>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:00:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 04:00:00, 2021-12-23 04:30:00)</th>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "      <td>2021-12-23 04:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 04:30:00, 2021-12-23 05:00:00)</th>\n",
       "      <td>2021-12-23 04:30:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:00:00, 2021-12-23 07:30:00)</th>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:00:00+00:00   \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 02:30:00+00:00   \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:00:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 04:00:00, 2021-12-23 04:30:00) 2021-12-23 04:00:00+00:00   \n",
       "[2021-12-23 04:30:00, 2021-12-23 05:00:00) 2021-12-23 04:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 06:30:00+00:00   \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:00:00+00:00   \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 07:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:00:00) 2021-12-23 02:00:00+00:00  \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:30:00) 2021-12-23 02:30:00+00:00  \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:00:00) 2021-12-23 03:00:00+00:00  \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 04:00:00, 2021-12-23 04:30:00) 2021-12-23 04:30:00+00:00  \n",
       "[2021-12-23 04:30:00, 2021-12-23 05:00:00) 2021-12-23 05:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  \n",
       "[2021-12-23 07:00:00, 2021-12-23 07:30:00) 2021-12-23 07:30:00+00:00  \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"30T\", ignore_breaks=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example the start of the afternoon session (05.00) is preserved as an indice only because it falls 'on frequency'. This won't be the case for all periods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 02:30:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:30:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 02:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:30:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 04:30:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 04:30:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:30:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 08:30:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 08:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:30:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:30:00) 2021-12-23 02:30:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:30:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 04:30:00, 2021-12-23 05:30:00) 2021-12-23 04:30:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:30:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:30:00) 2021-12-23 06:30:00+00:00   \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:30:00) 2021-12-23 07:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 02:30:00) 2021-12-23 02:30:00+00:00  \n",
       "[2021-12-23 02:30:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:30:00) 2021-12-23 04:30:00+00:00  \n",
       "[2021-12-23 04:30:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:30:00) 2021-12-23 07:30:00+00:00  \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:30:00) 2021-12-23 08:30:00+00:00  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"1H\", ignore_breaks=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `align` and `align_pm`\n",
    "\n",
    "The alignment options provide for anchoring the start of each session or subsession to a specific fraction of an hour. This can be useful to align trading data that is not anchored on a (sub)session's open.\n",
    "\n",
    "Consider the Tel Aviv Stock Exchange which opens at 07:59 UTC (when not observing DST). Without any alignment an index with a 5 minute period looks like this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:59:00, 2021-12-23 08:04:00)</th>\n",
       "      <td>2021-12-23 07:59:00+00:00</td>\n",
       "      <td>2021-12-23 08:04:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:04:00, 2021-12-23 08:09:00)</th>\n",
       "      <td>2021-12-23 08:04:00+00:00</td>\n",
       "      <td>2021-12-23 08:09:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:09:00, 2021-12-23 08:14:00)</th>\n",
       "      <td>2021-12-23 08:09:00+00:00</td>\n",
       "      <td>2021-12-23 08:14:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 07:59:00, 2021-12-23 08:04:00) 2021-12-23 07:59:00+00:00   \n",
       "[2021-12-23 08:04:00, 2021-12-23 08:09:00) 2021-12-23 08:04:00+00:00   \n",
       "[2021-12-23 08:09:00, 2021-12-23 08:14:00) 2021-12-23 08:09:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 07:59:00, 2021-12-23 08:04:00) 2021-12-23 08:04:00+00:00  \n",
       "[2021-12-23 08:04:00, 2021-12-23 08:09:00) 2021-12-23 08:09:00+00:00  \n",
       "[2021-12-23 08:09:00, 2021-12-23 08:14:00) 2021-12-23 08:14:00+00:00  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xtae = xcals.get_calendar(\"XTAE\") # Tel Aviv Stock Exchange\n",
    "index = xtae.trading_index(start, start, \"5T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if the data source anchors its 5 minute data not on this unusal open, but rather at 07:55 or 08:00? Well, that's what `align` is for..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:55:00, 2021-12-23 08:00:00)</th>\n",
       "      <td>2021-12-23 07:55:00+00:00</td>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:00:00, 2021-12-23 08:05:00)</th>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:05:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:05:00, 2021-12-23 08:10:00)</th>\n",
       "      <td>2021-12-23 08:05:00+00:00</td>\n",
       "      <td>2021-12-23 08:10:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 07:55:00, 2021-12-23 08:00:00) 2021-12-23 07:55:00+00:00   \n",
       "[2021-12-23 08:00:00, 2021-12-23 08:05:00) 2021-12-23 08:00:00+00:00   \n",
       "[2021-12-23 08:05:00, 2021-12-23 08:10:00) 2021-12-23 08:05:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 07:55:00, 2021-12-23 08:00:00) 2021-12-23 08:00:00+00:00  \n",
       "[2021-12-23 08:00:00, 2021-12-23 08:05:00) 2021-12-23 08:05:00+00:00  \n",
       "[2021-12-23 08:05:00, 2021-12-23 08:10:00) 2021-12-23 08:10:00+00:00  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = xtae.trading_index(start, start, \"5T\", align=\"-5T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:00:00, 2021-12-23 08:05:00)</th>\n",
       "      <td>2021-12-23 08:00:00+00:00</td>\n",
       "      <td>2021-12-23 08:05:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:05:00, 2021-12-23 08:10:00)</th>\n",
       "      <td>2021-12-23 08:05:00+00:00</td>\n",
       "      <td>2021-12-23 08:10:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:10:00, 2021-12-23 08:15:00)</th>\n",
       "      <td>2021-12-23 08:10:00+00:00</td>\n",
       "      <td>2021-12-23 08:15:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 08:00:00, 2021-12-23 08:05:00) 2021-12-23 08:00:00+00:00   \n",
       "[2021-12-23 08:05:00, 2021-12-23 08:10:00) 2021-12-23 08:05:00+00:00   \n",
       "[2021-12-23 08:10:00, 2021-12-23 08:15:00) 2021-12-23 08:10:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 08:00:00, 2021-12-23 08:05:00) 2021-12-23 08:05:00+00:00  \n",
       "[2021-12-23 08:05:00, 2021-12-23 08:10:00) 2021-12-23 08:10:00+00:00  \n",
       "[2021-12-23 08:10:00, 2021-12-23 08:15:00) 2021-12-23 08:15:00+00:00  "
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = xtae.trading_index(start, start, \"5T\", align=\"5T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`align` can be passed any value that represents a fraction of a hour. Like `period` it can take a `Timedelta` or a `str` that's acceptable as a single input to `Timedelta`.\n",
    "\n",
    "Postiive values will anchor a session's indices on the first occurence of `align` that follows the open, whilst negative values will anchor the indices on the first occurence that preceeds the open."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 08:30:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 08:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 08:30:00, 2021-12-23 09:30:00)</th>\n",
       "      <td>2021-12-23 08:30:00+00:00</td>\n",
       "      <td>2021-12-23 09:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 09:30:00, 2021-12-23 10:30:00)</th>\n",
       "      <td>2021-12-23 09:30:00+00:00</td>\n",
       "      <td>2021-12-23 10:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:30:00) 2021-12-23 07:30:00+00:00   \n",
       "[2021-12-23 08:30:00, 2021-12-23 09:30:00) 2021-12-23 08:30:00+00:00   \n",
       "[2021-12-23 09:30:00, 2021-12-23 10:30:00) 2021-12-23 09:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 07:30:00, 2021-12-23 08:30:00) 2021-12-23 08:30:00+00:00  \n",
       "[2021-12-23 08:30:00, 2021-12-23 09:30:00) 2021-12-23 09:30:00+00:00  \n",
       "[2021-12-23 09:30:00, 2021-12-23 10:30:00) 2021-12-23 10:30:00+00:00  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = xtae.trading_index(start, start, \"1H\", align=\"-30T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A session's indices will not be shifted if the open already aligns with `align`. For example, the following Hong Kong session opens at 01:30 which already aligns with \"5T\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 01:35:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 01:35:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:35:00, 2021-12-23 01:40:00)</th>\n",
       "      <td>2021-12-23 01:35:00+00:00</td>\n",
       "      <td>2021-12-23 01:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:40:00, 2021-12-23 01:45:00)</th>\n",
       "      <td>2021-12-23 01:40:00+00:00</td>\n",
       "      <td>2021-12-23 01:45:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 01:35:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 01:35:00, 2021-12-23 01:40:00) 2021-12-23 01:35:00+00:00   \n",
       "[2021-12-23 01:40:00, 2021-12-23 01:45:00) 2021-12-23 01:40:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 01:35:00) 2021-12-23 01:35:00+00:00  \n",
       "[2021-12-23 01:35:00, 2021-12-23 01:40:00) 2021-12-23 01:40:00+00:00  \n",
       "[2021-12-23 01:40:00, 2021-12-23 01:45:00) 2021-12-23 01:45:00+00:00  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"5T\", align=\"-5T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same is true for all other fractions of an hour, except \"20T\". If you really had to..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:20:00, 2021-12-23 01:40:00)</th>\n",
       "      <td>2021-12-23 01:20:00+00:00</td>\n",
       "      <td>2021-12-23 01:40:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:40:00, 2021-12-23 02:00:00)</th>\n",
       "      <td>2021-12-23 01:40:00+00:00</td>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 02:00:00, 2021-12-23 02:20:00)</th>\n",
       "      <td>2021-12-23 02:00:00+00:00</td>\n",
       "      <td>2021-12-23 02:20:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:20:00, 2021-12-23 01:40:00) 2021-12-23 01:20:00+00:00   \n",
       "[2021-12-23 01:40:00, 2021-12-23 02:00:00) 2021-12-23 01:40:00+00:00   \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:20:00) 2021-12-23 02:00:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:20:00, 2021-12-23 01:40:00) 2021-12-23 01:40:00+00:00  \n",
       "[2021-12-23 01:40:00, 2021-12-23 02:00:00) 2021-12-23 02:00:00+00:00  \n",
       "[2021-12-23 02:00:00, 2021-12-23 02:20:00) 2021-12-23 02:20:00+00:00  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"20T\", align=\"-20T\")\n",
    "show_as_df(index)[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where a calendar observes a break, by default the start of both the morning and afternoon subsessions will be anchored, independently, according to `align`. Alternatively `align_pm` can be passed to anchor the start of the afternoon subsessions:\n",
    "* to a different alignment, by passing as a `str` or `Timedelta`.\n",
    "* to the break-end (i.e. the afternoon subsession open), by passing as `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `start` and `end` as times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When `start` and `end` are passed as times, how the first and last indices are defined depends on whether the index is returned as an `IntervalIndex` or a `DatetimeIndex`.\n",
    "\n",
    "When returning an `IntervalIndex` (`intervals=True`):\n",
    "* The first indice will be:\n",
    "    * if `start` coincides with the left side of an indice, then that indice.\n",
    "    * otherwise the nearest indice to `start` with a left side that is later than `start`.\n",
    "\n",
    "* The last indice will be:\n",
    "    * if `end` coincides with the right side of an indice, then that indice.\n",
    "    * otherwise the nearest indice to `end` with a right side that is earlier than `end`.\n",
    "\n",
    "In the following example the `start` and `end` times coincide with, respectively, the left and right side of indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_min = pd.Timestamp(\"2021-12-23 03:00\")\n",
    "end_min = pd.Timestamp(\"2021-12-23 07:00\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:00:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:00:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 06:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  "
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start_min, end_min, \"30T\", intervals=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the effect of moving `start` forwards and `end` backwards by one minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  "
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_min = pd.Timedelta(1, \"T\")\n",
    "index = hkg.trading_index(start_min + one_min, end_min - one_min, \"30T\", intervals=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In short, when returning an `IntervalIndex`:\n",
    "* the first indice will never include a period that falls before `start`.\n",
    "* the last indice will never include a period that falls after `end`.\n",
    "\n",
    "The same is not true for when a `DatetimeIndex` is returned. In this case the first and last indices are defined without consideration to the periods that the indices may represent.\n",
    "\n",
    "When returning an `DatetimeIndex`:\n",
    "* The first indice will be either `start`, if start is an indice, or otherwise the nearest indice that follows `start`. \n",
    "* The last indice will be either `end`, if end is an indice, or otherwise the nearest indice that preceeds `end`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start_min=Timestamp('2021-12-23 03:00:00')\tend_min=Timestamp('2021-12-23 07:00:00')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 03:00:00+00:00', '2021-12-23 03:30:00+00:00',\n",
       "               '2021-12-23 05:00:00+00:00', '2021-12-23 05:30:00+00:00',\n",
       "               '2021-12-23 06:00:00+00:00', '2021-12-23 06:30:00+00:00',\n",
       "               '2021-12-23 07:00:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(f\"{start_min=}\\t{end_min=}\")  # for reference\n",
    "hkg.trading_index(start_min, end_min, \"30T\", closed=\"left\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the different interpretation of what `end` represents. Here the `end` indice is included even though it represents a period (07:00 - 07:30) that falls after `end_min`. If intervals=True then the analogous indice is excluded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:00:00, 2021-12-23 03:30:00)</th>\n",
       "      <td>2021-12-23 03:00:00+00:00</td>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 05:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:30:00, 2021-12-23 06:00:00)</th>\n",
       "      <td>2021-12-23 05:30:00+00:00</td>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:00:00, 2021-12-23 06:30:00)</th>\n",
       "      <td>2021-12-23 06:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:30:00, 2021-12-23 07:00:00)</th>\n",
       "      <td>2021-12-23 06:30:00+00:00</td>\n",
       "      <td>2021-12-23 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:00:00+00:00   \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 03:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 05:30:00+00:00   \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:00:00+00:00   \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 06:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 03:00:00, 2021-12-23 03:30:00) 2021-12-23 03:30:00+00:00  \n",
       "[2021-12-23 03:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 05:30:00) 2021-12-23 05:30:00+00:00  \n",
       "[2021-12-23 05:30:00, 2021-12-23 06:00:00) 2021-12-23 06:00:00+00:00  \n",
       "[2021-12-23 06:00:00, 2021-12-23 06:30:00) 2021-12-23 06:30:00+00:00  \n",
       "[2021-12-23 06:30:00, 2021-12-23 07:00:00) 2021-12-23 07:00:00+00:00  "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start_min, end_min, \"30T\", closed=\"left\", intervals=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final point on passing `start` and/or `end` as times:\n",
    "\n",
    "* **If the period is one day then `start` and/or `end` cannot be passed as times.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Overlapping indices`\n",
    "\n",
    "Now, if you've been playing with `trading_index` as you've worked through this tutorial and you've managed to get this far without raising an error, then you just haven't been trying hard enough..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntervalIndex([[2021-12-23 01:30:00, 2021-12-23 03:15:00), [2021-12-23 03:15:00, 2021-12-23 05:00:00), [2021-12-23 05:00:00, 2021-12-23 06:45:00), [2021-12-23 06:45:00, 2021-12-23 08:30:00)], dtype='interval[datetime64[ns, UTC], left]')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "period_105 = hkg.trading_index(start, start, \"105T\")\n",
    "period_105"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just one more minute..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "period_106 = hkg.trading_index(start, start, \"106T\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "IntervalsOverlapError                     Traceback (most recent call last)\n",
    "Input In [50], in <cell line: 1>()\n",
    "----> 1 period_106 = hkg.trading_index(start, start, \"106T\")\n",
    "\n",
    "IntervalsOverlapError: Unable to create trading index as intervals would overlap. This can occur when the frequency is longer than a break or the gap between one session's close and the next session's open (as reduced by any alignment). To shorten intervals that would otherwise overlap either pass `curtail_overlaps` as True or pass `force_close` and/or `force_break_close` as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened? The error message pretty much explains it. Lets have a better look at the index with the 105 minutes period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 03:15:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:15:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:15:00, 2021-12-23 05:00:00)</th>\n",
       "      <td>2021-12-23 03:15:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:45:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:45:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:45:00, 2021-12-23 08:30:00)</th>\n",
       "      <td>2021-12-23 06:45:00+00:00</td>\n",
       "      <td>2021-12-23 08:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:15:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 03:15:00, 2021-12-23 05:00:00) 2021-12-23 03:15:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:45:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:45:00, 2021-12-23 08:30:00) 2021-12-23 06:45:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:15:00) 2021-12-23 03:15:00+00:00  \n",
       "[2021-12-23 03:15:00, 2021-12-23 05:00:00) 2021-12-23 05:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:45:00) 2021-12-23 06:45:00+00:00  \n",
       "[2021-12-23 06:45:00, 2021-12-23 08:30:00) 2021-12-23 08:30:00+00:00  "
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(period_105)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how the right side of the second indice (the last indice of the morning subsession) has bumped right up against the left side of the third indice (the first indice of the afternoon subsession). The indices don't overlap because all the intervals are all `closed` on the \"left\" (by default), so the exact timestamp '2021-12-23 05:00:00' is present in the third indice..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('2021-12-23 05:00:00', tz=\"UTC\") in period_105[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...but not the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Timestamp('2021-12-23 05:00:00', tz=\"UTC\") in period_105[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, add just one more minute to the period length and these indices overlap, hence the `IntervalsOverlapError`. As noted in the error message, the overlap can be prevented by forcing close on the break."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 03:16:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:16:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:16:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 03:16:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:46:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:46:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:46:00, 2021-12-23 08:32:00)</th>\n",
       "      <td>2021-12-23 06:46:00+00:00</td>\n",
       "      <td>2021-12-23 08:32:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:16:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 03:16:00, 2021-12-23 04:00:00) 2021-12-23 03:16:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:46:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:46:00, 2021-12-23 08:32:00) 2021-12-23 06:46:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:16:00) 2021-12-23 03:16:00+00:00  \n",
       "[2021-12-23 03:16:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:46:00) 2021-12-23 06:46:00+00:00  \n",
       "[2021-12-23 06:46:00, 2021-12-23 08:32:00) 2021-12-23 08:32:00+00:00  "
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(hkg.trading_index(start, start, \"106T\", force_break_close=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, `curtail_overlaps` can be passed as True to curtail overlapping indices. This has the effect of curtailing the right side of the earlier of the overlapping indices to the left side of the latter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 03:21:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 03:21:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 03:21:00, 2021-12-23 05:00:00)</th>\n",
       "      <td>2021-12-23 03:21:00+00:00</td>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 06:51:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 06:51:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 06:51:00, 2021-12-23 08:42:00)</th>\n",
       "      <td>2021-12-23 06:51:00+00:00</td>\n",
       "      <td>2021-12-23 08:42:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:21:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 03:21:00, 2021-12-23 05:00:00) 2021-12-23 03:21:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:51:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 06:51:00, 2021-12-23 08:42:00) 2021-12-23 06:51:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 03:21:00) 2021-12-23 03:21:00+00:00  \n",
       "[2021-12-23 03:21:00, 2021-12-23 05:00:00) 2021-12-23 05:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 06:51:00) 2021-12-23 06:51:00+00:00  \n",
       "[2021-12-23 06:51:00, 2021-12-23 08:42:00) 2021-12-23 08:42:00+00:00  "
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = hkg.trading_index(start, start, \"111T\", curtail_overlaps=True)\n",
    "show_as_df(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously this has the same effect as forcing the close in so much as the lengths of some indices will now be less than the passed `period`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days 01:51:00', '0 days 01:39:00', '0 days 01:51:00',\n",
       "                '0 days 01:51:00'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index.length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NB** that `curtail_overlaps` is only available if outputing as an `IntervalIndex` (if `intervals=False` then `curtail_overlaps` has no effect).\n",
    "\n",
    "Another option, not noted by the error message, can be to _increase_ the period. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 01:30:00, 2021-12-23 04:00:00)</th>\n",
       "      <td>2021-12-23 01:30:00+00:00</td>\n",
       "      <td>2021-12-23 04:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 05:00:00, 2021-12-23 07:30:00)</th>\n",
       "      <td>2021-12-23 05:00:00+00:00</td>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 07:30:00, 2021-12-23 10:00:00)</th>\n",
       "      <td>2021-12-23 07:30:00+00:00</td>\n",
       "      <td>2021-12-23 10:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-23 01:30:00, 2021-12-23 04:00:00) 2021-12-23 01:30:00+00:00   \n",
       "[2021-12-23 05:00:00, 2021-12-23 07:30:00) 2021-12-23 05:00:00+00:00   \n",
       "[2021-12-23 07:30:00, 2021-12-23 10:00:00) 2021-12-23 07:30:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-23 01:30:00, 2021-12-23 04:00:00) 2021-12-23 04:00:00+00:00  \n",
       "[2021-12-23 05:00:00, 2021-12-23 07:30:00) 2021-12-23 07:30:00+00:00  \n",
       "[2021-12-23 07:30:00, 2021-12-23 10:00:00) 2021-12-23 10:00:00+00:00  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(hkg.trading_index(start, start, \"150T\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(I'll leave it to you to work out what happened there.)\n",
    "\n",
    "The possibility for overlaps are not limited to calendars with lunch breaks. Overlaps can also occur when the right side of the last indice of one session falls later than the left side of the first indice of the next session (as adjusted for any alignment). For a 24 hour calendar, like CMES, this will occur whenever the period is not a factor of 24 hours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>break_start</th>\n",
       "      <th>break_end</th>\n",
       "      <th>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-12-01</th>\n",
       "      <td>2021-11-30 23:00:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-01 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-02</th>\n",
       "      <td>2021-12-01 23:00:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-02 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-03</th>\n",
       "      <td>2021-12-02 23:00:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-03 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open break_start break_end  \\\n",
       "2021-12-01 2021-11-30 23:00:00+00:00         NaT       NaT   \n",
       "2021-12-02 2021-12-01 23:00:00+00:00         NaT       NaT   \n",
       "2021-12-03 2021-12-02 23:00:00+00:00         NaT       NaT   \n",
       "\n",
       "                               close  \n",
       "2021-12-01 2021-12-01 23:00:00+00:00  \n",
       "2021-12-02 2021-12-02 23:00:00+00:00  \n",
       "2021-12-03 2021-12-03 23:00:00+00:00  "
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# grab a 24-hour calendar\n",
    "cmes = xcals.get_calendar(\"CMES\")\n",
    "# for reference\n",
    "start24, end24 = \"2021-12-01\", \"2021-12-03\"\n",
    "cmes.schedule[start24:end24]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8 hours is a factor of 24 hours..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-11-30 23:00:00, 2021-12-01 07:00:00)</th>\n",
       "      <td>2021-11-30 23:00:00+00:00</td>\n",
       "      <td>2021-12-01 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-01 07:00:00, 2021-12-01 15:00:00)</th>\n",
       "      <td>2021-12-01 07:00:00+00:00</td>\n",
       "      <td>2021-12-01 15:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-01 15:00:00, 2021-12-01 23:00:00)</th>\n",
       "      <td>2021-12-01 15:00:00+00:00</td>\n",
       "      <td>2021-12-01 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-01 23:00:00, 2021-12-02 07:00:00)</th>\n",
       "      <td>2021-12-01 23:00:00+00:00</td>\n",
       "      <td>2021-12-02 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-02 07:00:00, 2021-12-02 15:00:00)</th>\n",
       "      <td>2021-12-02 07:00:00+00:00</td>\n",
       "      <td>2021-12-02 15:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-02 15:00:00, 2021-12-02 23:00:00)</th>\n",
       "      <td>2021-12-02 15:00:00+00:00</td>\n",
       "      <td>2021-12-02 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-02 23:00:00, 2021-12-03 07:00:00)</th>\n",
       "      <td>2021-12-02 23:00:00+00:00</td>\n",
       "      <td>2021-12-03 07:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-03 07:00:00, 2021-12-03 15:00:00)</th>\n",
       "      <td>2021-12-03 07:00:00+00:00</td>\n",
       "      <td>2021-12-03 15:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-03 15:00:00, 2021-12-03 23:00:00)</th>\n",
       "      <td>2021-12-03 15:00:00+00:00</td>\n",
       "      <td>2021-12-03 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-11-30 23:00:00, 2021-12-01 07:00:00) 2021-11-30 23:00:00+00:00   \n",
       "[2021-12-01 07:00:00, 2021-12-01 15:00:00) 2021-12-01 07:00:00+00:00   \n",
       "[2021-12-01 15:00:00, 2021-12-01 23:00:00) 2021-12-01 15:00:00+00:00   \n",
       "[2021-12-01 23:00:00, 2021-12-02 07:00:00) 2021-12-01 23:00:00+00:00   \n",
       "[2021-12-02 07:00:00, 2021-12-02 15:00:00) 2021-12-02 07:00:00+00:00   \n",
       "[2021-12-02 15:00:00, 2021-12-02 23:00:00) 2021-12-02 15:00:00+00:00   \n",
       "[2021-12-02 23:00:00, 2021-12-03 07:00:00) 2021-12-02 23:00:00+00:00   \n",
       "[2021-12-03 07:00:00, 2021-12-03 15:00:00) 2021-12-03 07:00:00+00:00   \n",
       "[2021-12-03 15:00:00, 2021-12-03 23:00:00) 2021-12-03 15:00:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-11-30 23:00:00, 2021-12-01 07:00:00) 2021-12-01 07:00:00+00:00  \n",
       "[2021-12-01 07:00:00, 2021-12-01 15:00:00) 2021-12-01 15:00:00+00:00  \n",
       "[2021-12-01 15:00:00, 2021-12-01 23:00:00) 2021-12-01 23:00:00+00:00  \n",
       "[2021-12-01 23:00:00, 2021-12-02 07:00:00) 2021-12-02 07:00:00+00:00  \n",
       "[2021-12-02 07:00:00, 2021-12-02 15:00:00) 2021-12-02 15:00:00+00:00  \n",
       "[2021-12-02 15:00:00, 2021-12-02 23:00:00) 2021-12-02 23:00:00+00:00  \n",
       "[2021-12-02 23:00:00, 2021-12-03 07:00:00) 2021-12-03 07:00:00+00:00  \n",
       "[2021-12-03 07:00:00, 2021-12-03 15:00:00) 2021-12-03 15:00:00+00:00  \n",
       "[2021-12-03 15:00:00, 2021-12-03 23:00:00) 2021-12-03 23:00:00+00:00  "
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(cmes.trading_index(start24, end24, \"8H\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but 7 minutes is not..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cmes.trading_index(start24, end24, \"7T\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "IntervalsOverlapError                     Traceback (most recent call last)\n",
    "Input In [60], in <cell line: 1>()\n",
    "----> 1 cmes.trading_index(start24, end24, \"7T\")\n",
    "\n",
    "IntervalsOverlapError: Unable to create trading index as intervals would overlap. This can occur when the frequency is longer than a break or the gap between one session's close and the next session's open (as reduced by any alignment). To shorten intervals that would otherwise overlap either pass `curtail_overlaps` as True or pass `force_close` and/or `force_break_close` as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_side</th>\n",
       "      <th>right_side</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IntervalIndex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-22 23:00:00, 2021-12-22 23:07:00)</th>\n",
       "      <td>2021-12-22 23:00:00+00:00</td>\n",
       "      <td>2021-12-22 23:07:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-22 23:07:00, 2021-12-22 23:14:00)</th>\n",
       "      <td>2021-12-22 23:07:00+00:00</td>\n",
       "      <td>2021-12-22 23:14:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-22 23:14:00, 2021-12-22 23:21:00)</th>\n",
       "      <td>2021-12-22 23:14:00+00:00</td>\n",
       "      <td>2021-12-22 23:21:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-22 23:21:00, 2021-12-22 23:28:00)</th>\n",
       "      <td>2021-12-22 23:21:00+00:00</td>\n",
       "      <td>2021-12-22 23:28:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-22 23:28:00, 2021-12-22 23:35:00)</th>\n",
       "      <td>2021-12-22 23:28:00+00:00</td>\n",
       "      <td>2021-12-22 23:35:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-28 22:27:00, 2021-12-28 22:34:00)</th>\n",
       "      <td>2021-12-28 22:27:00+00:00</td>\n",
       "      <td>2021-12-28 22:34:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-28 22:34:00, 2021-12-28 22:41:00)</th>\n",
       "      <td>2021-12-28 22:34:00+00:00</td>\n",
       "      <td>2021-12-28 22:41:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-28 22:41:00, 2021-12-28 22:48:00)</th>\n",
       "      <td>2021-12-28 22:41:00+00:00</td>\n",
       "      <td>2021-12-28 22:48:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-28 22:48:00, 2021-12-28 22:55:00)</th>\n",
       "      <td>2021-12-28 22:48:00+00:00</td>\n",
       "      <td>2021-12-28 22:55:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-28 22:55:00, 2021-12-28 23:00:00)</th>\n",
       "      <td>2021-12-28 22:55:00+00:00</td>\n",
       "      <td>2021-12-28 23:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>618 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "IntervalIndex                                                          \n",
       "[2021-12-22 23:00:00, 2021-12-22 23:07:00) 2021-12-22 23:00:00+00:00   \n",
       "[2021-12-22 23:07:00, 2021-12-22 23:14:00) 2021-12-22 23:07:00+00:00   \n",
       "[2021-12-22 23:14:00, 2021-12-22 23:21:00) 2021-12-22 23:14:00+00:00   \n",
       "[2021-12-22 23:21:00, 2021-12-22 23:28:00) 2021-12-22 23:21:00+00:00   \n",
       "[2021-12-22 23:28:00, 2021-12-22 23:35:00) 2021-12-22 23:28:00+00:00   \n",
       "...                                                              ...   \n",
       "[2021-12-28 22:27:00, 2021-12-28 22:34:00) 2021-12-28 22:27:00+00:00   \n",
       "[2021-12-28 22:34:00, 2021-12-28 22:41:00) 2021-12-28 22:34:00+00:00   \n",
       "[2021-12-28 22:41:00, 2021-12-28 22:48:00) 2021-12-28 22:41:00+00:00   \n",
       "[2021-12-28 22:48:00, 2021-12-28 22:55:00) 2021-12-28 22:48:00+00:00   \n",
       "[2021-12-28 22:55:00, 2021-12-28 23:00:00) 2021-12-28 22:55:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "IntervalIndex                                                         \n",
       "[2021-12-22 23:00:00, 2021-12-22 23:07:00) 2021-12-22 23:07:00+00:00  \n",
       "[2021-12-22 23:07:00, 2021-12-22 23:14:00) 2021-12-22 23:14:00+00:00  \n",
       "[2021-12-22 23:14:00, 2021-12-22 23:21:00) 2021-12-22 23:21:00+00:00  \n",
       "[2021-12-22 23:21:00, 2021-12-22 23:28:00) 2021-12-22 23:28:00+00:00  \n",
       "[2021-12-22 23:28:00, 2021-12-22 23:35:00) 2021-12-22 23:35:00+00:00  \n",
       "...                                                              ...  \n",
       "[2021-12-28 22:27:00, 2021-12-28 22:34:00) 2021-12-28 22:34:00+00:00  \n",
       "[2021-12-28 22:34:00, 2021-12-28 22:41:00) 2021-12-28 22:41:00+00:00  \n",
       "[2021-12-28 22:41:00, 2021-12-28 22:48:00) 2021-12-28 22:48:00+00:00  \n",
       "[2021-12-28 22:48:00, 2021-12-28 22:55:00) 2021-12-28 22:55:00+00:00  \n",
       "[2021-12-28 22:55:00, 2021-12-28 23:00:00) 2021-12-28 23:00:00+00:00  \n",
       "\n",
       "[618 rows x 2 columns]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_as_df(cmes.trading_index(start, end, \"7T\", force_close=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overlapping indices are also a consideration for trading indexes output as `DatetimeIndex`, although only if the index is being `closed` on either the \"right\" side or \"both\" sides (it's not possible for a `DatetimeIndex` `closed` on the \"left\" side or \"neither\" side to have overlapping indices as the right side is not defined, and hence cannot overlap the left side of the following indice).\n",
    "\n",
    "If the index is being `closed` on the \"right\" then the periods represented by the indices will overlap whenever they would overlap for the equivalent `IntervalIndex`. Only difference is that an `IndicesOverlapError` is raised rather than an `IntervalsOverlapError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hkg.trading_index(start, start, \"106T\", closed=\"right\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "IndicesOverlapError                       Traceback (most recent call last)\n",
    "Input In [62], in <cell line: 1>()\n",
    "----> 1 hkg.trading_index(start, start, \"106T\", closed=\"right\", intervals=False)\n",
    "\n",
    "IndicesOverlapError: Unable to create trading index as an indice would fall to the right of (later than) the subsequent indice. This can occur when the frequency is longer than a break or the gap between one session's close and the next session's open (as reduced by any alignment). Consider  passing `closed` as `left` or passing `force_close` and/or `force_break_close` as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the trading index is being closed on \"both\" sides then the overlap will occur one minute earlier, as whilst this is on the limit with `closed` \"right\"..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 03:15:00+00:00', '2021-12-23 05:00:00+00:00',\n",
       "               '2021-12-23 06:45:00+00:00', '2021-12-23 08:30:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.trading_index(start, start, \"105T\", closed=\"right\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's over the limit if `closed` \"both\". This is because here 05:00 would be a minute of both the last implied period of the morning subsession and the first implied period of the afternoon subsession."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hkg.trading_index(start, start, \"105T\", closed=\"both\", intervals=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "IndicesOverlapError                       Traceback (most recent call last)\n",
    "Input In [64], in <cell line: 1>()\n",
    "----> 1 hkg.trading_index(start, start, \"105T\", closed=\"both\", intervals=False)\n",
    "\n",
    "IndicesOverlapError: Unable to create trading index as an indice would fall to the right of (later than) the subsequent indice. This can occur when the frequency is longer than a break or the gap between one session's close and the next session's open (as reduced by any alignment). Consider  passing `closed` as `left` or passing `force_close` and/or `force_break_close` as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with an `IntervalIndex`, overlapping indices can be prevented by forcing the applicable close(s). Unlike `IntervalIndex`, `curtail_indices` is **not** available for `DatetimeIndex`.\n",
    "\n",
    "Although `curtail_overlaps` is unavailable, a similar effect can be achieved by passing `closed` as \"left\" instead of \"both\" or \"neither\" instead of \"right\" (the effect isn't exactly the same as `curtail_overlaps` allows for curtailing only overlapping indices, whilst changing closed to \"left\" or \"neither\" has the effect of losing the right side of the last implied period of _all_ sessions and subsessions, regardless of whether they would overlap or not)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python38 xcals",
   "language": "python",
   "name": "py38_xcals"
  },
  "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.8.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}