perspective-python 4.2.0__cp311-abi3-win_amd64.whl

perspective/tests/table/test_table_datetime.py

@@ -0,0 +1,2409 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import os
+import time
+from perspective.tests.conftest import Util
+import pytz
+import numpy as np
+import pandas as pd
+from datetime import date, datetime, timedelta
+from dateutil import tz
+from pytest import mark, raises
+from perspective import PerspectiveError
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+LOCAL_DATETIMES = [
+    datetime(2019, 1, 11, 0, 10, 20),
+    datetime(2019, 1, 11, 11, 10, 20),
+    datetime(2019, 1, 11, 19, 10, 20),
+]
+
+LOCAL_DATETIMES_TS = [int(d.timestamp() * 1000) for d in LOCAL_DATETIMES]
+
+# Test the DST transition for Continental US
+LOCAL_DATETIMES_DST = [
+    datetime(2019, 3, 9, 12, 10, 20),
+    datetime(2019, 3, 19, 12, 10, 20),
+    datetime(2019, 11, 2, 12, 10, 20),
+    datetime(2019, 11, 3, 12, 10, 20),
+]
+
+LOCAL_DATETIMES_DST_TS = [int(d.timestamp() * 1000) for d in LOCAL_DATETIMES_DST]
+
+LOCAL_TIMESTAMPS = [pd.Timestamp(d) for d in LOCAL_DATETIMES]
+LOCAL_TIMESTAMPS_DST = [pd.Timestamp(d) for d in LOCAL_DATETIMES_DST]
+
+# Set up testing data
+UTC = pytz.UTC
+
+UTC_DATETIMES = [UTC.localize(d) for d in LOCAL_DATETIMES]
+UTC_TIMESTAMPS = [UTC.localize(d) for d in LOCAL_TIMESTAMPS]
+
+UTC_DATETIMES_DST = [UTC.localize(d, is_dst=True) for d in LOCAL_DATETIMES_DST]
+UTC_TIMESTAMPS_DST = [UTC.localize(d, is_dst=True) for d in LOCAL_TIMESTAMPS_DST]
+
+PST = pytz.timezone("US/Pacific")
+CST = pytz.timezone("US/Central")
+EST = pytz.timezone("US/Eastern")
+GMT = pytz.timezone("GMT")
+HKT = pytz.timezone("Asia/Hong_Kong")
+JPT = pytz.timezone("Asia/Tokyo")
+ACT = pytz.timezone("Australia/ACT")
+
+TIMEZONES = [PST, CST, EST, GMT, HKT, JPT, ACT]
+
+TZ_DATETIMES = {}
+TZ_TIMESTAMPS = {}
+
+TZ_DATETIMES_DST = {}
+TZ_TIMESTAMPS_DST = {}
+
+for TZ in TIMEZONES:
+    TZ_DATETIMES[TZ.zone] = [TZ.localize(d) for d in LOCAL_DATETIMES]
+    TZ_TIMESTAMPS[TZ.zone] = [d.tz_localize(TZ) for d in LOCAL_TIMESTAMPS]
+    TZ_DATETIMES_DST[TZ.zone] = [d.astimezone(TZ) for d in UTC_DATETIMES_DST]
+    TZ_TIMESTAMPS_DST[TZ.zone] = [d.tz_convert(TZ) for d in UTC_TIMESTAMPS_DST]
+
+if os.name != "nt":
+    # no tzset on windows, run these tests on linux/mac only
+
+    class TestTableLocalDateTime(object):
+        """Test datetimes across configurations such as local time, timezone-aware,
+        timezone-naive, and UTC implementations.
+        """
+
+        def setup_method(self):
+            # To make sure that local times are not changed, set timezone to EST
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+        def teardown_method(self):
+            # go back to UTC at end of each test method, for consistency
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+        def test_table_should_assume_local_time(self):
+            """If a datetime object has no `tzinfo`, it should be assumed to be in
+            local time and not be converted at all.
+            """
+            data = {"a": LOCAL_DATETIMES}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_TS
+
+        @mark.skip(reason="no numpy support in JSON Table constructor")
+        def test_table_should_assume_local_time_numpy_datetime64(self):
+            data = {"a": [np.datetime64(d) for d in LOCAL_DATETIMES]}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_TS
+
+        def test_table_should_assume_local_time_pandas_timestamp(self):
+            data = {"a": LOCAL_TIMESTAMPS}
+
+            # Timestamps are assumed to be in UTC by pandas
+            table = Table(data)
+
+            # Timestamps are read out in local time
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_TS
+
+        @mark.skip(reason="no numpy support in JSON Table constructor")
+        def test_table_should_assume_local_time_pandas_timestamp_df(self, util: Util):
+            data = pd.DataFrame({"a": LOCAL_TIMESTAMPS})
+
+            # Timestamps are assumed to be in UTC by pandas
+            table = Table(data)
+
+            # Timestamps are read out in local time
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(2019, 1, 10, 19, 10, 20)),
+                util.to_timestamp(datetime(2019, 1, 11, 6, 10, 20)),
+                util.to_timestamp(datetime(2019, 1, 11, 14, 10, 20)),
+            ]
+
+        def test_table_should_assume_local_time_dst(self):
+            """If a datetime object has no `tzinfo`, it should be assumed to be in
+            local time and not be converted at all.
+            """
+            data = {"a": LOCAL_DATETIMES_DST}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_DST_TS
+
+        @mark.skip(reason="Do not support numpy in JSON constructor")
+        def test_table_should_assume_local_time_numpy_datetime64_dst(self):
+            data = {"a": [np.datetime64(d) for d in LOCAL_DATETIMES_DST]}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_DST_TS
+
+        def test_table_should_assume_local_time_pandas_timestamp_dst(self):
+            data = {"a": LOCAL_TIMESTAMPS_DST}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == LOCAL_DATETIMES_DST_TS
+
+        def test_table_should_assume_local_time_pandas_timestamp_dst_df(self, util):
+            data = pd.DataFrame({"a": LOCAL_TIMESTAMPS_DST})
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(2019, 3, 9, 7, 10, 20)),
+                util.to_timestamp(datetime(2019, 3, 19, 8, 10, 20)),
+                util.to_timestamp(datetime(2019, 11, 2, 8, 10, 20)),
+                util.to_timestamp(datetime(2019, 11, 3, 7, 10, 20)),
+            ]
+
+        @mark.skip(reason="Python specific behavior we don't need")
+        def test_table_datetime_min(self, util):
+            data = {"a": [datetime.min]}
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1969, 12, 31, 19, 0))
+            ]
+
+        @mark.skip(reason="Python specific behavior we don't need")
+        def test_table_datetime_min_df(self, util):
+            data = pd.DataFrame({"a": [datetime.min]})
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1969, 12, 31, 19, 0))
+            ]
+
+        def test_table_datetime_1900(self, util):
+            table = Table({"a": "datetime"})
+            table.update({"a": [util.to_timestamp(datetime(1900, 1, 1))]})
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1900, 1, 1))
+            ]
+
+        def test_table_datetime_1900_df(self, util):
+            data = pd.DataFrame({"a": [datetime(1900, 1, 1)]})
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1899, 12, 31, 19))
+            ]
+
+        def test_table_datetime_1899(self, util: Util):
+            table = Table({"a": "datetime"})
+            table.update({"a": [datetime(1899, 1, 1)]})
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1898, 12, 31, 19))
+            ]
+
+        def test_table_datetime_1899_df(self, util):
+            data = pd.DataFrame({"a": [datetime(1899, 1, 1)]})
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1898, 12, 31, 19))
+            ]
+
+        def test_table_datetime_min_epoch(self, util):
+            data = {"a": [0]}
+            table = Table({"a": "datetime"})
+            table.update(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1969, 12, 31, 19, 0))
+            ]
+
+        def test_table_datetime_cant_convert_from_int(self):
+            data = pd.DataFrame({"a": [0]})
+            table = Table({"a": "datetime"})
+            with raises(PerspectiveError):
+                table.update(data)
+            # assert str(ex.value) == "..."
+
+        @mark.skip(
+            reason="we do not support this conversion, wrote a test above to ensure it fails"
+        )
+        def test_table_datetime_min_epoch_df(self, util):
+            data = pd.DataFrame({"a": [0]})
+            table = Table({"a": "datetime"})
+            table.update(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(1969, 12, 31, 19, 0))
+            ]
+
+        @mark.skip
+        def test_table_datetime_max(self, util):
+            data = {"a": [datetime.max]}
+            table = Table(data)
+
+            # lol - result is converted from UTC to EST (local time)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(9999, 12, 31, 18, 59, 59))
+            ]
+
+        @mark.skip
+        def test_table_datetime_max_df(self, util):
+            data = pd.DataFrame({"a": [datetime.max]})
+            table = Table(data)
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(datetime(9999, 12, 31, 18, 59, 59))
+            ]
+
+    class TestTableDateTimeUTCToLocal(object):
+        def teardown_method(self):
+            # Set timezone to UTC, always
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_should_convert_UTC_to_local_time_pytz_pacific(self):
+            """If the datetime has `tzinfo` set, use it to convert the datetime to
+            UTC. Make sure this works with both `pytz` and `dateutil` for
+            `datetime` and `pandas.Timestamp`.
+            """
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns() == {
+                "a": [d.astimezone(PST).replace(tzinfo=None) for d in data["a"]]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_central(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(CST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_eastern(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(EST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_GMT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(GMT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_HKT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(HKT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_JPT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(JPT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_ACT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(ACT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_pacific(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(PST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_central(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(CST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_eastern(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(EST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_GMT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(GMT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_pacific_DST(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES_DST}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.replace(tzinfo=None))
+                    for d in TZ_DATETIMES_DST["US/Pacific"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_central_DST(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES_DST}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.replace(tzinfo=None))
+                    for d in TZ_DATETIMES_DST["US/Central"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_eastern_DST(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES_DST}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.replace(tzinfo=None))
+                    for d in TZ_DATETIMES_DST["US/Eastern"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_GMT_DST(
+            self, util: Util
+        ):
+            data = {"a": UTC_DATETIMES_DST}
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.replace(tzinfo=None))
+                    for d in TZ_DATETIMES_DST["GMT"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_pacific_DST_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS_DST})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(d.replace(tzinfo=None))
+                for d in TZ_DATETIMES_DST["US/Pacific"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_central_DST_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS_DST})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(d.replace(tzinfo=None))
+                for d in TZ_DATETIMES_DST["US/Central"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_eastern_DST_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS_DST})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(d.replace(tzinfo=None))
+                for d in TZ_DATETIMES_DST["US/Eastern"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_GMT_DST_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS_DST})
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(d.replace(tzinfo=None))
+                for d in TZ_DATETIMES_DST["GMT"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_HKT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(HKT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_JPT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(JPT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_ACT(self, util: Util):
+            data = {"a": UTC_DATETIMES}
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            ACT = tz.gettz("Australia/Sydney")
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(ACT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_UTC_to_local_time_pytz_pacific_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(PST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_central_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(CST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_eastern_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(EST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_GMT_timestamp(self, util):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(GMT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_HKT_timestamp(self, util):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(HKT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_JPT_timestamp(self, util):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(JPT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_pytz_ACT_timestamp(self, util):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(ACT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_pacific_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            # Should be in PST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(PST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_central_timestamp(
+            self,
+            util,
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            CST = tz.gettz("US/Central")
+
+            # Should be in CST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(CST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_eastern_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(EST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_GMT_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            GMT = tz.gettz("GMT")
+
+            # Should be in GMT now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(GMT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_HKT_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(HKT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_JPT_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(JPT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_UTC_to_local_time_dateutil_ACT_timestamp(
+            self, util
+        ):
+            data = pd.DataFrame({"a": UTC_TIMESTAMPS})
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(ACT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+    class TestTableDateTimeArbitaryToLocal(object):
+        def teardown_method(self):
+            # Set timezone to UTC, always
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+        def test_table_should_convert_PST_to_local_time_pytz_central(self, util: Util):
+            data = {"a": TZ_DATETIMES["US/Pacific"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(CST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_CST_to_local_time_pytz_eastern(self, util: Util):
+            data = {"a": TZ_DATETIMES["US/Central"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(EST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_EST_to_local_time_pytz_GMT(self, util: Util):
+            data = {"a": TZ_DATETIMES["US/Eastern"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(GMT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_GMT_to_local_time_pytz_HKT(self, util: Util):
+            data = {"a": TZ_DATETIMES["GMT"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(HKT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_HKT_to_local_time_pytz_JPT(self, util: Util):
+            data = {"a": TZ_DATETIMES["Asia/Hong_Kong"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(JPT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_JPT_to_local_time_pytz_ACT(self, util: Util):
+            data = {"a": TZ_DATETIMES["Asia/Tokyo"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(ACT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_PST_to_local_time_dateutil_central(
+            self, util: Util
+        ):
+            data = {"a": TZ_DATETIMES["US/Pacific"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(CST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_CST_to_local_time_dateutil_eastern(
+            self, util: Util
+        ):
+            data = {"a": TZ_DATETIMES["US/Central"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(EST).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_EST_to_local_time_dateutil_GMT(self, util: Util):
+            data = {"a": TZ_DATETIMES["US/Eastern"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(GMT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_GMT_to_local_time_dateutil_HKT(self, util: Util):
+            data = {"a": TZ_DATETIMES["GMT"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(HKT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_HKT_to_local_time_dateutil_JPT(self, util: Util):
+            data = {"a": TZ_DATETIMES["Asia/Hong_Kong"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(JPT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_JPT_to_local_time_dateutil_ACT(self, util: Util):
+            data = {"a": TZ_DATETIMES["Asia/Tokyo"]}
+            table = Table(data)
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns() == {
+                "a": [
+                    util.to_timestamp(d.astimezone(ACT).replace(tzinfo=None))
+                    for d in data["a"]
+                ]
+            }
+
+        def test_table_should_convert_PST_to_local_time_pytz_central_timestamp(
+            self, util: Util
+        ):
+            data = {"a": TZ_TIMESTAMPS["US/Pacific"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(CST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_CST_to_local_time_pytz_eastern_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["US/Central"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(EST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_EST_to_local_time_pytz_GMT_timestamp(self, util):
+            data = {"a": TZ_TIMESTAMPS["US/Eastern"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(GMT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_GMT_to_local_time_pytz_HKT_timestamp(self, util):
+            data = {"a": TZ_TIMESTAMPS["GMT"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(HKT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_HKT_to_local_time_pytz_JPT_timestamp(self, util):
+            data = {"a": TZ_TIMESTAMPS["Asia/Hong_Kong"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(JPT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_JPT_to_local_time_pytz_ACT_timestamp(self, util):
+            data = {"a": TZ_TIMESTAMPS["Asia/Tokyo"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(ACT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_PST_to_local_time_dateutil_central_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["US/Pacific"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            # Should be in CST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(CST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_CST_to_local_time_dateutil_eastern_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["US/Central"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+            # Should be in EST now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(EST).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_EST_to_local_time_dateutil_GMT_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["US/Eastern"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "GMT"
+            time.tzset()
+
+            # Should be in GMT now
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(GMT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_GMT_to_local_time_dateutil_HKT_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["GMT"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Asia/Hong_Kong"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(HKT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_HKT_to_local_time_dateutil_JPT_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["Asia/Hong_Kong"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Asia/Tokyo"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(JPT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+        def test_table_should_convert_JPT_to_local_time_dateutil_ACT_timestamp(
+            self, util
+        ):
+            data = {"a": TZ_TIMESTAMPS["Asia/Tokyo"]}
+            table = Table(pd.DataFrame(data))
+
+            os.environ["TZ"] = "Australia/Sydney"
+            time.tzset()
+
+            assert table.view().to_columns()["a"] == [
+                util.to_timestamp(
+                    d.astimezone(ACT).replace(tzinfo=None).to_pydatetime()
+                )
+                for d in data["a"]
+            ]
+
+    class TestTableDateTimeRowColumnPaths(object):
+        """Assert correctness of row and column paths in different timezones."""
+
+        def setup_method(self):
+            # To make sure that local times are not changed, set timezone to EST
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+        def teardown_method(self):
+            # Set timezone to UTC, always
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_group_by_datetime_row_path_local_time_EST(self, util: Util):
+            """Make sure that string datetimes generated in Python are in
+            local time and not UTC."""
+            data = {"a": LOCAL_DATETIMES, "b": [i for i in range(len(LOCAL_DATETIMES))]}
+
+            table = Table(data)
+
+            view = table.view(group_by=["a"])
+            assert view.to_columns() == {
+                "__ROW_PATH__": [
+                    [],
+                    [util.to_timestamp(datetime(2019, 1, 11, 0, 10, 20))],
+                    [util.to_timestamp(datetime(2019, 1, 11, 11, 10, 20))],
+                    [util.to_timestamp(datetime(2019, 1, 11, 19, 10, 20))],
+                ],
+                "a": [3, 1, 1, 1],
+                "b": [3, 0, 1, 2],
+            }
+
+        def test_table_group_by_datetime_row_path_UTC(self, util: Util):
+            """Make sure that string datetimes generated in Python are in
+            UTC if the timezone is UTC.
+
+            Set the timezone before creating the table so that the local
+            datetime is in the intended timezone, as this test asserts that
+            paths in the same timezone are not edited to UTC."""
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES, "b": [i for i in range(len(LOCAL_DATETIMES))]}
+
+            table = Table(data)
+
+            view = table.view(group_by=["a"])
+            assert view.to_columns() == {
+                "__ROW_PATH__": [
+                    [],
+                    [util.to_timestamp(datetime(2019, 1, 11, 0, 10, 20))],
+                    [util.to_timestamp(datetime(2019, 1, 11, 11, 10, 20))],
+                    [util.to_timestamp(datetime(2019, 1, 11, 19, 10, 20))],
+                ],
+                "a": [3, 1, 1, 1],
+                "b": [3, 0, 1, 2],
+            }
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_group_by_datetime_row_path_CST(self):
+            """Make sure that string datetimes generated in Python are in
+            CST if the timezone is CST."""
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES, "b": [i for i in range(len(LOCAL_DATETIMES))]}
+
+            table = Table(data)
+
+            view = table.view(group_by=["a"])
+            assert view.to_columns() == {
+                "__ROW_PATH__": [
+                    [],
+                    [datetime(2019, 1, 11, 0, 10, 20)],
+                    [datetime(2019, 1, 11, 11, 10, 20)],
+                    [datetime(2019, 1, 11, 19, 10, 20)],
+                ],
+                "a": [3, 1, 1, 1],
+                "b": [3, 0, 1, 2],
+            }
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_group_by_datetime_row_path_PST(self):
+            """Make sure that string datetimes generated in Python are in
+            CST if the timezone is CST."""
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES, "b": [i for i in range(len(LOCAL_DATETIMES))]}
+
+            table = Table(data)
+
+            view = table.view(group_by=["a"])
+            assert view.to_columns() == {
+                "__ROW_PATH__": [
+                    [],
+                    [datetime(2019, 1, 11, 0, 10, 20)],
+                    [datetime(2019, 1, 11, 11, 10, 20)],
+                    [datetime(2019, 1, 11, 19, 10, 20)],
+                ],
+                "a": [3, 1, 1, 1],
+                "b": [3, 0, 1, 2],
+            }
+
+    class TestTableDateTimeExpressions(object):
+        """Assert correctness of datetime-related expressions in
+        different timezones."""
+
+        def setup_method(self):
+            # To make sure that local times are not changed, set timezone to EST
+            os.environ["TZ"] = "US/Eastern"
+            time.tzset()
+
+        def teardown_method(self):
+            # Set timezone to UTC, always
+            os.environ["TZ"] = "UTC"
+            time.tzset()
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_now_in_EST(self, util):
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            now = datetime.now()
+            view = table.view(expressions=["now()"])
+            result = view.to_columns()
+
+            for item in result["now()"]:
+                in_range = (
+                    now - timedelta(seconds=2) < item < now + timedelta(seconds=2)
+                )
+                assert in_range is True
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_now_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            now = datetime.now()
+            view = table.view(expressions=["now()"])
+            result = view.to_columns()
+
+            for item in result["now()"]:
+                in_range = (
+                    now - timedelta(seconds=2) < item < now + timedelta(seconds=2)
+                )
+                assert in_range is True
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_now_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            now = datetime.now()
+            view = table.view(expressions=["now()"])
+            result = view.to_columns()
+
+            for item in result["now()"]:
+                in_range = (
+                    now - timedelta(seconds=2) < item < now + timedelta(seconds=2)
+                )
+                assert in_range is True
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_hour_of_day_in_EST(self):
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            view = table.view(expressions=['hour_of_day("a")'])
+            result = view.to_columns()
+            assert result['hour_of_day("a")'] == [0, 11, 19]
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_hour_of_day_in_CST(self):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            view = table.view(expressions=['hour_of_day("a")'])
+            result = view.to_columns()
+            assert result['hour_of_day("a")'] == [0, 11, 19]
+
+        @mark.skip(reason="Unsupported non-UTC timezone")
+        def test_table_hour_of_day_in_PST(self):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": LOCAL_DATETIMES}
+
+            table = Table(data)
+            view = table.view(expressions=['hour_of_day("a")'])
+            result = view.to_columns()
+            assert result['hour_of_day("a")'] == [0, 11, 19]
+
+        def test_table_day_of_week_edge_in_EST(self):
+            """Make sure edge cases are fixed for day of week - if a local
+            time converted to UTC is in the next day, the day of week
+            computation needs to be in local time."""
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['day_of_week("a")'])
+            result = view.to_columns()
+            assert result['day_of_week("a")'] == ["6 Friday"]
+
+        def test_table_day_of_week_edge_in_CST(self):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['day_of_week("a")'])
+            result = view.to_columns()
+            assert result['day_of_week("a")'] == ["6 Friday"]
+
+        def test_table_day_of_week_edge_in_PST(self):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['day_of_week("a")'])
+            result = view.to_columns()
+            assert result['day_of_week("a")'] == ["6 Friday"]
+
+        def test_table_month_of_year_edge_in_EST(self):
+            """Make sure edge cases are fixed for month of year - if a local
+            time converted to UTC is in the next month, the month of year
+            computation needs to be in local time."""
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['month_of_year("a")'])
+            result = view.to_columns()
+            assert result['month_of_year("a")'] == ["01 January"]
+
+        def test_table_month_of_year_edge_in_CST(self):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['month_of_year("a")'])
+            result = view.to_columns()
+            assert result['month_of_year("a")'] == ["01 January"]
+
+        def test_table_month_of_year_edge_in_PST(self):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=['month_of_year("a")'])
+            result = view.to_columns()
+            assert result['month_of_year("a")'] == ["01 January"]
+
+        def test_table_day_bucket_edge_in_EST(self, util):
+            """Make sure edge cases are fixed for day_bucket - if a local
+            time converted to UTC is in the next day, the day_bucket
+            computation needs to be in local time."""
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'D')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'D')"] == [
+                util.to_timestamp(datetime(2020, 1, 31))
+            ]
+
+        def test_table_day_bucket_edge_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'D')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'D')"] == [
+                util.to_timestamp(datetime(2020, 1, 31))
+            ]
+
+        def test_table_day_bucket_edge_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 1, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'D')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'D')"] == [
+                util.to_timestamp(datetime(2020, 1, 31))
+            ]
+
+        def test_table_week_bucket_edge_in_EST(self, util):
+            """Make sure edge cases are fixed for week_bucket - if a local
+            time converted to UTC is in the next day, the week_bucket
+            computation needs to be in local time."""
+            data = {"a": [datetime(2020, 2, 2, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 1, 27))
+            ]
+
+        def test_table_week_bucket_edge_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 2, 2, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 1, 27))
+            ]
+
+        def test_table_week_bucket_edge_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 2, 2, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 1, 27))
+            ]
+
+        def test_table_week_bucket_edge_flip_in_EST(self, util):
+            """Week bucket should flip backwards to last month."""
+            data = {"a": [datetime(2020, 3, 1, 12, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 2, 24))
+            ]
+
+        def test_table_week_bucket_edge_flip_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+            data = {"a": [datetime(2020, 3, 1, 12, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 2, 24))
+            ]
+
+        def test_table_week_bucket_edge_flip_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+            data = {"a": [datetime(2020, 3, 1, 12, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'W')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'W')"] == [
+                util.to_timestamp(datetime(2020, 2, 24))
+            ]
+
+        def test_table_month_bucket_edge_in_EST(self, util):
+            """Make sure edge cases are fixed for month_bucket - if a local
+            time converted to UTC is in the next day, the month_bucket
+            computation needs to be in local time."""
+            data = {"a": [datetime(2020, 6, 30, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'M')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'M')"] == [
+                util.to_timestamp(datetime(2020, 6, 1))
+            ]
+
+        def test_table_month_bucket_edge_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 6, 30, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'M')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'M')"] == [
+                util.to_timestamp(datetime(2020, 6, 1))
+            ]
+
+        def test_table_month_bucket_edge_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+
+            data = {"a": [datetime(2020, 6, 30, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'M')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'M')"] == [
+                util.to_timestamp(datetime(2020, 6, 1))
+            ]
+
+        def test_table_year_bucket_edge_in_EST(self, util):
+            """Make sure edge cases are fixed for year_bucket - if a local
+            time converted to UTC is in the next day, the year_bucket
+            computation needs to be in local time."""
+            data = {"a": [datetime(2019, 12, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'Y')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'Y')"] == [
+                util.to_timestamp(datetime(2019, 1, 1))
+            ]
+
+        def test_table_year_bucket_edge_in_CST(self, util):
+            os.environ["TZ"] = "US/Central"
+            time.tzset()
+            data = {"a": [datetime(2019, 12, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'Y')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'Y')"] == [
+                util.to_timestamp(datetime(2019, 1, 1))
+            ]
+
+        def test_table_year_bucket_edge_in_PST(self, util):
+            os.environ["TZ"] = "US/Pacific"
+            time.tzset()
+            data = {"a": [datetime(2019, 12, 31, 23, 59)]}
+
+            table = Table(data)
+            view = table.view(expressions=["bucket(\"a\", 'Y')"])
+            result = view.to_columns()
+            assert result["bucket(\"a\", 'Y')"] == [
+                util.to_timestamp(datetime(2019, 1, 1))
+            ]
+
+
+class TestTableDateTimePivots(object):
+    def test_table_group_by_date_correct(self, util: Util):
+        data = {
+            "a": [date(2020, i, 15) for i in range(1, 13)],
+            "b": [i for i in range(1, 13)],
+        }
+        table = Table(data)
+        view = table.view(group_by=["a"])
+        assert view.to_columns() == {
+            "__ROW_PATH__": [
+                [],
+                [util.to_timestamp(datetime(2020, 1, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 2, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 3, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 4, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 5, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 6, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 7, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 8, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 9, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 10, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 11, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 12, 15, 0, 0))],
+            ],
+            "a": [12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            "b": [78, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+        }
+
+    def test_table_group_by_pandas_date_correct(self, util: Util):
+        data = {
+            "a": [date(2020, i, 15) for i in range(1, 13)],
+            "b": [i for i in range(1, 13)],
+        }
+        table = Table(pd.DataFrame(data))
+        view = table.view(group_by=["a"])
+        assert view.to_columns() == {
+            "__ROW_PATH__": [
+                [],
+                [util.to_timestamp(datetime(2020, 1, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 2, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 3, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 4, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 5, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 6, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 7, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 8, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 9, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 10, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 11, 15, 0, 0))],
+                [util.to_timestamp(datetime(2020, 12, 15, 0, 0))],
+            ],
+            "index": [66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+            "a": [12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            "b": [78, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+        }
+
+    def test_table_split_by_date_correct(self, util: Util):
+        data = {
+            "a": [date(2020, i, 15) for i in range(1, 13)],
+            "b": [i for i in range(1, 13)],
+        }
+        table = Table(data)
+        view = table.view(split_by=["a"])
+        assert view.to_columns() == {
+            "2020-01-15|a": [
+                util.to_timestamp(datetime(2020, 1, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-01-15|b": [
+                1,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-02-15|a": [
+                None,
+                util.to_timestamp(datetime(2020, 2, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-02-15|b": [
+                None,
+                2,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-03-15|a": [
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 3, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-03-15|b": [
+                None,
+                None,
+                3,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-04-15|a": [
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 4, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-04-15|b": [
+                None,
+                None,
+                None,
+                4,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-05-15|a": [
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 5, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-05-15|b": [
+                None,
+                None,
+                None,
+                None,
+                5,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-06-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 6, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-06-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                6,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-07-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 7, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-07-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                7,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-08-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 8, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-08-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                8,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-09-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 9, 15, 0, 0)),
+                None,
+                None,
+                None,
+            ],
+            "2020-09-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                9,
+                None,
+                None,
+                None,
+            ],
+            "2020-10-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 10, 15, 0, 0)),
+                None,
+                None,
+            ],
+            "2020-10-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                10,
+                None,
+                None,
+            ],
+            "2020-11-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 11, 15, 0, 0)),
+                None,
+            ],
+            "2020-11-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                11,
+                None,
+            ],
+            "2020-12-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 12, 15, 0, 0)),
+            ],
+            "2020-12-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                12,
+            ],
+        }
+
+    def test_table_split_by_pandas_date_correct(self, util: Util):
+        data = {
+            "a": [date(2020, i, 15) for i in range(1, 13)],
+            "b": [i for i in range(1, 13)],
+        }
+        table = Table(pd.DataFrame(data))
+        view = table.view(columns=["a", "b"], split_by=["a"])
+        print(f"XXXX: {view.to_columns()}")
+        assert view.to_columns() == {
+            "2020-01-15|a": [
+                util.to_timestamp(datetime(2020, 1, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-01-15|b": [
+                1,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-02-15|a": [
+                None,
+                util.to_timestamp(datetime(2020, 2, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-02-15|b": [
+                None,
+                2,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-03-15|a": [
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 3, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-03-15|b": [
+                None,
+                None,
+                3,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-04-15|a": [
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 4, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-04-15|b": [
+                None,
+                None,
+                None,
+                4,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-05-15|a": [
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 5, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-05-15|b": [
+                None,
+                None,
+                None,
+                None,
+                5,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-06-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 6, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-06-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                6,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-07-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 7, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-07-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                7,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-08-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 8, 15, 0, 0)),
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-08-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                8,
+                None,
+                None,
+                None,
+                None,
+            ],
+            "2020-09-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 9, 15, 0, 0)),
+                None,
+                None,
+                None,
+            ],
+            "2020-09-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                9,
+                None,
+                None,
+                None,
+            ],
+            "2020-10-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 10, 15, 0, 0)),
+                None,
+                None,
+            ],
+            "2020-10-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                10,
+                None,
+                None,
+            ],
+            "2020-11-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 11, 15, 0, 0)),
+                None,
+            ],
+            "2020-11-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                11,
+                None,
+            ],
+            "2020-12-15|a": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                util.to_timestamp(datetime(2020, 12, 15, 0, 0)),
+            ],
+            "2020-12-15|b": [
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                12,
+            ],
+        }