docs/tutorials/calendar_methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calendar methods\n",
    "\n",
    "This tutorial offers a walk through of all the `ExchangeCalendar` methods (for properties see the [calendar properties](./calendar_properties.ipynb) tutorial).\n",
    "\n",
    "The following sections cover methods according to the nature of the argument(s) they take:\n",
    "* [Methods that query a Date](#Methods-that-query-a-Date)  \n",
    "* [Methods that query a Session](#Methods-that-query-a-Session)  \n",
    "* [Methods that query a Minute](#Methods-that-query-a-Minute)  \n",
    "* [Methods that query multiple TradingMinute](#Methods-that-query-multiple-TradingMinute)  \n",
    "* [Methods that query a range of dates](#Methods-that-query-a-range-of-dates)\n",
    "* [Methods that query a time](#Methods-that-query-a-time)\n",
    "\n",
    "The following sections cover methods that evaluate an index of trading minutes or sessions:\n",
    "* [Methods that evaluate an index of contiguous trading minutes](#Methods-that-evaluate-an-index-of-contiguous-trading-minutes)\n",
    "* [Methods that evaluate an index of contiguous sessions](#Methods-that-evaluate-an-index-of-contiguous-sessions)\n",
    "\n",
    "`Date` and `Session` refer to types for 'session' parameters (see [sessions.ipynb](./sessions.ipynb) for a tutorial on how to work with sessions).\n",
    "\n",
    "`Minute` and `TradingMinute` refer to types for 'minute' parameters (see [minutes.ipynb](./minutes.ipynb) for a tutorial on how to work with mintues)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup\n",
    "import exchange_calendars as xcals\n",
    "import pandas as pd\n",
    "\n",
    "one_minute = pd.Timedelta(1, \"T\")\n",
    "\n",
    "nys = xcals.get_calendar(\"XNYS\") # New York Stock Exchange\n",
    "hkg = xcals.get_calendar(\"XHKG\") # Hong Kong Stock Exchange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query a Date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The argument of methods in this section takes a `Date` type."
   ]
  },
  {
   "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-31</th>\n",
       "      <td>2021-12-31 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-31 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-03</th>\n",
       "      <td>2022-01-03 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2022-01-03 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-04</th>\n",
       "      <td>2022-01-04 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2022-01-04 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open break_start break_end  \\\n",
       "2021-12-31 2021-12-31 14:30:00+00:00         NaT       NaT   \n",
       "2022-01-03 2022-01-03 14:30:00+00:00         NaT       NaT   \n",
       "2022-01-04 2022-01-04 14:30:00+00:00         NaT       NaT   \n",
       "\n",
       "                               close  \n",
       "2021-12-31 2021-12-31 21:00:00+00:00  \n",
       "2022-01-03 2022-01-03 21:00:00+00:00  \n",
       "2022-01-04 2022-01-04 21:00:00+00:00  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference, all times are UTC\n",
    "nys.schedule.loc[\"2021-12-31\":\"2022-01-04\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`is_session`** queries if a date represents a session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.is_session(\"2022-01-01\"), nys.is_session(\"2022-01-04\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`date_to_session`** will return the the passed `date` if `date` represents a session, or otherwise the nearest session in the passed `direction`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-04 00:00:00')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# date is a session so `direction` is ignored\n",
    "nys.date_to_session(\"2022-01-04\", direction=\"next\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-03 00:00:00', freq='C')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.date_to_session(\"2022-01-01\", direction=\"next\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2021-12-31 00:00:00', freq='C')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.date_to_session(\"2022-01-01\", direction=\"previous\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ValueError is raised if `direction` is not passed and `date` is not a session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nys.date_to_session(\"2022-01-01\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "ValueError                                Traceback (most recent call last)\n",
    "Input In [7], in <cell line: 1>()\n",
    "----> 1 nys.date_to_session(\"2022-01-01\")\n",
    "\n",
    "ValueError: `date` '2022-01-01 00:00:00' does not represent a session. Consider passing a `direction`.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query a Session\n",
    "\n",
    "The argument of methods in this section takes a `Session` type.\n",
    "\n",
    "The following methods can be used to return the **open, close** and **break times** of a session..."
   ]
  },
  {
   "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>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>2022-01-04</th>\n",
       "      <td>2022-01-04 01:30:00+00:00</td>\n",
       "      <td>2022-01-04 04:00:00+00:00</td>\n",
       "      <td>2022-01-04 05:00:00+00:00</td>\n",
       "      <td>2022-01-04 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2022-01-04 2022-01-04 01:30:00+00:00 2022-01-04 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2022-01-04 2022-01-04 05:00:00+00:00 2022-01-04 08:00:00+00:00  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference (all times are UTC)\n",
    "session = \"2022-01-04\"\n",
    "hkg.schedule.loc[[session]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 01:30:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 08:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.session_open(session), hkg.session_close(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 01:30:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 08:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or\n",
    "hkg.session_open_close(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 04:00:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 05:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.session_break_start(session), hkg.session_break_end(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 04:00:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 05:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or\n",
    "hkg.session_break_start_end(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-04 09:30:00+0800', tz='Asia/Hong_Kong')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in local time\n",
    "hkg.session_open(session).tz_convert(hkg.tz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`session_*_minute`** methods return a boundary trading minute for a session or subsession."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 01:30:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 07:59:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.session_first_minute(session), hkg.session_last_minute(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 03:59:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 05:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.session_last_am_minute(session), hkg.session_first_pm_minute(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 01:30:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 07:59:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or get first and last minutes together...\n",
    "hkg.session_first_last_minute(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 01:31:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-04 08:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB with \"right\" side...\n",
    "hkg_right = xcals.get_calendar(\"XHKG\", side=\"right\")\n",
    "hkg_right.session_first_last_minute(session)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`session_has_break`** to query if a session has a break."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Hong Kong has a break, at least on `session`...\n",
    "hkg.session_has_break(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# but New York does not\n",
    "nys.session_has_break(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>2022-01-04</th>\n",
       "      <td>2022-01-04 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2022-01-04 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open break_start break_end  \\\n",
       "2022-01-04 2022-01-04 14:30:00+00:00         NaT       NaT   \n",
       "\n",
       "                               close  \n",
       "2022-01-04 2022-01-04 21:00:00+00:00  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ...\n",
    "nys.schedule.loc[[session]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`next_session`** and **`previous_session`** do what they say on the tin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2022-01-04'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# just to recall...\n",
    "session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-03 00:00:00', freq='C')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.previous_session(session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-05 00:00:00', freq='C')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.next_session(session)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`session_offset`** takes a 'count' argument which provides for offsetting a session by a given number of sessions. If `count` is -1 or 1 then the method behaves as `previous_session` and `next_session` respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-03 00:00:00', freq='C'),\n",
       " Timestamp('2022-01-05 00:00:00', freq='C'))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.session_offset(session, count=-1), nys.session_offset(session, count=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2021-12-31 00:00:00', freq='C'),\n",
       " Timestamp('2022-01-06 00:00:00', freq='C'))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.session_offset(session, -2), nys.session_offset(session, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2021-10-22 00:00:00', freq='C'),\n",
       " Timestamp('2022-03-17 00:00:00', freq='C'))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.session_offset(session, -50), nys.session_offset(session, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-04 00:00:00', freq='C')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# going nowhere...\n",
    "nys.session_offset(session, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`session_minutes`** returns an index of all the trading minutes of the passed session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-04 01:30:00+00:00', '2022-01-04 01:31:00+00:00',\n",
       "               '2022-01-04 01:32:00+00:00', '2022-01-04 01:33:00+00:00',\n",
       "               '2022-01-04 01:34:00+00:00', '2022-01-04 01:35:00+00:00',\n",
       "               '2022-01-04 01:36:00+00:00', '2022-01-04 01:37:00+00:00',\n",
       "               '2022-01-04 01:38:00+00:00', '2022-01-04 01:39:00+00:00',\n",
       "               ...\n",
       "               '2022-01-04 07:50:00+00:00', '2022-01-04 07:51:00+00:00',\n",
       "               '2022-01-04 07:52:00+00:00', '2022-01-04 07:53:00+00:00',\n",
       "               '2022-01-04 07:54:00+00:00', '2022-01-04 07:55:00+00:00',\n",
       "               '2022-01-04 07:56:00+00:00', '2022-01-04 07:57:00+00:00',\n",
       "               '2022-01-04 07:58:00+00:00', '2022-01-04 07:59:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', length=330, freq=None)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.session_minutes(session)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query a Minute\n",
    "\n",
    "The argument of methods in this section takes a `Minute` type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`is_trading_minute`** returns a boolean indicating if a minute is a trading minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>2022-01-04</th>\n",
       "      <td>2022-01-04 01:30:00+00:00</td>\n",
       "      <td>2022-01-04 04:00:00+00:00</td>\n",
       "      <td>2022-01-04 05:00:00+00:00</td>\n",
       "      <td>2022-01-04 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2022-01-04 2022-01-04 01:30:00+00:00 2022-01-04 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2022-01-04 2022-01-04 05:00:00+00:00 2022-01-04 08:00:00+00:00  "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "hkg.schedule.loc[[\"2022-01-04\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.is_trading_minute(\"2022-01-04 01:25\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.is_trading_minute(\"2022-01-04 01:35\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "break_minute = \"2022-01-04 04:35\"\n",
    "hkg.is_trading_minute(break_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`is_break_minute`** returns a boolean indicating if a minute lies within a lunch break. Break minutes lie between the last trading minute of the morning subsession and first trading minute of the afternoon subsession, exclusive of both (a break minute cannot be a trading minute)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.is_break_minute(break_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`is_open_on_minute`** can take an optional `include_breaks` argument. If `include_breaks` is False (the default) then the method behaves in the same way as `is_trading_minute`. If `include_breaks` is True then the method will return True if `minute` is either a trading minute or a break minute (otherwise returns False)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.is_open_on_minute(break_minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.is_open_on_minute(break_minute, ignore_breaks=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_to_trading_minute`** will return the passed `minute` if `minute` is a trading minute, or otherwise the closest minute in the passed `direction`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-27 14:15:00+0000', tz='UTC'), True)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a trading minute\n",
    "trading_minute = nys.first_minutes[\"2010-10-27\"] + pd.Timedelta(45, \"T\")\n",
    "trading_minute, nys.is_trading_minute(trading_minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 14:15:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# minute is a trading_minute, so `direction` ignored\n",
    "nys.minute_to_trading_minute(trading_minute, direction=\"next\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-27 13:27:00+0000', tz='UTC'), False)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a non-trading minute\n",
    "non_trading_minute = nys.first_minutes[\"2010-10-27\"] - pd.Timedelta(3, \"T\")\n",
    "non_trading_minute, nys.is_trading_minute(non_trading_minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 13:30:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_trading_minute(non_trading_minute, direction=\"next\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-26 19:59:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_trading_minute(non_trading_minute, direction=\"previous\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ValueError is raised if `direction` is not passed and `minute` is not a trading minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nys.minute_to_trading_minute(non_trading_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "ValueError                                Traceback (most recent call last)\n",
    "Input In [41], in <cell line: 1>()\n",
    "----> 1 nys.minute_to_trading_minute(non_trading_minute)\n",
    "\n",
    "ValueError: `minute` '2010-10-27 13:27:00+00:00' is not a trading minute. Consider passing `direction` as 'next' or 'previous'.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`previous_open`**, **`next_open`**, **`previous_close`** and **`next_close`** will return the previous or next open or close relative to the passed `minute`. NB Which minutes are treated as trading minutes is irrelevant."
   ]
  },
  {
   "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>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>2022-01-04</th>\n",
       "      <td>2022-01-04 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2022-01-04 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-05</th>\n",
       "      <td>2022-01-05 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2022-01-05 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open break_start break_end  \\\n",
       "2022-01-04 2022-01-04 14:30:00+00:00         NaT       NaT   \n",
       "2022-01-05 2022-01-05 14:30:00+00:00         NaT       NaT   \n",
       "\n",
       "                               close  \n",
       "2022-01-04 2022-01-04 21:00:00+00:00  \n",
       "2022-01-05 2022-01-05 21:00:00+00:00  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "nys.schedule.loc[\"2022-01-04\":\"2022-01-05\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-05 14:30:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "open_05 = nys.session_open(\"2022-01-05\")\n",
    "open_05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 14:30:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-06 14:30:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.previous_open(open_05), nys.next_open(open_05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-05 14:30:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.previous_open(open_05 + one_minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 21:00:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-05 21:00:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.previous_close(open_05), nys.next_close(open_05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`previous_minute`** and **`next_minute`** return the first trading minute prior to / following `minute`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-05 14:30:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minute = nys.first_minutes[\"2022-01-05\"]\n",
    "minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 20:59:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-05 14:31:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.previous_minute(minute), nys.next_minute(minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2022-01-05 14:28:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minute -= (one_minute * 2)\n",
    "minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2022-01-04 20:59:00+0000', tz='UTC'),\n",
       " Timestamp('2022-01-05 14:30:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.previous_minute(minute), nys.next_minute(minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_offset`** takes a 'count' argument which provides for offsetting a trading minute by the given number of minutes. If count is -1 or 1 then the method behaves as `previous_minute` and `next_minute` respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 14:15:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling\n",
    "trading_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-27 14:14:00+0000', tz='UTC'),\n",
       " Timestamp('2010-10-27 14:16:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset(trading_minute, count=-1), nys.minute_offset(trading_minute, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-27 14:10:00+0000', tz='UTC'),\n",
       " Timestamp('2010-10-27 14:20:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset(trading_minute, -5), nys.minute_offset(trading_minute, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-27 13:30:00+0000', tz='UTC'),\n",
       " Timestamp('2010-10-27 19:59:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset(trading_minute, -45), nys.minute_offset(trading_minute, 344)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-26 19:59:00+0000', tz='UTC'),\n",
       " Timestamp('2010-10-28 13:30:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset(trading_minute, -46), nys.minute_offset(trading_minute, 345)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2010-10-15 16:15:00+0000', tz='UTC'),\n",
       " Timestamp('2010-11-05 18:45:00+0000', tz='UTC'))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset(trading_minute, -3000), nys.minute_offset(trading_minute, 3000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 14:15:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and of course\n",
    "nys.minute_offset(trading_minute, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_to_session`** returns the session associated with `minute`. If `minute` is a trading minute or a break minute then this will be the session of which the minute is a trading/break minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 00:00:00', freq='C')"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_session(trading_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `minute` is not a trading or break minute then the return is determined by the optional `direction` parameter. If `direction` is \"next\" the return will be the closest session after `minute`, whilst if `direction` is \"previous\" the return will be the closest session before `minute`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 13:27:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "non_trading_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 00:00:00', freq='C')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# default `direction` is \"next\"\n",
    "nys.minute_to_session(non_trading_minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-26 00:00:00', freq='C')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_session(non_trading_minute, direction=\"previous\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`direction` can also take \"none\", in which case `minute` is required to be a trading or break minute. To the contrary a ValueError is raised:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nys.minute_to_session(non_trading_minute, direction=\"none\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "---------------------------------------------------------------------------\n",
    "ValueError                                Traceback (most recent call last)\n",
    "Input In [62], in <cell line: 1>()\n",
    "----> 1 nys.minute_to_session(non_trading_minute, direction=\"none\")\n",
    "\n",
    "ValueError: `minute` '2010-10-27 13:27:00+00:00' is not a trading minute. Consider passing `direction` as 'next' or 'previous'.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_to_past_session`** returns a session that closed before the given `minute`. If the passed `minute` is a trading minute then the method will NOT return the session of which `minute` is a trading minute, but rather a prior session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 14:15:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling\n",
    "trading_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-26 00:00:00', freq='C')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_past_session(trading_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the above differs to `minute_to_session`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 00:00:00', freq='C')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_session(trading_minute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`minute_to_past_session` can take an optional `count` argument (default 1) to offset the past session returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-26 00:00:00', freq='C')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as default\n",
    "nys.minute_to_past_session(trading_minute, count=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-25 00:00:00', freq='C')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_past_session(trading_minute, count=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-22 00:00:00', freq='C')"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_past_session(trading_minute, count=3)\n",
    "# jumping a weekend..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_to_future_session`** works in the same way as **`minute_to_past_session`** albeit looking fowards."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-28 00:00:00', freq='C')"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_future_session(trading_minute)\n",
    "# default count is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-29 00:00:00', freq='C')"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_to_future_session(trading_minute, count=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minute_offset_by_sessions`** offsets a trading minute by a given number of sessions, by default 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-27 14:15:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling again\n",
    "trading_minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-28 14:15:00+0000', tz='UTC', freq='C')"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset_by_sessions(trading_minute)\n",
    "# default count is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-10-25 14:15:00+0000', tz='UTC', freq='C')"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset_by_sessions(trading_minute, count=-2)\n",
    "# offseting 'backwards'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a would-be offset minute is not a minute of the offset session then...\n",
    "\n",
    "If the would-be offset minute is later than the offset session's close, the offset session's last trading minute is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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>close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-12-23</th>\n",
       "      <td>2020-12-23 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-12-24</th>\n",
       "      <td>2020-12-24 18:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-12-28</th>\n",
       "      <td>2020-12-28 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                               close\n",
       "2020-12-23 2020-12-23 21:00:00+00:00\n",
       "2020-12-24 2020-12-24 18:00:00+00:00\n",
       "2020-12-28 2020-12-28 21:00:00+00:00"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "nys.schedule.loc[\"2020-12-23\":\"2020-12-28\", \"close\"].to_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2020-12-24 17:59:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minute_offset_by_sessions(\"2020-12-23 20:22\", 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the would-be offset minute is earlier than the offset session's open, the offset session's first trading minute is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2011-03-03</th>\n",
       "      <td>2011-03-03 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-03-04</th>\n",
       "      <td>2011-03-04 02:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-03-07</th>\n",
       "      <td>2011-03-07 01:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-03-08</th>\n",
       "      <td>2011-03-08 01:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open\n",
       "2011-03-03 2011-03-03 02:00:00+00:00\n",
       "2011-03-04 2011-03-04 02:00:00+00:00\n",
       "2011-03-07 2011-03-07 01:30:00+00:00\n",
       "2011-03-08 2011-03-08 01:30:00+00:00"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "hkg.schedule.loc[\"'2011-03-03\":\"2011-03-08\", \"open\"].to_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2011-03-04 02:00:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.minute_offset_by_sessions(\"2011-03-08 01:47\", count=-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the would-be offset minute is a break minute, the last pre-break trading minute is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "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>2010-12-23</th>\n",
       "      <td>2010-12-23 02:00:00+00:00</td>\n",
       "      <td>2010-12-23 04:00:00+00:00</td>\n",
       "      <td>2010-12-23 05:00:00+00:00</td>\n",
       "      <td>2010-12-23 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010-12-24</th>\n",
       "      <td>2010-12-24 02:00:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2010-12-24 04:30:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2010-12-23 2010-12-23 02:00:00+00:00 2010-12-23 04:00:00+00:00   \n",
       "2010-12-24 2010-12-24 02:00:00+00:00                       NaT   \n",
       "\n",
       "                           break_end                     close  \n",
       "2010-12-23 2010-12-23 05:00:00+00:00 2010-12-23 08:00:00+00:00  \n",
       "2010-12-24                       NaT 2010-12-24 04:30:00+00:00  "
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for reference\n",
    "hkg.schedule.loc[\"2010-12-23\":\"2010-12-24\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2010-12-23 03:59:00+0000', tz='UTC')"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.minute_offset_by_sessions(\"2010-12-24 04:15\", count=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that evaluate an index of contiguous trading minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minutes_in_range`** returns all trading minutes within and inclusive of `start` and `end`. The parameters take `Minute` type (i.e. they do not need to represent actual trading minutes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "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>2022-01-04</th>\n",
       "      <td>2022-01-04 01:30:00+00:00</td>\n",
       "      <td>2022-01-04 04:00:00+00:00</td>\n",
       "      <td>2022-01-04 05:00:00+00:00</td>\n",
       "      <td>2022-01-04 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2022-01-04 2022-01-04 01:30:00+00:00 2022-01-04 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2022-01-04 2022-01-04 05:00:00+00:00 2022-01-04 08:00:00+00:00  "
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling...\n",
    "hkg.schedule.loc[[\"2022-01-04\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-04 03:55:00+00:00', '2022-01-04 03:56:00+00:00',\n",
       "               '2022-01-04 03:57:00+00:00', '2022-01-04 03:58:00+00:00',\n",
       "               '2022-01-04 03:59:00+00:00', '2022-01-04 05:00:00+00:00',\n",
       "               '2022-01-04 05:01:00+00:00', '2022-01-04 05:02:00+00:00',\n",
       "               '2022-01-04 05:03:00+00:00', '2022-01-04 05:04:00+00:00',\n",
       "               '2022-01-04 05:05:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.minutes_in_range(\"2022-01-04 03:55\", \"2022-01-04 05:05\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-04 05:00:00+00:00', '2022-01-04 05:01:00+00:00',\n",
       "               '2022-01-04 05:02:00+00:00', '2022-01-04 05:03:00+00:00',\n",
       "               '2022-01-04 05:04:00+00:00', '2022-01-04 05:05:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# `start` does not have to represent a trading minute\n",
    "hkg.minutes_in_range(\"2022-01-04 04:30\", \"2022-01-04 05:05\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, **`minutes_window`** can be used to create an index of trading minutes of a defined length, anchored by the passed `minute`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-04 07:55:00+00:00', '2022-01-04 07:56:00+00:00',\n",
       "               '2022-01-04 07:57:00+00:00', '2022-01-04 07:58:00+00:00',\n",
       "               '2022-01-04 07:59:00+00:00', '2022-01-05 01:30:00+00:00',\n",
       "               '2022-01-05 01:31:00+00:00', '2022-01-05 01:32:00+00:00',\n",
       "               '2022-01-05 01:33:00+00:00', '2022-01-05 01:34:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.minutes_window(\"2022-01-04 07:55\", count=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or to work backwards from `minute`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-04 07:46:00+00:00', '2022-01-04 07:47:00+00:00',\n",
       "               '2022-01-04 07:48:00+00:00', '2022-01-04 07:49:00+00:00',\n",
       "               '2022-01-04 07:50:00+00:00', '2022-01-04 07:51:00+00:00',\n",
       "               '2022-01-04 07:52:00+00:00', '2022-01-04 07:53:00+00:00',\n",
       "               '2022-01-04 07:54:00+00:00', '2022-01-04 07:55:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hkg.minutes_window(\"2022-01-04 07:55\", count=-10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query multiple TradingMinute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`minutes_to_sessions`** does for multiple TradingMinute what `minute_to_session` does for one. However, this method is limited by requiring every minute of the passed `minutes` parameter to be a trading minute (i.e. there's no `direction` parameter available for this one). Also, whilst minutes do not need to be contiguous, they do need to be in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2022-09-02   2022-09-02 13:35:00+00:00\n",
       "2022-09-06   2022-09-06 13:35:00+00:00\n",
       "2022-09-07   2022-09-07 13:35:00+00:00\n",
       "2022-09-08   2022-09-08 13:35:00+00:00\n",
       "2022-09-09   2022-09-09 13:35:00+00:00\n",
       "Freq: C, Name: first_minutes, dtype: datetime64[ns, UTC]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set up a minute index to pass as `minutes`..\n",
    "ser = nys.first_minutes[-200:-195] + (one_minute * 5)\n",
    "ser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-09-02 13:35:00+00:00', '2022-09-08 13:35:00+00:00',\n",
       "               '2022-09-09 13:35:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', name='first_minutes', freq=None)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still setting up 'minutes'\n",
    "mins = pd.DatetimeIndex(ser)\n",
    "mins = mins[:1].union(mins[-2:], sort=False)\n",
    "mins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-09-02', '2022-09-08', '2022-09-09'], dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.minutes_to_sessions(mins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-09-02', '2022-09-06', '2022-09-07', '2022-09-08',\n",
       "               '2022-09-09'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB `minutes` can also be passed as a Series...\n",
    "nys.minutes_to_sessions(ser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that evaluate an index of contiguous sessions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sessions_in_range`** does for sessions what `minutes_in_range` does for minutes. Returns an index of all the sessions between `start` and `end`. Parameters take `Date` type (i.e. they do not need to represent actual sessions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2022-01-03', '2022-01-04', '2022-01-05', '2022-01-06',\n",
       "               '2022-01-07', '2022-01-10', '2022-01-11', '2022-01-12',\n",
       "               '2022-01-13', '2022-01-14',\n",
       "               ...\n",
       "               '2022-12-16', '2022-12-19', '2022-12-20', '2022-12-21',\n",
       "               '2022-12-22', '2022-12-23', '2022-12-27', '2022-12-28',\n",
       "               '2022-12-29', '2022-12-30'],\n",
       "              dtype='datetime64[ns]', length=251, freq='C')"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_in_range(\"2022\", \"2022-12-31\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sessions_window`** holds no surprises if you're familiar with `minutes_window`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23', '2021-12-27', '2021-12-28'], dtype='datetime64[ns]', freq='C')"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_window(\"2021-12-23\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-21', '2021-12-22', '2021-12-23'], dtype='datetime64[ns]', freq='C')"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_window(\"2021-12-23\", -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query a range of dates\n",
    "\n",
    "The methods in this section query sessions that fall within the range of dates from `start` through `end` (inclusive of both). Both parameters take a `Date` (i.e the passed values can but do not have to represent an actual session)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "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 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-23 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-27</th>\n",
       "      <td>2021-12-27 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-27 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-28</th>\n",
       "      <td>2021-12-28 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-28 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-12-29</th>\n",
       "      <td>2021-12-29 14:30:00+00:00</td>\n",
       "      <td>NaT</td>\n",
       "      <td>NaT</td>\n",
       "      <td>2021-12-29 21:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open break_start break_end  \\\n",
       "2021-12-23 2021-12-23 14:30:00+00:00         NaT       NaT   \n",
       "2021-12-27 2021-12-27 14:30:00+00:00         NaT       NaT   \n",
       "2021-12-28 2021-12-28 14:30:00+00:00         NaT       NaT   \n",
       "2021-12-29 2021-12-29 14:30:00+00:00         NaT       NaT   \n",
       "\n",
       "                               close  \n",
       "2021-12-23 2021-12-23 21:00:00+00:00  \n",
       "2021-12-27 2021-12-27 21:00:00+00:00  \n",
       "2021-12-28 2021-12-28 21:00:00+00:00  \n",
       "2021-12-29 2021-12-29 21:00:00+00:00  "
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start, end = \"2021-12-23\", \"2021-12-29\"\n",
    "# for reference\n",
    "nys.schedule.loc[start:end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sessions_distance`** returns the number of sessions in the range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_distance(start, end)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sessions_minutes`** returns an index comprised of the trading minutes of all sessions in the given range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 14:30:00+00:00', '2021-12-23 14:31:00+00:00',\n",
       "               '2021-12-23 14:32:00+00:00', '2021-12-23 14:33:00+00:00',\n",
       "               '2021-12-23 14:34:00+00:00', '2021-12-23 14:35:00+00:00',\n",
       "               '2021-12-23 14:36:00+00:00', '2021-12-23 14:37:00+00:00',\n",
       "               '2021-12-23 14:38:00+00:00', '2021-12-23 14:39:00+00:00',\n",
       "               ...\n",
       "               '2021-12-29 20:50:00+00:00', '2021-12-29 20:51:00+00:00',\n",
       "               '2021-12-29 20:52:00+00:00', '2021-12-29 20:53:00+00:00',\n",
       "               '2021-12-29 20:54:00+00:00', '2021-12-29 20:55:00+00:00',\n",
       "               '2021-12-29 20:56:00+00:00', '2021-12-29 20:57:00+00:00',\n",
       "               '2021-12-29 20:58:00+00:00', '2021-12-29 20:59:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', length=1560, freq=None)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_minutes(start, end)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`sessions_minutes_count`** returns just the number of trading minutes corresponding to the sessions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1560"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.sessions_minutes_count(start, end)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1560"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# i.e. `sessions_minutes_count` behaves as...\n",
    "len(nys.sessions_minutes(start, end))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sessions_opens` and `sessions_closes` were **deprecated** in 4.0. Instead query the analogous properties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2021-12-23   2021-12-23 14:30:00+00:00\n",
       "2021-12-27   2021-12-27 14:30:00+00:00\n",
       "2021-12-28   2021-12-28 14:30:00+00:00\n",
       "2021-12-29   2021-12-29 14:30:00+00:00\n",
       "Freq: C, Name: open, dtype: datetime64[ns, UTC]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.opens[start:end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2021-12-23   2021-12-23 21:00:00+00:00\n",
       "2021-12-27   2021-12-27 21:00:00+00:00\n",
       "2021-12-28   2021-12-28 21:00:00+00:00\n",
       "2021-12-29   2021-12-29 21:00:00+00:00\n",
       "Freq: C, Name: close, dtype: datetime64[ns, UTC]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.closes[start:end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods that query a time\n",
    "\n",
    "`is_open_at_time` is rather unique in that it is not concerned with any specific `Minute` or `Date` but rather only if the exchange is considered open as at a given instance. The calendar's side has no effect on the return. Consequently, \n",
    "even if the calendar's side is \"both\" it's possible to query if the market is open as at a time specified with second or greater accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "hkg_both = xcals.get_calendar(\"XHKG\", side=\"both\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "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>2022-01-04</th>\n",
       "      <td>2022-01-04 01:30:00+00:00</td>\n",
       "      <td>2022-01-04 04:00:00+00:00</td>\n",
       "      <td>2022-01-04 05:00:00+00:00</td>\n",
       "      <td>2022-01-04 08:00:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                open               break_start  \\\n",
       "2022-01-04 2022-01-04 01:30:00+00:00 2022-01-04 04:00:00+00:00   \n",
       "\n",
       "                           break_end                     close  \n",
       "2022-01-04 2022-01-04 05:00:00+00:00 2022-01-04 08:00:00+00:00  "
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling...\n",
    "hkg.schedule.loc[[\"2022-01-04\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timestamp = pd.Timestamp(\"2022-01-04 07:59:59\")\n",
    "hkg_both.is_open_at_time(timestamp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that unlike other methods, the input has to be an instance of `pd.Timestamp`. If passed as timezone-naive (as here) it will be assumed to represent UTC.\n",
    "\n",
    "`is_open_at_time` can take a 'side' option to determine if the exchange will be considered open or closed on a session's bounds:\n",
    "* **\"left\"** (default) - treat exchange as open on session open and any break-end, treat as closed on session close and any break-start.\n",
    "* **\"right\"** - treat exchange as open on session close and any break-start, treat as closed on session open and any break-end.\n",
    "* **\"both\"** - treat exchange as open on all of session open, close and any break-start and break-end.\n",
    "* **\"neither\"** - treat exchange as closed on all of session open, close and any break-start and break-end.\n",
    "\n",
    "It can also take an `ignore_breaks` options which, as for `is_open_on_minute`, will treat the exchange as open during any break."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, False, True, False]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sides = (\"left\", \"right\", \"both\", \"neither\")\n",
    "timestamp = pd.Timestamp(\"2022-01-04 01:30:00\")\n",
    "[ hkg.is_open_at_time(timestamp, side=side) for side in sides ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, True, True, False]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timestamp = pd.Timestamp(\"2022-01-04 04:00:00\")\n",
    "[ hkg.is_open_at_time(timestamp, side=side) for side in sides ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, True]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ hkg.is_open_at_time(timestamp, side, ignore_breaks=True) for side in sides ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, True]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timestamp = pd.Timestamp(\"2022-01-04 03:59:59\")\n",
    "[ hkg.is_open_at_time(timestamp, side=side) for side in sides ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, False, False, False]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timestamp = pd.Timestamp(\"2022-01-04 04:00:01\")\n",
    "[ hkg.is_open_at_time(timestamp, side=side) for side in sides ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, False, False, False]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ hkg.is_open_at_time(timestamp, side, ignore_breaks=False) for side in sides ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`trading_index`**  \n",
    "Saving the best for last, `trading_index` provides for creating a trading index of given `period` over a range of sessions. It's options provide so much flexibility that it's got it's own tutorial at [trading_index.ipynb](./trading_index.ipynb). \n",
    "\n",
    "Here's a taster..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('2021-12-23', '2021-12-29')"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recalling\n",
    "start, end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 14:30:00+00:00', '2021-12-23 14:45:00+00:00',\n",
       "               '2021-12-23 15:00:00+00:00', '2021-12-23 15:15:00+00:00',\n",
       "               '2021-12-23 15:30:00+00:00', '2021-12-23 15:45:00+00:00',\n",
       "               '2021-12-23 16:00:00+00:00', '2021-12-23 16:15:00+00:00',\n",
       "               '2021-12-23 16:30:00+00:00', '2021-12-23 16:45:00+00:00',\n",
       "               ...\n",
       "               '2021-12-29 18:30:00+00:00', '2021-12-29 18:45:00+00:00',\n",
       "               '2021-12-29 19:00:00+00:00', '2021-12-29 19:15:00+00:00',\n",
       "               '2021-12-29 19:30:00+00:00', '2021-12-29 19:45:00+00:00',\n",
       "               '2021-12-29 20:00:00+00:00', '2021-12-29 20:15:00+00:00',\n",
       "               '2021-12-29 20:30:00+00:00', '2021-12-29 20:45:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', length=104, freq=None)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.trading_index(start, end, \"15min\", intervals=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 14:54:00+00:00', '2021-12-23 15:18:00+00:00',\n",
       "               '2021-12-23 15:42:00+00:00', '2021-12-23 16:06:00+00:00',\n",
       "               '2021-12-23 16:30:00+00:00', '2021-12-23 16:54:00+00:00',\n",
       "               '2021-12-23 17:18:00+00:00', '2021-12-23 17:42:00+00:00',\n",
       "               '2021-12-23 18:06:00+00:00', '2021-12-23 18:30:00+00:00',\n",
       "               '2021-12-23 18:54:00+00:00', '2021-12-23 19:18:00+00:00',\n",
       "               '2021-12-23 19:42:00+00:00', '2021-12-23 20:06:00+00:00',\n",
       "               '2021-12-23 20:30:00+00:00', '2021-12-23 20:54:00+00:00',\n",
       "               '2021-12-23 21:18:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.trading_index(start, start, \"24min\", closed=\"right\", intervals=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2021-12-23 14:30:00+00:00', '2021-12-23 14:54:00+00:00',\n",
       "               '2021-12-23 15:18:00+00:00', '2021-12-23 15:42:00+00:00',\n",
       "               '2021-12-23 16:06:00+00:00', '2021-12-23 16:30:00+00:00',\n",
       "               '2021-12-23 16:54:00+00:00', '2021-12-23 17:18:00+00:00',\n",
       "               '2021-12-23 17:42:00+00:00', '2021-12-23 18:06:00+00:00',\n",
       "               '2021-12-23 18:30:00+00:00', '2021-12-23 18:54:00+00:00',\n",
       "               '2021-12-23 19:18:00+00:00', '2021-12-23 19:42:00+00:00',\n",
       "               '2021-12-23 20:06:00+00:00', '2021-12-23 20:30:00+00:00',\n",
       "               '2021-12-23 20:54:00+00:00'],\n",
       "              dtype='datetime64[ns, UTC]', freq=None)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nys.trading_index(start, start, \"24min\", force_close=True, intervals=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntervalIndex([[2021-12-23 14:30:00, 2021-12-23 14:50:00), [2021-12-23 14:50:00, 2021-12-23 15:10:00), [2021-12-23 15:10:00, 2021-12-23 15:30:00), [2021-12-23 15:30:00, 2021-12-23 15:50:00), [2021-12-23 15:50:00, 2021-12-23 16:10:00) ... [2021-12-29 19:30:00, 2021-12-29 19:50:00), [2021-12-29 19:50:00, 2021-12-29 20:10:00), [2021-12-29 20:10:00, 2021-12-29 20:30:00), [2021-12-29 20:30:00, 2021-12-29 20:50:00), [2021-12-29 20:50:00, 2021-12-29 21:10:00)], dtype='interval[datetime64[ns, UTC], left]')"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = nys.trading_index(start, end, \"20min\", intervals=True)\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "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",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 14:30:00, 2021-12-23 14:50:00)</th>\n",
       "      <td>2021-12-23 14:30:00+00:00</td>\n",
       "      <td>2021-12-23 14:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 14:50:00, 2021-12-23 15:10:00)</th>\n",
       "      <td>2021-12-23 14:50:00+00:00</td>\n",
       "      <td>2021-12-23 15:10:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 15:10:00, 2021-12-23 15:30:00)</th>\n",
       "      <td>2021-12-23 15:10:00+00:00</td>\n",
       "      <td>2021-12-23 15:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 15:30:00, 2021-12-23 15:50:00)</th>\n",
       "      <td>2021-12-23 15:30:00+00:00</td>\n",
       "      <td>2021-12-23 15:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-23 15:50:00, 2021-12-23 16:10:00)</th>\n",
       "      <td>2021-12-23 15:50:00+00:00</td>\n",
       "      <td>2021-12-23 16:10: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-29 19:30:00, 2021-12-29 19:50:00)</th>\n",
       "      <td>2021-12-29 19:30:00+00:00</td>\n",
       "      <td>2021-12-29 19:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-29 19:50:00, 2021-12-29 20:10:00)</th>\n",
       "      <td>2021-12-29 19:50:00+00:00</td>\n",
       "      <td>2021-12-29 20:10:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-29 20:10:00, 2021-12-29 20:30:00)</th>\n",
       "      <td>2021-12-29 20:10:00+00:00</td>\n",
       "      <td>2021-12-29 20:30:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-29 20:30:00, 2021-12-29 20:50:00)</th>\n",
       "      <td>2021-12-29 20:30:00+00:00</td>\n",
       "      <td>2021-12-29 20:50:00+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[2021-12-29 20:50:00, 2021-12-29 21:10:00)</th>\n",
       "      <td>2021-12-29 20:50:00+00:00</td>\n",
       "      <td>2021-12-29 21:10:00+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>80 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           left_side  \\\n",
       "[2021-12-23 14:30:00, 2021-12-23 14:50:00) 2021-12-23 14:30:00+00:00   \n",
       "[2021-12-23 14:50:00, 2021-12-23 15:10:00) 2021-12-23 14:50:00+00:00   \n",
       "[2021-12-23 15:10:00, 2021-12-23 15:30:00) 2021-12-23 15:10:00+00:00   \n",
       "[2021-12-23 15:30:00, 2021-12-23 15:50:00) 2021-12-23 15:30:00+00:00   \n",
       "[2021-12-23 15:50:00, 2021-12-23 16:10:00) 2021-12-23 15:50:00+00:00   \n",
       "...                                                              ...   \n",
       "[2021-12-29 19:30:00, 2021-12-29 19:50:00) 2021-12-29 19:30:00+00:00   \n",
       "[2021-12-29 19:50:00, 2021-12-29 20:10:00) 2021-12-29 19:50:00+00:00   \n",
       "[2021-12-29 20:10:00, 2021-12-29 20:30:00) 2021-12-29 20:10:00+00:00   \n",
       "[2021-12-29 20:30:00, 2021-12-29 20:50:00) 2021-12-29 20:30:00+00:00   \n",
       "[2021-12-29 20:50:00, 2021-12-29 21:10:00) 2021-12-29 20:50:00+00:00   \n",
       "\n",
       "                                                          right_side  \n",
       "[2021-12-23 14:30:00, 2021-12-23 14:50:00) 2021-12-23 14:50:00+00:00  \n",
       "[2021-12-23 14:50:00, 2021-12-23 15:10:00) 2021-12-23 15:10:00+00:00  \n",
       "[2021-12-23 15:10:00, 2021-12-23 15:30:00) 2021-12-23 15:30:00+00:00  \n",
       "[2021-12-23 15:30:00, 2021-12-23 15:50:00) 2021-12-23 15:50:00+00:00  \n",
       "[2021-12-23 15:50:00, 2021-12-23 16:10:00) 2021-12-23 16:10:00+00:00  \n",
       "...                                                              ...  \n",
       "[2021-12-29 19:30:00, 2021-12-29 19:50:00) 2021-12-29 19:50:00+00:00  \n",
       "[2021-12-29 19:50:00, 2021-12-29 20:10:00) 2021-12-29 20:10:00+00:00  \n",
       "[2021-12-29 20:10:00, 2021-12-29 20:30:00) 2021-12-29 20:30:00+00:00  \n",
       "[2021-12-29 20:30:00, 2021-12-29 20:50:00) 2021-12-29 20:50:00+00:00  \n",
       "[2021-12-29 20:50:00, 2021-12-29 21:10:00) 2021-12-29 21:10:00+00:00  \n",
       "\n",
       "[80 rows x 2 columns]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# just to see it clearer...\n",
    "pd.DataFrame(dict(left_side=index.left, right_side=index.right), index=index)"
   ]
  }
 ],
 "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
}