timezone_troubles.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div style='font-size: 72px; text-align: center; height: 95%; top: 2.5%'>\n",
    "    <b>Working with Time Zones:</b>\n",
    "    <b><div style='font-size: 64px; text-align: center'>Everything You Wish You Didn't Need to Know</div></b>\n",
    "    <br/>\n",
    "    <br/>\n",
    "    <span style='font-size: 50px'>\n",
    "        Paul Ganssle<br/>\n",
    "        <img src=\"images/bloomberg-logo-black.svg\" style=\"border: none; box-shadow: none; height: 5rem\"><br/>\n",
    "        <div style=\"text-align:center\"><img src=\"images/dateutil-logo.png\" style=\"border: 0px; box-shadow: none; height: 150px; display:inline\"></div>\n",
    "        </span>\n",
    "</div>\n",
    "<br/><br/>\n",
    "<div style=\"text-align: center; font-size: 20px\">\n",
    "<i><a href=\"https://github.com/pganssle/pylondinium-2018-timezones-talk\">Github repo for this talk</a></i>\n",
    "    <br/>\n",
    "    <img src=\"images/cc0-standalone.svg\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pytz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "nbpresent": {
     "id": "01f47c89-e2ac-483d-811c-e02632ca7f58"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from dateutil.tz import gettz, tzutc\n",
    "from dateutil import tz\n",
    "from datetime import datetime, timedelta, tzinfo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "nbpresent": {
     "id": "c23203a4-7663-4016-8c63-9354e4341dbc"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from dateutil.tz import gettz\n",
    "from dateutil.tz import tzutc, tzoffset, tzlocal\n",
    "from dateutil.tz import tzstr, tzrange, tzfile\n",
    "\n",
    "from dateutil import relativedelta as rd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from helper_functions import print_tzinfo\n",
    "from helper_functions import print_dt_eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def add_absolute(dt, td):\n",
    "    if dt.tzinfo is None:\n",
    "        return dt + td\n",
    "    \n",
    "    dtu = dt.astimezone(tz.UTC)\n",
    "    return (dtu + td).astimezone(dt.tzinfo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "NYC = gettz('America/New_York')\n",
    "CHI = gettz('America/Chicago')\n",
    "UTC = tzutc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<style>\n",
    ".emoji {\n",
    "    font-family: Noto Color Emoji !important;\n",
    "}\n",
    "</style>\n",
    "\n",
    "<div style=\"font-size: 4.5em;\">\n",
    "<span class=\"emoji\">⚠️</span> Dialect Warning <span class=\"emoji\">⚠️</span>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font style=\"font-size: 3.5em; font-family: monospace;\">s/zee/zed/g</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## UTC\n",
    "\n",
    "- Reference time zone\n",
    "- Monotonic-ish (what's a few leap seconds between friends?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Time zones vs. Offsets\n",
    "\n",
    "- `UTC+1` is an offset\n",
    "- `Europe/London` is a time zone"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- `BST` is a highly-context-dependent abbreviation:\n",
    "    - British Summer Time (`UTC+1`)\n",
    "    - Bangladesh Standard Time (`UTC+6`)\n",
    "    - Bougainville Standard Time (`UTC+11`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Complicated time zones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-integer offsets\n",
    "\n",
    "**Examples:**\n",
    "- `Australia/Adelaide` (+09:30)\n",
    "- `Asia/Kathmandu` (+05:45)\n",
    "- `Africa/Monrovia` (+00:44:30) (Before 1979)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Change of DST status without offset change\n",
    "\n",
    "* Portugal, 1992\n",
    "  * `WET  (+0 STD) -> WEST (+1 DST)  1992-03-29`\n",
    "  * `WEST (+1 DST) -> CET  (+1 STD)  1992-09-27`\n",
    " \n",
    "* Portugal, 1996\n",
    "  * `CET  (+1 STD) -> WEST (+1 DST)  1996-03-31`\n",
    "  * `WEST (+1 DST) -> WET  (+0 STD)  1996-10-27`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Complicated time zones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Zone name change without offset change\n",
    "\n",
    "* Aleutian Islands, 1983:\n",
    "  * `BST (-11 STD)` -> `BDT (-10 DST)`, `1983-04-24`\n",
    "  * `BDT (-10 DST)` -> `AHST (-10 STD)`, `1983-10-30`\n",
    "  * `AHST (-10 STD)` -> `HST (-10 STD)`, `1983-11-30` (Zone renamed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### More than one DST transition per year\n",
    "\n",
    "* Morroco, 2012\n",
    "    * `WET  (+0 STD) -> WEST (+1 DST)  2012-04-29`\n",
    "    * `WEST (+1 DST) -> WET  (+0 STD)  2012-07-20`\n",
    "    * `WET  (+0 STD) -> WEST (+1 DST)  2012-08-20`\n",
    "    * `WEST (+1 DST) -> WET  (+0 STD)  2012-09-30`\n",
    "\n",
    "... and Morocco in 2013-present, and Egypt in 2010 and 2014, and Palestine in 2011."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Complicated time zones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Missing days\n",
    "\n",
    "* Christmas Island (Kiritimati), December 31, 1994  (UTC-10 -> UTC+14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1994-12-30 23:59:00-10:00\n",
      "1995-01-01 00:01:00+14:00\n"
     ]
    }
   ],
   "source": [
    "dt_before = datetime(1994, 12, 30, 23, 59, tzinfo=tz.gettz('Pacific/Kiritimati'))\n",
    "dt_after = add_absolute(dt_before, timedelta(minutes=2))\n",
    "\n",
    "print(dt_before)\n",
    "print(dt_after)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also Samoa on January 29, 2011."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Double days\n",
    "* Kwajalein Atoll, 1969"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1969-09-30 11:59:00+11:00\n",
      "1969-09-30 12:01:00+11:00\n"
     ]
    }
   ],
   "source": [
    "dt_before = datetime(1969, 9, 30, 11, 59, tzinfo=tz.gettz('Pacific/Kwajalein'))\n",
    "dt_after = add_absolute(dt_before, timedelta(minutes=2))\n",
    "\n",
    "print(dt_before)\n",
    "print(dt_after)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## More than one timezone *per place*\n",
    "\n",
    "Officially, China has a single timezone (`Asia/Shanghai`) for the entire country (UTC+8), but unofficially in Xinjiang they observe [Xinjiang Time](https://en.wikipedia.org/wiki/Xinjiang_Time). Quoting Wikipedia entry:\n",
    "\n",
    "> Currently, the timezone used within Xinjiang is roughly split along the ethnic divide, with most ethnic Han population in the area following Beijing Time, and most ethnic Uyghur population as well as population of some other ethnics in the area following Xinjiang Time.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `Asia/Shanghai`\n",
    "![Asia/Shanghai time zone map](images/china_shanghai.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `Asia/Urumqi`\n",
    "![Asia/Shanghai time zone map](images/china_overlay.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why do we need to work with time zones at all?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-03-09 17:00:00-05:00\n",
      "2017-03-10 17:00:00-05:00\n",
      "2017-03-13 17:00:00-04:00\n",
      "2017-03-14 17:00:00-04:00\n",
      "2017-03-15 17:00:00-04:00\n"
     ]
    }
   ],
   "source": [
    "from dateutil import rrule as rr\n",
    "\n",
    "# Close of business in New York on weekdays\n",
    "closing_times = rr.rrule(freq=rr.DAILY, byweekday=(rr.MO, rr.TU, rr.WE, rr.TH, rr.FR),\n",
    "                         byhour=17, dtstart=datetime(2017, 3, 9, 17), count=5)\n",
    "\n",
    "for dt in closing_times:\n",
    "    print(dt.replace(tzinfo=NYC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-03-09 22:00:00+00:00\n",
      "2017-03-10 22:00:00+00:00\n",
      "2017-03-13 21:00:00+00:00\n",
      "2017-03-14 21:00:00+00:00\n",
      "2017-03-15 21:00:00+00:00\n"
     ]
    }
   ],
   "source": [
    "for dt in closing_times:\n",
    "    print(dt.replace(tzinfo=NYC).astimezone(UTC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python's Time Zone Model\n",
    "## `tzinfo`\n",
    "\n",
    "* Time zones are provided by *subclassing* `tzinfo`.\n",
    "* Information provided is a function of the datetime:\n",
    "\n",
    "    * `tzname`: The (usually abbreviated) name of the time zone at the given datetime\n",
    "    * `utcoffset`: The offset from UTC at the given datetime\n",
    "    * `dst`: The size of the datetime's DST offset (usually 0 or 1 hour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An example `tzinfo` implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-11-04 12:00:00-04:00\n",
      "2017-11-05 12:00:00-05:00\n"
     ]
    }
   ],
   "source": [
    "class ET(tzinfo):\n",
    "    def utcoffset(self, dt):\n",
    "        if self.isdaylight(dt):\n",
    "            return timedelta(hours=-4)\n",
    "        else:\n",
    "            return timedelta(hours=-5)\n",
    "    \n",
    "    def dst(self, dt):\n",
    "        if self.isdaylight(dt):\n",
    "            return timedelta(hours=1)\n",
    "        else:\n",
    "            return timedelta(hours=0)\n",
    "    \n",
    "    def tzname(self, dt):\n",
    "        return \"EDT\" if self.isdaylight(dt) else \"EST\"\n",
    "\n",
    "    def isdaylight(self, dt):\n",
    "        dst_start = datetime(dt.year, 1, 1) + rd.relativedelta(month=3, weekday=rd.SU(+2), hour=2)\n",
    "        dst_end = datetime(dt.year, 1, 1) + rd.relativedelta(month=11, weekday=rd.SU, hour=2)\n",
    "        \n",
    "        return dst_start <= dt.replace(tzinfo=None) < dst_end\n",
    "\n",
    "print(datetime(2017, 11, 4, 12, 0, tzinfo=ET()))\n",
    "print(datetime(2017, 11, 5, 12, 0, tzinfo=ET()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-11-05 01:30:00-04:00\n",
      "2017-11-05 02:30:00-05:00\n"
     ]
    }
   ],
   "source": [
    "dt_before_utc = datetime(2017, 11, 5, 0, 30, tzinfo=ET()).astimezone(tz.UTC)\n",
    "dt_during = (dt_before_utc + timedelta(hours=1)).astimezone(ET())  # 1:30 EST\n",
    "dt_after = (dt_before_utc + timedelta(hours=2)).astimezone(ET())   # 1:30 EDT\n",
    "\n",
    "print(dt_during)   # Lookin good!\n",
    "print(dt_after)    # OH NO!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ambiguous times\n",
    "Ambiguous times are times where the same \"wall time\" occurs twice, such as during a DST to STD transition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 00:30:00-04:00 | EDT |  Unambiguous\n",
      "2004-10-31 01:30:00-04:00 | EDT |  Ambiguous\n",
      "2004-10-31 01:30:00-05:00 | EST |  Ambiguous\n",
      "2004-10-31 02:30:00-05:00 | EST |  Unambiguous\n"
     ]
    }
   ],
   "source": [
    "dt1 = datetime(2004, 10, 31, 4, 30, tzinfo=UTC)\n",
    "for i in range(4):\n",
    "    dt = (dt1 + timedelta(hours=i)).astimezone(NYC)\n",
    "    print('{} | {} |  {}'.format(dt, dt.tzname(), \n",
    "                                   'Ambiguous' if tz.datetime_ambiguous(dt) else 'Unambiguous'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## PEP-495: Local Time Disambiguation\n",
    "\n",
    "* First introduced in Python 3.6\n",
    "* Introduces the `fold` attribute of `datetime`\n",
    "* Changes to aware datetime comparison around ambiguous times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Whether you are on the fold side is a *property of the datetime*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 01:30:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n",
      "2004-10-31 01:30:00-0500\n",
      "    tzname:   EST;      UTC Offset:  -5.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(datetime(2004, 10, 31, 1, 30, tzinfo=NYC))          # fold=0\n",
    "print_tzinfo(datetime(2004, 10, 31, 1, 30, fold=1, tzinfo=NYC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** `fold=1` represents the *second* instance of an ambiguous datetime\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparing timezone-aware datetimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "dt1 = datetime(2004, 10, 30, 12, 0);   dt1a = datetime(2004, 10, 31, 1, 30)\n",
    "dt2 = datetime(2004, 10, 30, 12, 0);   dt2a = datetime(2004, 10, 31, 1, 30)\n",
    "dt3 = datetime(2004, 10, 30, 11, 0);   dt3a = datetime(2004, 10, 31, 2, 30)   # Unambiguous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Same Zone**: Wall clock times are used, offset *ignored*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-30 12:00:00-04:00 == 2004-10-30 12:00:00-04:00: True</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-30 12:00:00-04:00 == 2004-10-30 11:00:00-04:00: False</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_dt_eq(dt1.replace(tzinfo=NYC), dt2.replace(tzinfo=NYC))   # Unambiguous\n",
    "print_dt_eq(dt1.replace(tzinfo=NYC), dt3.replace(tzinfo=NYC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-31 01:30:00-04:00 == 2004-10-31 01:30:00-04:00: True</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\"><b>2004-10-31 01:30:00-04:00 == 2004-10-31 01:30:00-05:00: True</b></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-31 01:30:00-04:00 == 2004-10-31 02:30:00-05:00: False</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_dt_eq(dt1a.replace(tzinfo=NYC), dt2a.replace(tzinfo=NYC))  # Ambiguous\n",
    "print_dt_eq(dt1a.replace(tzinfo=NYC), dt2a.replace(fold=1, tzinfo=NYC), bold=True)\n",
    "print_dt_eq(dt1a.replace(tzinfo=NYC), dt3a.replace(tzinfo=NYC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Comparing timezone-aware datetimes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* **Different zones**: If both datetimes are unambiguous, the *absolute* times are compared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-30 12:00:00-04:00 == 2004-10-30 12:00:00-05:00: False</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\">2004-10-30 12:00:00-04:00 == 2004-10-30 11:00:00-05:00: True</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_dt_eq(dt1.replace(tzinfo=NYC), dt2.replace(tzinfo=CHI))    # Unambiguous\n",
    "print_dt_eq(dt1.replace(tzinfo=NYC), dt3.replace(tzinfo=CHI))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If *either* datetime is ambiguous, the result is always `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"font-family: monospace\"><b>2004-10-31 01:30:00-05:00 == 2004-10-31 02:30:00-06:00: False</b></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_dt_eq(dt1a.replace(fold=1, tzinfo=NYC), dt3a.replace(tzinfo=CHI), bold=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A curious case..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "LON = gettz('Europe/London')\n",
    "\n",
    "x = datetime(2007, 3, 25, 1, 0, tzinfo=LON)\n",
    "ts = x.timestamp()\n",
    "y = datetime.fromtimestamp(ts, LON)\n",
    "z = datetime.fromtimestamp(ts, gettz.nocache('Europe/London'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y == z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Imaginary Times\n",
    "\n",
    "Imaginary times are wall times that don't exist in a given time zone, such as during an STD to DST transition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 01:30:00-05:00 | EST \n",
      "2004-04-04 03:30:00-04:00 | EDT \n",
      "2004-04-04 04:30:00-04:00 | EDT \n"
     ]
    }
   ],
   "source": [
    "dt1 = datetime(2004, 4, 4, 6, 30, tzinfo=UTC)\n",
    "for i in range(3):\n",
    "    dt = (dt1 + timedelta(hours=i)).astimezone(NYC)\n",
    "    print(f'{dt} | {dt.tzname()} ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2007-03-25 01:00:00+01:00\n"
     ]
    }
   ],
   "source": [
    "print(datetime(2007, 3, 25, 1, 0, tzinfo=LON))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2007-03-25 00:00:00+00:00\n",
      "2007-03-25 02:00:00+01:00\n"
     ]
    }
   ],
   "source": [
    "print(datetime(2007, 3, 25, 0, 0, tzinfo=UTC).astimezone(LON))\n",
    "print(datetime(2007, 3, 25, 1, 0, tzinfo=UTC).astimezone(LON))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Why it was non-transitive\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "LON = gettz('Europe/London')\n",
    "\n",
    "x = datetime(2007, 3, 25, 1, 0, tzinfo=LON)\n",
    "ts = x.timestamp()\n",
    "y = datetime.fromtimestamp(ts, LON)\n",
    "z = datetime.fromtimestamp(ts, gettz.nocache('Europe/London'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x (LON):              2007-03-25 01:00:00+01:00\n",
      "x (UTC):              2007-03-25 00:00:00+00:00\n",
      "x (LON->UTC->LON):    2007-03-25 00:00:00+00:00\n"
     ]
    }
   ],
   "source": [
    "print(f'x (LON):              {x}')\n",
    "print(f'x (UTC):              {x.astimezone(UTC)}')\n",
    "print(f'x (LON->UTC->LON):    {x.astimezone(UTC).astimezone(LON)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y: 2007-03-25 00:00:00+00:00\n",
      "z: 2007-03-25 00:00:00+00:00\n"
     ]
    }
   ],
   "source": [
    "print(f'y: {y}')\n",
    "print(f'z: {z}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 2007-03-25 01:00:00+01:00\n",
      "y: 2007-03-25 00:00:00+00:00\n",
      "z: 2007-03-25 00:00:00+00:00\n"
     ]
    }
   ],
   "source": [
    "print(f'x: {x}')\n",
    "print(f'y: {y}')\n",
    "print(f'z: {z}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.tzinfo is y.tzinfo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.tzinfo is z.tzinfo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Working with time zones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## `dateutil`\n",
    "In `dateutil`'s suite of `tzinfo` objects, you can attach time zones in the constructor if you have a wall time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 14:00:00-0700\n",
      "    tzname:   PDT;      UTC Offset:  -7.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "dt = datetime(2017, 8, 11, 14, tzinfo=tz.gettz('US/Pacific'))\n",
    "print_tzinfo(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you have a naive wall time, or a wall time in another zone that you want to translate without shifting the offset, use `datetime.replace`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 14:00:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(dt.replace(tzinfo=tz.gettz('US/Eastern')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you have an *absolute* time, in UTC or otherwise, use `datetime.astimezone()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 17:00:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(dt.astimezone(tz.gettz('US/Eastern')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `pytz`\n",
    "In `pytz`, `datetime.astimezone()` still works exactly as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 17:00:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(dt.astimezone(pytz.timezone('US/Eastern')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "But the constructor or `.replace` methods fail horribly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 14:00:00-0456\n",
      "    tzname:   LMT;      UTC Offset:  -4.93h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(dt.replace(tzinfo=pytz.timezone('US/Eastern')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# `pytz`'s time zone model\n",
    "\n",
    "* `tzinfo`s are all *static offsets*\n",
    "* `tzinfo` is attached *by the time zone object itself*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-11 14:00:00-0700\n",
      "    tzname:   PDT;      UTC Offset:  -7.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "LOS_p = pytz.timezone('America/Los_Angeles')\n",
    "dt = LOS_p.localize(datetime(2017, 8, 11, 14, 0))\n",
    "print_tzinfo(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You must `normalize()` datetimes after you've done some arithmetic on them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-02-07 14:00:00-0700\n",
      "    tzname:   PDT;      UTC Offset:  -7.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "dt_add = dt + timedelta(days=180)\n",
    "print_tzinfo(dt_add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-02-07 13:00:00-0800\n",
      "    tzname:   PST;      UTC Offset:  -8.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(LOS_p.normalize(dt_add))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is more detail on this on my blog post, [\"`pytz`: The Fastest Footgun in the West\"](https://blog.ganssle.io/articles/2018/03/pytz-fastest-footgun.html) (https://blog.ganssle.io/articles/2018/03/pytz-fastest-footgun.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "fd7b8eb5-ebc6-4905-b222-515e5d474d86"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Handling ambiguous times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "Both `dateutil` and `pytz` will automatically give you the right *absolute time* if converting from an absolute time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datetime.datetime(2004, 10, 31, 1, 30, fold=1, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))\n",
      "2004-10-31 01:30:00-0500\n",
      "    tzname:   EST;      UTC Offset:  -5.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "dt1 = datetime(2004, 10, 31, 6, 30, tzinfo=UTC)  # This is in the fold in EST\n",
    "\n",
    "dt_dateutil = dt1.astimezone(tz.gettz('US/Eastern'))\n",
    "dt_pytz = dt1.astimezone(pytz.timezone('US/Eastern'))\n",
    "print(repr(dt_dateutil))\n",
    "print_tzinfo(dt_dateutil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datetime.datetime(2004, 10, 31, 1, 30, tzinfo=<DstTzInfo 'US/Eastern' EST-1 day, 19:00:00 STD>)\n",
      "2004-10-31 01:30:00-0500\n",
      "    tzname:   EST;      UTC Offset:  -5.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "print(repr(dt_pytz))    # Note that pytz doesn't set fold\n",
    "print_tzinfo(dt_pytz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `dateutil`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For backwards compatibility, `dateutil` provides a `tz.enfold` method to add a `fold` attribute if necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2004, 10, 31, 1, 30, fold=1, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt = datetime(2004, 10, 31, 1, 30, tzinfo=tz.gettz('US/Eastern'))\n",
    "tz.enfold(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "Python 2.7.12\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> from datetime import datetime\n",
    ">>> from dateutil import tz\n",
    ">>> dt = datetime(2004, 10, 31, 1, 30, tzinfo=tz.gettz('US/Eastern'))\n",
    ">>> tz.enfold(dt)\n",
    "_DatetimeWithFold(2004, 10, 31, 1, 30, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))\n",
    ">>> tz.enfold(dt).tzname()\n",
    "'EST'\n",
    ">>> dt.tzname()\n",
    "'EDT'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `dateutil`\n",
    "\n",
    "To detect ambiguous times, `dateutil` provides `tz.datetime_ambiguous`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.datetime_ambiguous(datetime(2004, 10, 31, 1, 30, tzinfo=NYC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.datetime_ambiguous(datetime(2004, 10, 31, 1, 30), NYC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 00:30:00-04:00 (fold=0)\n",
      "2004-10-31 01:30:00-05:00 (fold=1)\n",
      "2004-10-31 02:30:00-05:00 (fold=0)\n"
     ]
    }
   ],
   "source": [
    "dt_0 = datetime(2004, 10, 31, 0, 30, tzinfo=NYC)\n",
    "for i in range(3):\n",
    "    dt_i = dt_0 + timedelta(hours=i)\n",
    "    dt_i = tz.enfold(dt_i, tz.datetime_ambiguous(dt_i))\n",
    "    print(f'{dt_i} (fold={dt_i.fold})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Note:** `fold` is ignored when the `datetime` is not ambiguous:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 00:30:00-04:00 (fold=1)\n",
      "2004-10-31 01:30:00-05:00 (fold=1)\n",
      "2004-10-31 02:30:00-05:00 (fold=1)\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    dt_i = tz.enfold(dt_0 + timedelta(hours=i), fold=1)\n",
    "    print(f'{dt_i} (fold={dt_i.fold})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `pytz`\n",
    "\n",
    "When localizing times, `pytz` defaults to *standard time*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "NYC_pytz = pytz.timezone('America/New_York')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 01:30:00-0500\n",
      "    tzname:   EST;      UTC Offset:  -5.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "dt_pytz = NYC_pytz.localize(datetime(2004, 10, 31, 1, 30))\n",
    "print_tzinfo(dt_pytz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To get a time zone in *daylight time*, pass `is_dst=True` to `localize`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 01:30:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "dt_pytz = NYC_pytz.localize(datetime(2004, 10, 31, 1, 30), is_dst=True)\n",
    "print_tzinfo(dt_pytz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "If `is_dst=None` is passed to `localize`, `pytz` raises an `AmbiguousTimeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-10-31 00:30:00 | Unambiguous\n",
      "2004-10-31 01:30:00 | Ambiguous\n"
     ]
    }
   ],
   "source": [
    "for hour in (0, 1):\n",
    "    dt = datetime(2004, 10, 31, hour, 30)\n",
    "    try:\n",
    "        NYC_pytz.localize(dt, is_dst=None)\n",
    "        print(f'{dt} | Unambiguous')\n",
    "    except pytz.AmbiguousTimeError:\n",
    "        print(f'{dt} | Ambiguous')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Handling imaginary times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `dateutil`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dateutil` provides a `tz.datetime_exists()` function to tell you whether you've constructed an imaginary `datetime`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 01:30:00-05:00 (Exists)\n",
      "2004-04-04 02:30:00-04:00 (Imaginary)\n",
      "2004-04-04 03:30:00-04:00 (Exists)\n"
     ]
    }
   ],
   "source": [
    "dt_0 = datetime(2004, 4, 4, 1, 30, tzinfo=NYC)\n",
    "for i in range(3):\n",
    "    dt = dt_0 + timedelta(hours=i)\n",
    "    print(f'{dt} ({{}})'.format('Exists' if tz.datetime_exists(dt) else 'Imaginary'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `tz.resolve_imaginary`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Generally for imaginary datetimes, you want to \"skip forward\" to what the the time would be if the transition had not happened. In `dateutil` you can use the `tz.resolve_imaginary` function to do this automatically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 03:30:00-04:00\n"
     ]
    }
   ],
   "source": [
    "dt = datetime(2004, 4, 4, 1, 30, tzinfo=NYC)\n",
    "dt_imag = dt + timedelta(hours=1)\n",
    "print(tz.resolve_imaginary(dt_imag))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1994-12-31 09:00:00-10:00 (Imaginary)\n"
     ]
    }
   ],
   "source": [
    "dt = datetime(1994, 12, 31, 9, tzinfo=tz.gettz('Pacific/Kiritimati'))\n",
    "print(f'{dt} ({{}})'.format('Exists' if tz.datetime_exists(dt) else 'Imaginary'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(1995, 1, 1, 9, 0, tzinfo=tzfile('/usr/share/zoneinfo/Pacific/Kiritimati'))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.resolve_imaginary(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both of these functions work with `pytz` time zones as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `pytz`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "When using `localize` on an imaginary datetime, `pytz` will create an imaginary time and use `is_dst` to decide what offset to assign it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 02:30:00-04:00\n",
      "2004-04-04 02:30:00-05:00\n"
     ]
    }
   ],
   "source": [
    "print(NYC_pytz.localize(datetime(2004, 4, 4, 2, 30), is_dst=True))\n",
    "print(NYC_pytz.localize(datetime(2004, 4, 4, 2, 30), is_dst=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "If you have a non-existent date, `normalize()` will slide it forward or backwards, depending on the value passed to `is_dst` (default is `False`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 01:30:00-05:00\n",
      "2004-04-04 03:30:00-04:00\n"
     ]
    }
   ],
   "source": [
    "dt_imag_dst = NYC_pytz.localize(datetime(2004, 4, 4, 2, 30), is_dst=True)\n",
    "dt_imag_std = NYC_pytz.localize(datetime(2004, 4, 4, 2, 30), is_dst=False)\n",
    "\n",
    "print(NYC_pytz.normalize(dt_imag_dst))\n",
    "print(NYC_pytz.normalize(dt_imag_std))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `pytz`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "If you pass `is_dst=None`, `pytz` will throw a `NonExistentTimeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 01:30:00-05:00 (Exists)\n",
      "2004-04-04 01:30:00-05:00 (Imaginary)\n",
      "2004-04-04 03:30:00-04:00 (Exists)\n"
     ]
    }
   ],
   "source": [
    "dt_0 = datetime(2004, 4, 4, 1, 30)\n",
    "for i in range(3):\n",
    "    try:\n",
    "        dt = NYC_pytz.localize(dt_0 + timedelta(hours=i), is_dst=None)\n",
    "        exists = True\n",
    "    except pytz.NonExistentTimeError:\n",
    "        exists = False\n",
    "\n",
    "    print(f'{dt} ({{}})'.format('Exists' if exists else 'Imaginary'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `pytz`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`dateutil.tz.datetime_exists()`  and `dateutil.tz.resolve_imaginary()` work with `pytz` zones, too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:      True\n",
      "Imaginary: False\n"
     ]
    }
   ],
   "source": [
    "dt_pytz_real = NYC_pytz.localize(datetime(2004, 4, 4, 1, 30))\n",
    "dt_pytz_imag = NYC_pytz.localize(datetime(2004, 4, 4, 2, 30))\n",
    "\n",
    "print(f'Real:      {tz.datetime_exists(dt_pytz_real)}')\n",
    "print(f'Imaginary: {tz.datetime_exists(dt_pytz_imag)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 02:30:00-05:00 -> 2004-04-04 02:30:00-05:00\n"
     ]
    }
   ],
   "source": [
    "print(f'{dt_pytz_imag} -> {tz.resolve_imaginary(dt_pytz_imag)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `pytz`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`tz.datetime_exists` will detect non-normalized `datetimes`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 04:30:00-05:00: Imaginary\n"
     ]
    }
   ],
   "source": [
    "dt_nn = dt_pytz_real + timedelta(hours=3)   # Needs to be normalized to DST\n",
    "print('{}: {}'.format(dt_nn, 'Exists' if tz.datetime_exists(dt_nn) else 'Imaginary'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "But `resolve_imaginary` currently only works for standard imaginary datetimes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2004-04-04 04:30:00-05:00 -> 2004-04-04 04:30:00-05:00\n"
     ]
    }
   ],
   "source": [
    "dt_n = tz.resolve_imaginary(dt_nn)\n",
    "print(f'{dt_nn} -> {dt_n}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `dateutil`'s `tzinfo` implementations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## UTC and Static time zones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2014-12-19 22:30:00+0000\n",
      "    tzname:   UTC;      UTC Offset:   0.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "# tz.UTC is equivalent to pytz.UTC or timezone.utc\n",
    "dt = datetime(2014, 12, 19, 22, 30, tzinfo=tz.UTC)\n",
    "print_tzinfo(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Static offsets represent zones with a fixed offset from UTC, and takes a tzname or either number of seconds or a `timedelta`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-17 21:15:00+0900\n",
      "    tzname:   JST;      UTC Offset:   9.00h;        DST:      0.0h\n",
      "2016-07-17 17:45:00+0530\n",
      "    tzname:   IST;      UTC Offset:   5.50h;        DST:      0.0h\n",
      "2016-07-17 07:15:00-0500\n",
      "    tzname:  None;      UTC Offset:  -5.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "JST = tzoffset('JST', 32400)                       # Japan Standard Time is year round\n",
    "IST = tzoffset('IST',                              # India Standard Time is year round\n",
    "               timedelta(hours=5, minutes=30))  \n",
    "EST = tzoffset(None, timedelta(hours=-5))          # Can use None as a name\n",
    "\n",
    "dt = datetime(2016, 7, 17, 12, 15, tzinfo=tzutc())\n",
    "print_tzinfo(dt.astimezone(JST))\n",
    "print_tzinfo(dt.astimezone(IST))\n",
    "print_tzinfo(dt.astimezone(EST))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## UTC and Static time zones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "In Python 3.2, `timezone` objects were introduced to provide ready-made `tzinfo` subclasses for the simple case of static offsets from UTC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2014-12-19 22:30:00+0000\n",
      "    tzname:   UTC;      UTC Offset:   0.00h;        DST:      None\n"
     ]
    }
   ],
   "source": [
    "from datetime import timezone\n",
    "dt = datetime(2014, 12, 19, 22, 30, tzinfo=timezone.utc)     # Equivalent to pytz.UTC or dateutil.tz.UTC\n",
    "print_tzinfo(dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-17 21:15:00+0900\n",
      "    tzname:   JST;      UTC Offset:   9.00h;        DST:      None\n",
      "\n",
      "2016-07-17 17:45:00+0530\n",
      "    tzname:   IST;      UTC Offset:   5.50h;        DST:      None\n",
      "\n",
      "2016-07-17 07:15:00-0500\n",
      "    tzname: UTC-05:00;  UTC Offset:  -5.00h;        DST:      None\n"
     ]
    }
   ],
   "source": [
    "JST = timezone(timedelta(hours=9), 'JST')          # Japan Standard Time is year round\n",
    "IST = timezone(timedelta(hours=5, minutes=30),     # India Standard Time is year round\n",
    "               'IST')  \n",
    "EST = timezone(timedelta(hours=-5))                # Without a name, it's UTC-hh:mm\n",
    "\n",
    "dt = datetime(2016, 7, 17, 12, 15, tzinfo=tz.UTC)\n",
    "print_tzinfo(dt.astimezone(JST)); print()\n",
    "print_tzinfo(dt.astimezone(IST)); print()\n",
    "print_tzinfo(dt.astimezone(EST))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Local time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The `tz.tzlocal()` class is a `tzinfo` implementation that uses the OS hooks in Python's `time`  module to get the local system time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-17 13:15:00+0100\n",
      "    tzname:   BST;      UTC Offset:   1.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "# Temporarily changes the TZ file on *nix systems.\n",
    "from helper_functions import TZEnvContext\n",
    "\n",
    "print_tzinfo(dt.astimezone(tz.tzlocal()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-17 12:15:00+0000\n",
      "    tzname:   UTC;      UTC Offset:   0.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "with TZEnvContext('UTC'):\n",
    "    print_tzinfo(dt.astimezone(tz.tzlocal()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-01-13 04:15:00-0800\n",
      "    tzname:   PST;      UTC Offset:  -8.00h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "with TZEnvContext('PST8PDT'):\n",
    "    print_tzinfo((dt + timedelta(days=180)).astimezone(tz.tzlocal()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Local time: Windows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`tz.win.tzwinlocal()` directly queries the Windows registry for its time zone data and uses that to construct a `tzinfo`.\n",
    "\n",
    "Fixes this bug:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "```python\n",
    ">>> dt = datetime(2014, 2, 11, 17, 0)\n",
    "\n",
    ">>> print(dt.replace(tzinfo=tz.tzlocal()).tzname())\n",
    "Eastern Standard Time\n",
    "\n",
    ">>> print(dt.replace(tzinfo=tz.win.tzwinlocal()).tzname())\n",
    "Eastern Standard Time\n",
    "\n",
    ">>> with TZWinContext('Pacific Standard Time'):\n",
    "...     print(dt.replace(tzinfo=tz.tzlocal()).tzname())\n",
    "...     print(dt.replace(tzinfo=tz.win.tzwinlocal()).tzname())\n",
    "\n",
    "Eastern Standard Time\n",
    "Pacific Standard Time\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## IANA (Olson) database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The `dateutil.tz.tzfile` class provides support for IANA `zoneinfo` binaries (shipped with \\*nix systems).\n",
    "<br/><br/>\n",
    "**DO NOT USE `tz.tzfile` directly** - use `tz.gettz()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tzfile('/usr/share/zoneinfo/America/New_York')"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NYC = tz.gettz('America/New_York')\n",
    "NYC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The IANA database contains *historical* time zone transitions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-08-12 14:00:00-0400\n",
      "    tzname:   EDT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(datetime(2017, 8, 12, 14, tzinfo=NYC))      # Eastern Daylight Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1944-01-06 12:15:00-0400\n",
      "    tzname:   EWT;      UTC Offset:  -4.00h;        DST:      1.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(datetime(1944, 1, 6, 12, 15, tzinfo=NYC))    # Eastern War Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1901-09-06 16:07:00-0456\n",
      "    tzname:   LMT;      UTC Offset:  -4.93h;        DST:      0.0h\n"
     ]
    }
   ],
   "source": [
    "print_tzinfo(datetime(1901, 9, 6, 16, 7, tzinfo=NYC))     # Local solar mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `tz.gettz()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best way to get a time zone is to pass the relevant timezone string to the `gettz()` function, which is intended to be a Python equivalent to the `TZ` environment variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tzfile('/etc/localtime')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.gettz()      # Passing nothing gives you local time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tzlocal()\n"
     ]
    }
   ],
   "source": [
    "# If it finds a valid abbreviation for the local zone, returns tzlocal()\n",
    "with TZEnvContext('LMT4'):\n",
    "    print(gettz('LMT'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tzfile('/usr/share/zoneinfo/Pacific/Kiritimati')\n"
     ]
    }
   ],
   "source": [
    "# Retrieve IANA zone:\n",
    "print(gettz('Pacific/Kiritimati'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## `tz.gettz()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "It can parse more exotic zones like this GNU `TZ` string specification:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tzstr('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3')\n"
     ]
    }
   ],
   "source": [
    "# Directly parse a TZ variable:\n",
    "print(gettz('AEST-10AEDT-11,M10.1.0/2,M4.1.0/3'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "And on Windows it will also accept Windows-style time zone names:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "```python\n",
    ">>> tz.gettz('Eastern Standard Time')\n",
    "tzwin('Eastern Standard Time')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### `tz.gettz()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`gettz` will return the same time zone object for the same input string, unless the cache is bypassed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.gettz('America/New_York') is tz.gettz('America/New_York')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "You can clear the cache with `tz.gettz.cache_clear()`, or get a fresh instance with `tz.gettz.nocache`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tz.gettz('Europe/London') is tz.gettz.nocache('Europe/London')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Timezone Tips"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Civil time vs. Timestamp\n",
    "\n",
    "- Civil times are \"wall times\" - use this when it matters what the clock on the wall says (e.g. meetings, television shows)\n",
    "- Timestamps are specific moments in time: use this when it matters what order things happened in or the duration between two events (e.g. logging, astronomical events)\n",
    "\n",
    "Store civil times as naive portion + time zone serialization (e.g. `America/New_York`). Store timestamps in UTC or equivalent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IANA and CDR\n",
    "- Never rely on a 3-letter abbreviation.\n",
    "- IANA keys are lookups in the tz database\n",
    "- Use Unicode CLDR (Common Locale Data Repository) to get display names for time zones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "f1dc73f9-8745-40ed-b00d-07a740b457f5"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plug\n",
    "\n",
    "<h3>Me</h3>\n",
    "\n",
    "<center> <b>@pganssle</b> / <a href=\"https://ganssle.io\">https://ganssle.io</a> / <a href=\"https://blog.ganssle.io\">https://blog.ganssle.io</a></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dateutil\n",
    "\n",
    "If you're interested in helping out with dateutil development, check out the issues on the github or e-mail me.\n",
    "\n",
    "#### Open Issues - https://github.com/dateutil/dateutil - Check out the [help wanted](https://github.com/dateutil/dateutil/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) label!\n",
    "\n",
    "* [(#76) Add ability to get Olson/POSIX name of a timezone)](https://github.com/dateutil/dateutil/issues/76)\n",
    "* [(#411) Creating a relativedelta instance with floating point value in integer quantity for months or years](https://github.com/dateutil/dateutil/issues/411)\n",
    "* [(#383) Add mypy static type hinting](https://github.com/dateutil/dateutil/issues/383)\n",
    "* [(#691) Add LRU Cache to gettz and factories](https://github.com/dateutil/dateutil/issues/691)\n",
    "* [(#462) tzfile reader only reads 32-bit zoneinfo files](https://github.com/dateutil/dateutil/issues/462)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Bloomberg</h3>\n",
    "\n",
    "<center><b>@TechAtBloomberg</b> - <a href=\"https://www.techatbloomberg.com\">https://www.TechAtBloomberg.com</a></center>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "nbpresent": {
   "slides": {
    "08cbf3b7-09bf-4e2d-a7bb-669bef598000": {
     "id": "08cbf3b7-09bf-4e2d-a7bb-669bef598000",
     "prev": "e66ce0b2-0da8-4e70-b485-bc633ae610b1",
     "regions": {
      "4886cbf0-e3dd-4e82-a981-fa6d3b8e8c7e": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "04d99eed-ab07-47dc-9744-bcb0f0c1cc79",
        "part": "whole"
       },
       "id": "4886cbf0-e3dd-4e82-a981-fa6d3b8e8c7e"
      },
      "4fd83263-2c77-4142-b443-d67c15873a27": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "10a7d89b-3ab4-4174-9469-9130a6633d13",
        "part": "whole"
       },
       "id": "4fd83263-2c77-4142-b443-d67c15873a27"
      },
      "f046a812-85a3-4f5d-a06e-0a2f7113dfb6": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "0960c080-94ec-491c-9054-2ce4800da44e",
        "part": "whole"
       },
       "id": "f046a812-85a3-4f5d-a06e-0a2f7113dfb6"
      },
      "f8172fed-7a45-49b9-a4c7-734c79195fd8": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2c7a7f15-280a-4ca1-8752-5852f2883b0e",
        "part": "whole"
       },
       "id": "f8172fed-7a45-49b9-a4c7-734c79195fd8"
      }
     }
    },
    "2f08fc76-506a-436a-a001-57cd459bc10e": {
     "id": "2f08fc76-506a-436a-a001-57cd459bc10e",
     "prev": "72eab6bc-5c13-48f0-bbdd-55c413e7356c",
     "regions": {
      "32e25f03-3d86-49ad-b4d1-d85dfb16658e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3f0d0a60-76bb-4da1-bd78-422dd3f03aa9",
        "part": "whole"
       },
       "id": "32e25f03-3d86-49ad-b4d1-d85dfb16658e"
      },
      "5839e18b-9098-47b8-bd8a-98935c00e1e5": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "3a9a3ce1-90c6-40e2-ad2a-934079abea25",
        "part": "whole"
       },
       "id": "5839e18b-9098-47b8-bd8a-98935c00e1e5"
      }
     }
    },
    "2f0cb708-e8f5-4bc4-8e52-6d0510cc2f7e": {
     "id": "2f0cb708-e8f5-4bc4-8e52-6d0510cc2f7e",
     "prev": "e2348bdb-3ba2-45f4-ad55-415ed9ff5540",
     "regions": {
      "419de7ca-967b-43cc-a106-ec2945ef5786": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "2f1f753d-37c5-497a-ae5c-0c533ed54e91",
        "part": "whole"
       },
       "id": "419de7ca-967b-43cc-a106-ec2945ef5786"
      },
      "508182a7-bb0f-45d4-bd0e-f3557f567d95": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3f4cd2d0-3b8e-40b3-ba6b-0853c8a8b46e",
        "part": "whole"
       },
       "id": "508182a7-bb0f-45d4-bd0e-f3557f567d95"
      },
      "f55c88ee-fc85-4c09-804f-d48a7b7506e0": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "b26d27b2-1e68-4ba5-8d98-a8141448d9e5",
        "part": "whole"
       },
       "id": "f55c88ee-fc85-4c09-804f-d48a7b7506e0"
      }
     }
    },
    "350a7bd9-42fc-4394-b958-5afe2d830238": {
     "id": "350a7bd9-42fc-4394-b958-5afe2d830238",
     "prev": "4be02312-304d-4f97-928e-5ff23e461620",
     "regions": {
      "3f1464dd-8225-4a40-a95b-2a462269b3ec": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "a611d48a-6bcb-4274-bae3-6d50512fdf09",
        "part": "whole"
       },
       "id": "3f1464dd-8225-4a40-a95b-2a462269b3ec"
      },
      "5f43454d-d4c1-4f03-9c62-e719e2352322": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "34cc706b-ff2f-45b8-ba7b-59b75135c02e",
        "part": "whole"
       },
       "id": "5f43454d-d4c1-4f03-9c62-e719e2352322"
      },
      "603befb3-2674-436e-b07a-27aea83ee9b7": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "dc9b5653-368a-44d0-b35d-748971617072",
        "part": "whole"
       },
       "id": "603befb3-2674-436e-b07a-27aea83ee9b7"
      },
      "67cf9ace-457c-4b98-b291-9718aaa54a9f": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "c851bd48-df5a-4be0-b178-67a8404cbc62",
        "part": "whole"
       },
       "id": "67cf9ace-457c-4b98-b291-9718aaa54a9f"
      },
      "d9ff66ec-d319-4e2f-9073-99aea3073caf": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "60323647-c87d-41cc-b73c-36e97b2907bd",
        "part": "whole"
       },
       "id": "d9ff66ec-d319-4e2f-9073-99aea3073caf"
      }
     }
    },
    "3c973d6a-e9bc-4213-abb0-69a8d748a364": {
     "id": "3c973d6a-e9bc-4213-abb0-69a8d748a364",
     "prev": "08cbf3b7-09bf-4e2d-a7bb-669bef598000",
     "regions": {
      "34acf9a1-ec8f-4d55-a554-b05fce65f9e7": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "da2c8567-4cc4-4e60-be05-9f015217bde4",
        "part": "whole"
       },
       "id": "34acf9a1-ec8f-4d55-a554-b05fce65f9e7"
      },
      "4ac89145-2170-44da-a9c8-38edba56c308": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "5f071bae-78eb-43a4-ae01-5d3e48c59ba9",
        "part": "whole"
       },
       "id": "4ac89145-2170-44da-a9c8-38edba56c308"
      },
      "b78806ae-ae82-4852-8297-7f8f10146dce": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "f88a5291-5045-4a53-bc2d-cad368570417",
        "part": "whole"
       },
       "id": "b78806ae-ae82-4852-8297-7f8f10146dce"
      },
      "c24e3f04-cf7c-437f-ad6a-cca33993bb4d": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "110c0454-5a9c-4754-a379-2f8bbf5387f0",
        "part": "whole"
       },
       "id": "c24e3f04-cf7c-437f-ad6a-cca33993bb4d"
      },
      "f2bf53a8-af82-43b6-9768-47ad9df1abc8": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "a09f3100-3c5c-4e41-ab49-f204406d9727",
        "part": "whole"
       },
       "id": "f2bf53a8-af82-43b6-9768-47ad9df1abc8"
      }
     }
    },
    "3f2767d4-1685-48e2-9396-efb6cbbc61dc": {
     "id": "3f2767d4-1685-48e2-9396-efb6cbbc61dc",
     "prev": "fa8362df-d0d0-4967-b2ce-0bc24b041a7b",
     "regions": {
      "394e691c-6357-4a45-9584-37844ec03621": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "4d00ecb6-3fef-4f2d-be90-3eb3e072be9a",
        "part": "whole"
       },
       "id": "394e691c-6357-4a45-9584-37844ec03621"
      },
      "3f08aa5d-8ea8-4f3f-bab4-68fbe3e8f4e0": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "cda597e6-aed9-478f-9bec-db309fc7cee3",
        "part": "whole"
       },
       "id": "3f08aa5d-8ea8-4f3f-bab4-68fbe3e8f4e0"
      },
      "42c0b288-525b-4aa3-9451-e999a2af27c4": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "0c8084cb-dc2d-445f-b87a-1ee52c5826cb",
        "part": "whole"
       },
       "id": "42c0b288-525b-4aa3-9451-e999a2af27c4"
      },
      "90c7ddab-b5a4-45a0-a18d-03b871cfdb0f": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "b95f0af4-9089-4a02-8173-fc2051d161f6",
        "part": "whole"
       },
       "id": "90c7ddab-b5a4-45a0-a18d-03b871cfdb0f"
      }
     }
    },
    "4be02312-304d-4f97-928e-5ff23e461620": {
     "id": "4be02312-304d-4f97-928e-5ff23e461620",
     "prev": "78715b1e-7d4a-4385-90ee-d04faae5b7ce",
     "regions": {
      "395c9d4f-7c41-42a5-899b-b496a52b6656": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "38713a58-b89e-44f7-9317-82c232b11bb6",
        "part": "whole"
       },
       "id": "395c9d4f-7c41-42a5-899b-b496a52b6656"
      },
      "d5aa9431-911b-402e-bb85-9f3b4f9cde52": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "26b2096e-cf66-4f15-85a7-123f6faebe71",
        "part": "whole"
       },
       "id": "d5aa9431-911b-402e-bb85-9f3b4f9cde52"
      }
     }
    },
    "66da7c99-5473-4fde-abc5-14ff1f24944c": {
     "id": "66da7c99-5473-4fde-abc5-14ff1f24944c",
     "prev": null,
     "regions": {
      "cddc6c40-2f5a-4772-a542-863ce74bcee0": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "8043c60e-9264-43a5-93d5-3f81e76a08e9",
        "part": "whole"
       },
       "id": "cddc6c40-2f5a-4772-a542-863ce74bcee0"
      }
     },
     "theme": null
    },
    "72eab6bc-5c13-48f0-bbdd-55c413e7356c": {
     "id": "72eab6bc-5c13-48f0-bbdd-55c413e7356c",
     "prev": "2f0cb708-e8f5-4bc4-8e52-6d0510cc2f7e",
     "regions": {
      "1c21434a-1960-4afc-a8c7-96827c8101c1": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "3ef7ac4e-85c1-42dc-a24c-c8bd919b02c3",
        "part": "whole"
       },
       "id": "1c21434a-1960-4afc-a8c7-96827c8101c1"
      },
      "227aa851-2359-4f67-8e38-56f78964a3a2": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "917e35fa-a529-4d20-91b8-683a9d7958ad",
        "part": "whole"
       },
       "id": "227aa851-2359-4f67-8e38-56f78964a3a2"
      },
      "784b3013-ba7a-45be-80fd-fafff32e654c": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "33fc71bd-0869-4ee4-ad97-77d17dfe9060",
        "part": "whole"
       },
       "id": "784b3013-ba7a-45be-80fd-fafff32e654c"
      }
     }
    },
    "77c56d86-ac62-441a-b637-c28c416c0f3b": {
     "id": "77c56d86-ac62-441a-b637-c28c416c0f3b",
     "prev": "350a7bd9-42fc-4394-b958-5afe2d830238",
     "regions": {
      "308dd9d6-9ef2-44a9-9be3-bdba35e97b3d": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "59e970ae-5206-4784-a215-497dd643e915",
        "part": "whole"
       },
       "id": "308dd9d6-9ef2-44a9-9be3-bdba35e97b3d"
      },
      "71265642-930c-411b-be49-2e96ef5f99bc": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "10eba1b2-e23e-4a6d-b65b-501be28a364b",
        "part": "whole"
       },
       "id": "71265642-930c-411b-be49-2e96ef5f99bc"
      },
      "b619ae6f-5599-4197-a836-840fcb342956": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "29a0fbc7-b7f2-4421-982c-e7a07f1bde16",
        "part": "whole"
       },
       "id": "b619ae6f-5599-4197-a836-840fcb342956"
      }
     }
    },
    "784b9f54-8d1f-44b3-a3ef-478627ee3d66": {
     "id": "784b9f54-8d1f-44b3-a3ef-478627ee3d66",
     "prev": "dadb12e3-ae58-4c42-b0ea-06373c4a431c",
     "regions": {
      "39a7a53d-fbd5-4d48-bb6b-b61cc2d3fd5b": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "3708d043-1fa9-40dc-b5c2-d87028af4282",
        "part": "whole"
       },
       "id": "39a7a53d-fbd5-4d48-bb6b-b61cc2d3fd5b"
      },
      "4acf35f1-15bf-466a-95f0-5b23c636d8e0": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e48e5499-6521-4dda-9d21-d15ee6642fc0",
        "part": "whole"
       },
       "id": "4acf35f1-15bf-466a-95f0-5b23c636d8e0"
      },
      "95a037ef-83fc-4a0b-8d43-6025c0b2de7c": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "3cebb4b0-5d5f-42b0-97eb-21415802a73c",
        "part": "whole"
       },
       "id": "95a037ef-83fc-4a0b-8d43-6025c0b2de7c"
      },
      "e85a7ad4-36ca-49f6-87ff-20a51cd777cb": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "da5dfe07-74dc-4d06-9294-8c48143fac79",
        "part": "whole"
       },
       "id": "e85a7ad4-36ca-49f6-87ff-20a51cd777cb"
      }
     }
    },
    "78715b1e-7d4a-4385-90ee-d04faae5b7ce": {
     "id": "78715b1e-7d4a-4385-90ee-d04faae5b7ce",
     "prev": "784b9f54-8d1f-44b3-a3ef-478627ee3d66",
     "regions": {
      "121cac40-dd0d-42e0-8354-ff86e9be2c4a": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "05aa375c-84bd-4032-989d-c3dbf618ff9c",
        "part": "whole"
       },
       "id": "121cac40-dd0d-42e0-8354-ff86e9be2c4a"
      },
      "353d960f-eccd-4329-9fe4-1e05fc87d7df": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "c6900de4-08a9-46b1-acc4-8fe534c613f9",
        "part": "whole"
       },
       "id": "353d960f-eccd-4329-9fe4-1e05fc87d7df"
      },
      "97d037ea-837b-48ac-805d-d392246ad489": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "64d92b3d-127c-4ced-964c-f86a93db8487",
        "part": "whole"
       },
       "id": "97d037ea-837b-48ac-805d-d392246ad489"
      },
      "de401a81-2c80-4452-869c-763e261781da": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "dc279304-7d4d-4030-9fb4-ba45a5937d35",
        "part": "whole"
       },
       "id": "de401a81-2c80-4452-869c-763e261781da"
      }
     }
    },
    "809c5d54-cb2b-4ee6-b489-5be655e7f76a": {
     "id": "809c5d54-cb2b-4ee6-b489-5be655e7f76a",
     "prev": "ce512c0b-94ce-43fa-bbc6-3f226d4bbf5a",
     "regions": {
      "2ecffdb9-e84b-4c01-9dff-b3749a4b4af7": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "6e6c3715-7bbe-4842-a007-8b6a410efe24",
        "part": "whole"
       },
       "id": "2ecffdb9-e84b-4c01-9dff-b3749a4b4af7"
      },
      "6a241d03-ae96-43ef-bb10-4e3786697390": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "9cdb3b68-bb7d-4ca5-96c1-cbfd571dcfd0",
        "part": "whole"
       },
       "id": "6a241d03-ae96-43ef-bb10-4e3786697390"
      },
      "ce126b3a-e547-44a5-96c4-20595ead57b1": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "f74d10b8-0fff-463a-afe4-1e944732061c",
        "part": "whole"
       },
       "id": "ce126b3a-e547-44a5-96c4-20595ead57b1"
      },
      "cf10ddc0-4b09-4485-be24-b89051adfa36": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "41a186e7-808d-499a-a6df-7163d743be8b",
        "part": "whole"
       },
       "id": "cf10ddc0-4b09-4485-be24-b89051adfa36"
      },
      "d7569640-ce29-48be-aecb-d8c8a3c09907": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "dc9f19bc-dcc4-443c-b27e-e8c074f0223b",
        "part": "whole"
       },
       "id": "d7569640-ce29-48be-aecb-d8c8a3c09907"
      }
     }
    },
    "b27537c7-1de5-4549-8ab3-8616f123d906": {
     "id": "b27537c7-1de5-4549-8ab3-8616f123d906",
     "prev": "3c973d6a-e9bc-4213-abb0-69a8d748a364",
     "regions": {
      "defdfd03-c438-4b11-9bc7-d70581ff70ec": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "002aa7af-e7f3-4a01-a554-99e1227d79f3",
        "part": "whole"
       },
       "id": "defdfd03-c438-4b11-9bc7-d70581ff70ec"
      }
     }
    },
    "b407c083-3f01-4305-953e-7ba26fd64b5d": {
     "id": "b407c083-3f01-4305-953e-7ba26fd64b5d",
     "prev": "b27537c7-1de5-4549-8ab3-8616f123d906",
     "regions": {
      "71158419-75d5-4a45-82cb-b3a26c161fe3": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f1dc73f9-8745-40ed-b00d-07a740b457f5",
        "part": "whole"
       },
       "id": "71158419-75d5-4a45-82cb-b3a26c161fe3"
      },
      "f22190a5-b3d3-4ba1-bc51-4098d3285f85": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "e29656f8-7417-4f5f-972a-02d4568419c5",
        "part": "whole"
       },
       "id": "f22190a5-b3d3-4ba1-bc51-4098d3285f85"
      }
     }
    },
    "bed18a91-f54c-4106-9447-9dc97d33ace4": {
     "id": "bed18a91-f54c-4106-9447-9dc97d33ace4",
     "prev": "fe3da8de-836b-4889-a4ab-629b26217b67",
     "regions": {
      "d6b7dcb3-bef5-44e8-b74b-c142df5ebba2": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "ae4b457d-959b-41ca-8571-92c70a2dc5a6",
        "part": "whole"
       },
       "id": "d6b7dcb3-bef5-44e8-b74b-c142df5ebba2"
      }
     }
    },
    "c4d2da00-bd89-4407-8579-aa26076c58f0": {
     "id": "c4d2da00-bd89-4407-8579-aa26076c58f0",
     "prev": "ef8678ac-0540-4f50-a0b0-d0896fb4b534",
     "regions": {
      "4fb8e26b-d6f9-4bb1-8d3f-e4bf29be0564": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3a4bb641-60ad-41aa-ba0b-168114f66123",
        "part": "whole"
       },
       "id": "4fb8e26b-d6f9-4bb1-8d3f-e4bf29be0564"
      }
     }
    },
    "ce512c0b-94ce-43fa-bbc6-3f226d4bbf5a": {
     "id": "ce512c0b-94ce-43fa-bbc6-3f226d4bbf5a",
     "prev": "dda4eda5-514d-4280-a559-bd74c8c104c3",
     "regions": {
      "1ca181e6-13b4-4422-ad93-a9fc9ac8000f": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "a9d6971f-f5ae-4b1b-b6e3-e55c8888df85",
        "part": "whole"
       },
       "id": "1ca181e6-13b4-4422-ad93-a9fc9ac8000f"
      },
      "5e0e1839-9110-4d4d-bdd7-dae58e7ebcba": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "6387a7f2-b75f-46c7-9e97-a84cd6d7f572",
        "part": "whole"
       },
       "id": "5e0e1839-9110-4d4d-bdd7-dae58e7ebcba"
      }
     }
    },
    "dadb12e3-ae58-4c42-b0ea-06373c4a431c": {
     "id": "dadb12e3-ae58-4c42-b0ea-06373c4a431c",
     "prev": "2f08fc76-506a-436a-a001-57cd459bc10e",
     "regions": {
      "043ab3da-aef9-416f-b902-5f5fbfe320ba": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "f7b34bd5-c053-4979-8158-2f50748f7675",
        "part": "whole"
       },
       "id": "043ab3da-aef9-416f-b902-5f5fbfe320ba"
      },
      "558f6345-14cb-4521-9730-eef3c0ebc9ca": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "94aaefd8-aab9-4c42-acb2-941a64967264",
        "part": "whole"
       },
       "id": "558f6345-14cb-4521-9730-eef3c0ebc9ca"
      },
      "7ee05790-958f-4c12-aa1c-777e4163b86e": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "a32bed8e-6037-4c04-bcda-421832d9dc56",
        "part": "whole"
       },
       "id": "7ee05790-958f-4c12-aa1c-777e4163b86e"
      },
      "ac119c18-2ded-42e9-be27-af8c465be319": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "2213bd0e-a129-43c6-9a49-7cad724ac2b4",
        "part": "whole"
       },
       "id": "ac119c18-2ded-42e9-be27-af8c465be319"
      },
      "d2720b60-81f1-4455-a5f9-846eac423dfe": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "373921a8-9ede-4197-8cee-b82437f5aa64",
        "part": "whole"
       },
       "id": "d2720b60-81f1-4455-a5f9-846eac423dfe"
      }
     }
    },
    "dda4eda5-514d-4280-a559-bd74c8c104c3": {
     "id": "dda4eda5-514d-4280-a559-bd74c8c104c3",
     "prev": "bed18a91-f54c-4106-9447-9dc97d33ace4",
     "regions": {
      "5d7b4cc1-7f00-4e56-98f8-63505e3c232d": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "265acf8c-7e77-4dc8-8dc2-3b41be08da83",
        "part": "whole"
       },
       "id": "5d7b4cc1-7f00-4e56-98f8-63505e3c232d"
      },
      "88d6daf1-b76a-4514-aae4-cb188ae70178": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "46839b0a-7318-49c4-ba0a-c7990ba40c4f",
        "part": "whole"
       },
       "id": "88d6daf1-b76a-4514-aae4-cb188ae70178"
      },
      "c1f03cf3-d740-44e7-b66c-1bb01c6f957f": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "1b36334e-b088-48a5-9f79-28e8f4c7731d",
        "part": "whole"
       },
       "id": "c1f03cf3-d740-44e7-b66c-1bb01c6f957f"
      }
     }
    },
    "e2348bdb-3ba2-45f4-ad55-415ed9ff5540": {
     "id": "e2348bdb-3ba2-45f4-ad55-415ed9ff5540",
     "prev": "3f2767d4-1685-48e2-9396-efb6cbbc61dc",
     "regions": {
      "26bc2feb-d03f-4ce7-a56c-b468559beb28": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "01c097a1-b040-463f-ad8a-e9ff3617606d",
        "part": "whole"
       },
       "id": "26bc2feb-d03f-4ce7-a56c-b468559beb28"
      },
      "78d57727-7104-482f-a33a-074e9c66acac": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "405a573a-b42f-4099-a9b9-d4004ffc1e6d",
        "part": "whole"
       },
       "id": "78d57727-7104-482f-a33a-074e9c66acac"
      },
      "797af71b-41d3-4c38-bf3b-8442c379594a": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "8586e12f-9d8f-48f5-9dab-8485f02c37ba",
        "part": "whole"
       },
       "id": "797af71b-41d3-4c38-bf3b-8442c379594a"
      },
      "bf310390-8a94-4f60-94dd-77996c2a5100": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "9aeba9ea-b9b8-4713-a361-8b8799bcd827",
        "part": "whole"
       },
       "id": "bf310390-8a94-4f60-94dd-77996c2a5100"
      }
     }
    },
    "e66ce0b2-0da8-4e70-b485-bc633ae610b1": {
     "id": "e66ce0b2-0da8-4e70-b485-bc633ae610b1",
     "prev": "809c5d54-cb2b-4ee6-b489-5be655e7f76a",
     "regions": {
      "371d8de5-99ac-46ff-afe4-d7b84f3cc073": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "c2cfcf5d-ea69-412f-aff1-bab5e240021f",
        "part": "whole"
       },
       "id": "371d8de5-99ac-46ff-afe4-d7b84f3cc073"
      },
      "4a45f51a-7f93-4ab7-8593-839253f38797": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "5347e33d-9387-4805-9422-e670473079a9",
        "part": "whole"
       },
       "id": "4a45f51a-7f93-4ab7-8593-839253f38797"
      },
      "4b5a3b9c-10cb-4fb2-9309-6fde835e50e1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "30022299-75c8-4706-b099-46ecbbd14db4",
        "part": "whole"
       },
       "id": "4b5a3b9c-10cb-4fb2-9309-6fde835e50e1"
      }
     }
    },
    "ef8678ac-0540-4f50-a0b0-d0896fb4b534": {
     "id": "ef8678ac-0540-4f50-a0b0-d0896fb4b534",
     "prev": "66da7c99-5473-4fde-abc5-14ff1f24944c",
     "regions": {
      "6dc08ff2-77cc-4e7b-a9fb-9fdfb46e88a7": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "679a49fa-4450-4ac5-a09b-4c26467bb0cf",
        "part": "whole"
       },
       "id": "6dc08ff2-77cc-4e7b-a9fb-9fdfb46e88a7"
      }
     }
    },
    "fa8362df-d0d0-4967-b2ce-0bc24b041a7b": {
     "id": "fa8362df-d0d0-4967-b2ce-0bc24b041a7b",
     "prev": "c4d2da00-bd89-4407-8579-aa26076c58f0",
     "regions": {
      "353d7ed9-0403-48a9-87d9-97ff19fbe977": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "c03609c2-22d7-453c-87df-4a4822599bfa",
        "part": "whole"
       },
       "id": "353d7ed9-0403-48a9-87d9-97ff19fbe977"
      },
      "4f763f24-d210-441b-a0fa-d293306ce7a7": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "a113b645-8c8d-4a1d-9c6f-eaf5287c3b60",
        "part": "whole"
       },
       "id": "4f763f24-d210-441b-a0fa-d293306ce7a7"
      },
      "f210b6c0-c327-42ca-bd33-e7393490769b": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "c4d89d4b-4241-4506-84b0-aa70f30d974a",
        "part": "whole"
       },
       "id": "f210b6c0-c327-42ca-bd33-e7393490769b"
      },
      "fc00f419-018b-4dd1-b15d-fd5800a850aa": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "6ae7fdb2-21e4-4be3-afc5-005b6a0040e8",
        "part": "whole"
       },
       "id": "fc00f419-018b-4dd1-b15d-fd5800a850aa"
      }
     }
    },
    "fe3da8de-836b-4889-a4ab-629b26217b67": {
     "id": "fe3da8de-836b-4889-a4ab-629b26217b67",
     "prev": "77c56d86-ac62-441a-b637-c28c416c0f3b",
     "regions": {
      "0f12d54b-4c00-4957-a24a-ea9318feed8b": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "571fc88a-3513-4b40-8787-16ab28050fbf",
        "part": "whole"
       },
       "id": "0f12d54b-4c00-4957-a24a-ea9318feed8b"
      },
      "86dff081-6b80-4df6-8ba1-745929dcff74": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "b4670e0f-49da-48a8-bc82-640a954d2f54",
        "part": "whole"
       },
       "id": "86dff081-6b80-4df6-8ba1-745929dcff74"
      }
     }
    }
   },
   "themes": {
    "default": "494ee13b-4963-4ee7-9c53-3d837a60e208",
    "theme": {}
   }
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}