Exemple #1
0
    def test_tssdict_combine(self):
        """
        A batch of tests combining columns to one timeseries.

        Tests check to see whether the parameters are passed down properly to
        each timeseries.
        """

        # combine(self, discard=True, pad=None)
        ts_new, _ = self.tssdict.combine(discard=True, pad=None)

        # shape corresponds to the shortest length
        self.assertEqual(
            ts_new.tseries.shape[0], self.ts_short.tseries.shape[0]
        )

        self.assertEqual(ts_new.tseries.shape[1], 3)

        # combine(self, discard=False, pad=0)
        ts_new, _ = self.tssdict.combine(discard=False, pad=0)

        # shape corresponds to the longest length
        self.assertEqual(
            ts_new.tseries.shape[0], self.ts_long.tseries.shape[0]
        )

        self.assertEqual(ts_new.tseries.shape[1], 3)

        # test with TssList
        tmp_ts0 = Timeseries()
        tmp_ts0.key = "First"

        tmp_ts0.dseries = datetime(2014, 12, 31).toordinal() - np.arange(10)
        tmp_ts0.tseries = np.arange(10)
        tmp_ts0.make_arrays()

        tmp_ts1 = Timeseries()
        tmp_ts1.key = "Second"

        tmp_ts1.dseries = datetime(2014, 12, 31).toordinal() - np.arange(10)
        tmp_ts1.tseries = np.arange(10)
        tmp_ts1.make_arrays()

        tssdict = TssDict(TssList([tmp_ts0, tmp_ts1]))

        ts, _ = tssdict.combine()

        self.assertTupleEqual(ts.tseries.shape, (10, 2))

        # test with TssDict
        tssdict = TssDict(TssDict([tmp_ts0, tmp_ts1]))

        ts, _ = tssdict.combine()
        self.assertTupleEqual(ts.tseries.shape, (10, 2))
Exemple #2
0
    def test_tssdict_min_date(self):
        """Tests min date """

        # First add a timeseries that is earlier than the others
        tmp_ts0 = Timeseries()
        tmp_ts0.key = "First"

        tmp_ts0.dseries = datetime(2014, 12, 31).toordinal() - np.arange(10)
        tmp_ts0.tseries = np.arange(10)
        tmp_ts0.make_arrays()

        self.tssdict[tmp_ts0.key] = tmp_ts0

        self.assertTupleEqual(
            self.tssdict.min_date(), (date(2014, 12, 22), "First")
        )

        tmp_nodata = Timeseries()
        tmp_nodata.key = "nothing"
        tssdict = TssDict()
        tssdict[tmp_nodata.key] = tmp_nodata

        self.assertTupleEqual(tssdict.min_date(), (None, "nothing"))

        tssdict = TssDict()

        # none timeseries list
        tssdict["test"] = [
            date(2014, 12, 31) + timedelta(days=i) for i in range(10)
        ]
        tssdict["test1"] = [
            date(2013, 12, 31) + timedelta(days=i) for i in range(10)
        ]
        self.assertRaises(ValueError, tssdict.min_date)
Exemple #3
0
    def test_timeseries_extend(self):
        """Tests adding rows to a timeseries."""

        # create overlapping timeseries
        ts = Timeseries()
        start_date = datetime(2016, 1, 5).toordinal()
        ts.dseries = start_date + np.arange(10)
        ts.tseries = np.arange(10, 20)
        ts.make_arrays()

        ts_copy = self.ts.clone()

        self.assertRaises(ValueError, self.ts.extend, ts, overlay=False)

        # [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
        #
        #                     [ 10. 11. 12. 13. 14. 15.  16.  17.  18.  19.]

        ts_copy.extend(ts, overlay=True)

        self.assertEqual(ts_copy.tseries[4], 4)
        self.assertEqual(ts_copy.tseries[5], 10)
        self.assertEqual(ts_copy.tseries[6], 11)
        self.assertEqual(ts_copy.tseries[7], 12)
        self.assertEqual(ts_copy.tseries[8], 13)
        self.assertEqual(ts_copy.tseries[9], 14)
        self.assertEqual(ts_copy.tseries[10], 15)
        self.assertEqual(ts_copy.tseries[11], 16)
Exemple #4
0
    def test_timeseries_start_date(self):
        """Tests start date regardless of date sorts and types."""
        # get as ordinal
        self.assertEqual(self.ts.dseries[0], self.ts.start_date())

        # reverse - now new to old
        self.ts.reverse()
        self.assertEqual(self.ts.dseries[-1], self.ts.start_date())

        # get as datetime from ordinal
        self.assertEqual(date(2015, 12, 31), self.ts.start_date("datetime"))

        # get as timestamp
        ts = Timeseries(frequency="sec")

        self.assertEqual("timestamp", ts.get_date_series_type())

        ts.dseries = datetime(2015, 12, 31).timestamp() + np.arange(10)
        ts.tseries = np.arange(10)

        self.assertEqual(ts.dseries[0], ts.start_date())

        # reverse - now new to old
        ts.reverse()
        self.assertEqual(ts.dseries[-1], ts.start_date())

        # get as datetime from timestamp
        self.assertEqual(date(2015, 12, 31), self.ts.start_date("datetime"))

        # string date
        self.assertEqual(self.ts.start_date("str"), "2015-12-31")

        # bad format
        self.assertRaises(ValueError, self.ts.start_date, "bad")
Exemple #5
0
    def test_date_string_series(self):
        """Tests returning a list of dates in string format."""

        # ordinal default fmt
        str_series = self.ts.date_string_series()

        self.assertEqual(str_series[0], "2015-12-31")
        self.assertEqual(str_series[1], "2016-01-01")
        self.assertEqual(str_series[2], "2016-01-02")
        self.assertEqual(str_series[3], "2016-01-03")
        self.assertEqual(str_series[4], "2016-01-04")

        # timestamp default fmt
        ts = Timeseries(frequency="sec")

        ts.dseries = datetime(2016, 1, 1, 0, 0, 0).timestamp() + np.arange(10)
        ts.tseries = np.arange(10)
        ts.make_arrays()

        str_series = ts.date_string_series()

        self.assertEqual(str_series[0], "2016-01-01 00:00:00")
        self.assertEqual(str_series[1], "2016-01-01 00:00:01")
        self.assertEqual(str_series[2], "2016-01-01 00:00:02")
        self.assertEqual(str_series[3], "2016-01-01 00:00:03")
        self.assertEqual(str_series[4], "2016-01-01 00:00:04")

        # ordinal custom fmt
        str_series = self.ts.date_string_series("%Y-%b-%d")

        self.assertEqual(str_series[0], "2015-Dec-31")
        self.assertEqual(str_series[1], "2016-Jan-01")
        self.assertEqual(str_series[2], "2016-Jan-02")
        self.assertEqual(str_series[3], "2016-Jan-03")
        self.assertEqual(str_series[4], "2016-Jan-04")
Exemple #6
0
    def test_timeseries_daterange(self):
        """Tests returning the starting and ending dates in various formats."""
        # ordinal daterange as ordinals,
        self.assertTupleEqual(
            self.ts.daterange(),
            (
                datetime(2015, 12, 31).toordinal(),
                datetime(2016, 1, 9).toordinal(),
            ),
        )

        # ordinal daterange as string
        self.assertTupleEqual(self.ts.daterange("str"),
                              ("2015-12-31", "2016-01-09"))

        # ordinal daterange as datetimes
        self.assertTupleEqual(
            self.ts.daterange("datetime"),
            (date(2015, 12, 31), date(2016, 1, 9)),
        )

        # timestamp
        tstamp_list = datetime(2016, 1, 1).timestamp() + np.arange(20)

        ts = Timeseries()
        ts.frequency = FREQ_SEC
        ts.dseries = tstamp_list
        ts.tseries = np.arange(20)

        # timestamp daterange as timestamps
        self.assertTupleEqual(
            ts.daterange(),
            (
                datetime(2016, 1, 1).timestamp(),
                datetime(2016, 1, 1, 0, 0, 19).timestamp(),
            ),
        )

        # timestamp daterange as string
        self.assertTupleEqual(
            ts.daterange("str"),
            ("2016-01-01 00:00:00", "2016-01-01 00:00:19"),
        )

        # timestamp daterange as datetimes
        self.assertTupleEqual(
            ts.daterange("datetime"),
            (
                datetime(2016, 1, 1, 0, 0, 0),
                datetime(2016, 1, 1, 0, 0, 19),
            ),
        )

        # test blank Timeseries
        ts = Timeseries()
        self.assertTupleEqual(ts.daterange(), (None, None))

        # test invalid format flag
        self.assertRaises(ValueError, self.ts.daterange, fmt="wrong")
Exemple #7
0
    def test_timeseries_get_duped_dates(self):
        """Test the dupes works properly."""
        ts = self.ts.clone()

        ts.dseries[3] = ts.dseries[4]

        ts = Timeseries(frequency="sec")

        ts.dseries = datetime(2015, 12, 31).timestamp() + np.arange(10)
        ts.tseries = np.arange(10)
        ts.make_arrays()

        ts.dseries[3] = ts.dseries[4]
Exemple #8
0
    def test_timeseries_get_datetime(self):
        """Tests conversion to datetime from ordinal/timestamps"""

        tmp_date = self.ts.start_date()

        self.assertEqual(date(2015, 12, 31), self.ts.get_datetime(tmp_date))

        ts = Timeseries(frequency="sec")

        ts.dseries = datetime(2015, 12, 31).timestamp() + np.arange(10)
        ts.tseries = np.arange(10)

        tmp_date = self.ts.start_date()
        self.assertEqual(date(2015, 12, 31), self.ts.get_datetime(tmp_date))
Exemple #9
0
    def test_timeseries_datetime_series(self):
        """ Tests returning a date series converted to date/datetime objects. """

        ord_list = datetime(2016, 1, 1).toordinal() + np.arange(20)
        tstamp_list = datetime(2016, 1, 1).timestamp() + np.arange(20)

        ts = Timeseries()
        ts.dseries = ord_list
        ts.tseries = np.arange(20)  # gilding the lily

        dt_list = [date(2016, 1, 1) + timedelta(days=i) for i in range(20)]

        self.assertListEqual(ts.datetime_series(), dt_list)

        ts.frequency = FREQ_SEC
        ts.dseries = tstamp_list
        ts.tseries = np.arange(20)

        dt_list = [
            datetime(2016, 1, 1) + timedelta(seconds=i) for i in range(20)
        ]

        self.assertListEqual(ts.datetime_series(), dt_list)
Exemple #10
0
    def test_timeseries_closest_date(self):
        """Tests returning the closest date in the series to the input date."""

        ts = Timeseries()
        ts.dseries = []
        ts.tseries = []

        start_date = datetime(2015, 12, 31)
        for i in range(40):
            date = start_date + timedelta(days=i)
            if date.weekday() not in [5, 6]:

                ts.dseries.append(date.toordinal())
                ts.tseries.append(i)

        ts.make_arrays()

        date1 = datetime(2016, 1, 7)  # existing date within date series
        date2 = datetime(2016, 1, 16)  # date falling on a weekend
        date3 = datetime(2015, 6, 16)  # date prior to start of date series
        date4 = datetime(2016, 3, 8)  # date after to end of date series

        # as datetime and in the series
        test_date = ts.closest_date(rowdate=date1, closest=1)
        self.assertEqual(test_date, date1.toordinal())

        # as ordinal and in the series
        test_date = ts.closest_date(rowdate=date1, closest=1)
        self.assertEqual(test_date, date1.toordinal())

        # as datetime but date not in series
        test_date = ts.closest_date(rowdate=date2, closest=1)
        self.assertEqual(test_date, datetime(2016, 1, 18).toordinal())

        test_date = ts.closest_date(rowdate=date2, closest=-1)
        self.assertEqual(test_date, datetime(2016, 1, 15).toordinal())

        # as datetime but date not in series, look for earlier date
        self.assertRaises(ValueError,
                          ts.closest_date,
                          rowdate=date3,
                          closest=-1)

        # as datetime but date not in series, look for later date
        self.assertRaises(ValueError,
                          ts.closest_date,
                          rowdate=date4,
                          closest=1)
Exemple #11
0
    def test_timeseries_years(self):
        """Tests returning the ending values by years in a dict."""

        ts = Timeseries()
        ts.dseries = datetime(2015, 12, 31).toordinal() + np.arange(1000)
        ts.tseries = np.arange(1000)

        self.assertDictEqual(
            ts.years(),
            {
                2015: 0,
                2016: 366,
                2017: 731,
                2018: 999,
            },
        )
Exemple #12
0
    def test_convert(self):
        """
        This function is a pass-through to the convert function.

        This version basically checks to see if the plumbing works. However,
        until the design decision is made on how to transition from intraday
        to monthly, etc., this cannot be considered complete.

        """

        ts = Timeseries()

        ts.dseries = datetime(2015, 12, 31).toordinal() + np.arange(1000)
        ts.tseries = np.arange(1000)

        ts_monthly = ts.convert(new_freq=FREQ_M, include_partial=True)

        self.assertEqual(ts_monthly.dseries[0], 735963)
        self.assertEqual(ts_monthly.dseries[1], 735994)
        self.assertEqual(ts_monthly.dseries[2], 736023)
        self.assertEqual(ts_monthly.dseries[3], 736054)
        self.assertEqual(ts_monthly.dseries[4], 736084)
        self.assertEqual(ts_monthly.dseries[5], 736115)
        self.assertEqual(ts_monthly.dseries[6], 736145)
        self.assertEqual(ts_monthly.dseries[7], 736176)
        self.assertEqual(ts_monthly.dseries[8], 736207)
        self.assertEqual(ts_monthly.dseries[9], 736237)

        self.assertEqual(ts_monthly.tseries[0], 0)
        self.assertEqual(ts_monthly.tseries[1], 31)
        self.assertEqual(ts_monthly.tseries[2], 60)
        self.assertEqual(ts_monthly.tseries[3], 91)
        self.assertEqual(ts_monthly.tseries[4], 121)
        self.assertEqual(ts_monthly.tseries[5], 152)
        self.assertEqual(ts_monthly.tseries[6], 182)
        self.assertEqual(ts_monthly.tseries[7], 213)
        self.assertEqual(ts_monthly.tseries[8], 244)
        self.assertEqual(ts_monthly.tseries[9], 274)

        self.assertEqual(ts_monthly.dseries[-1], 736962)
        self.assertEqual(ts_monthly.tseries[-1], 999)

        # bad frequency
        self.assertRaises(ValueError,
                          ts.convert,
                          new_freq="bad",
                          include_partial=True)
Exemple #13
0
    def test_timeseries_months(self):
        """Tests returning the ending values by months in a dict."""
        ts = Timeseries()
        ts.dseries = datetime(2015, 12, 31).toordinal() + np.arange(1000)
        ts.tseries = np.arange(1000)

        self.assertDictEqual(
            ts.months(),
            {
                "2015-12": 0,
                "2016-01": 31,
                "2016-02": 60,
                "2016-03": 91,
                "2016-04": 121,
                "2016-05": 152,
                "2016-06": 182,
                "2016-07": 213,
                "2016-08": 244,
                "2016-09": 274,
                "2016-10": 305,
                "2016-11": 335,
                "2016-12": 366,
                "2017-01": 397,
                "2017-02": 425,
                "2017-03": 456,
                "2017-04": 486,
                "2017-05": 517,
                "2017-06": 547,
                "2017-07": 578,
                "2017-08": 609,
                "2017-09": 639,
                "2017-10": 670,
                "2017-11": 700,
                "2017-12": 731,
                "2018-01": 762,
                "2018-02": 790,
                "2018-03": 821,
                "2018-04": 851,
                "2018-05": 882,
                "2018-06": 912,
                "2018-07": 943,
                "2018-08": 974,
                "2018-09": 999,
            },
        )
Exemple #14
0
    def test_timeseries_row_no(self):
        """ Tests the ability to locate the correct row. """
        ts = Timeseries()
        ts.dseries = []
        ts.tseries = []

        start_date = datetime(2015, 12, 31)
        for i in range(40):
            date = start_date + timedelta(days=i)
            if date.weekday() not in [5, 6]:

                ts.dseries.append(date.toordinal())
                ts.tseries.append(i)

        ts.make_arrays()

        date1 = datetime(2016, 1, 7)  # existing date within date series
        date2 = datetime(2016, 1, 16)  # date falling on a weekend
        date3 = datetime(2015, 6, 16)  # date prior to start of date series
        date4 = datetime(2016, 3, 8)  # date after to end of date series

        # as datetime
        row_no = ts.row_no(rowdate=date1, closest=0, no_error=False)
        self.assertEqual(row_no, 5)

        # as ordinal
        row_no = ts.row_no(rowdate=date1.toordinal(),
                           closest=0,
                           no_error=False)
        self.assertEqual(row_no, 5)

        # as datetime but date not in series
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date2,
            closest=0,
            no_error=False,
        )

        row_no = ts.row_no(rowdate=date2, closest=0, no_error=True)
        self.assertEqual(row_no, -1)

        # as datetime but date not in series, look for earlier date
        row_no = ts.row_no(rowdate=date2, closest=-1, no_error=False)
        self.assertEqual(row_no, 11)

        # as datetime but date not in series, look for later date
        row_no = ts.row_no(rowdate=date2, closest=1, no_error=False)
        self.assertEqual(row_no, 12)

        # as datetime but date not in series, look for earlier date
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date3,
            closest=-1,
            no_error=False,
        )

        # as datetime but date not in series, look for later date
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date4,
            closest=1,
            no_error=False,
        )

        # now change series direction
        ts.reverse()

        # as datetime
        row_no = ts.row_no(rowdate=date1, closest=0, no_error=False)
        self.assertEqual(row_no, 22)

        # as ordinal
        row_no = ts.row_no(rowdate=date1.toordinal(),
                           closest=0,
                           no_error=False)
        self.assertEqual(row_no, 22)

        # as datetime but date not in series
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date2,
            closest=0,
            no_error=False,
        )

        row_no = ts.row_no(rowdate=date2, closest=0, no_error=True)
        self.assertEqual(row_no, -1)

        # as datetime but date not in series, look for earlier date
        row_no = ts.row_no(rowdate=date2, closest=-1, no_error=False)
        self.assertEqual(row_no, 16)

        # as datetime but date not in series, look for later date
        row_no = ts.row_no(rowdate=date2, closest=1, no_error=False)
        self.assertEqual(row_no, 15)

        # as datetime but date not in series, look for earlier date
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date3,
            closest=-1,
            no_error=False,
        )

        # as datetime but date not in series, look for later date
        self.assertRaises(
            ValueError,
            ts.row_no,
            rowdate=date4,
            closest=1,
            no_error=False,
        )
Exemple #15
0
    def test_timeseries_truncdate(self):
        """
        Tests returning a timeseries that is a subset, but selected by
        date.
        """
        # set up separate timeseries with weekends skipped
        ts = Timeseries()
        ts.dseries = []
        ts.tseries = []
        start_date = datetime(2015, 12, 31)
        for i in range(40):
            date = start_date + timedelta(days=i)
            if date.weekday() not in [5, 6]:

                ts.dseries.append(date.toordinal())
                ts.tseries.append(i)

        ts.make_arrays()

        date1 = datetime(2016, 1, 7)  # existing date within date series
        date2 = datetime(2016, 1, 25)  # existing date within date series
        date3 = datetime(2016, 1, 16)  # date falling on a weekend

        # date as datetime
        ts1 = ts.clone()
        ts1.truncdate(start=date1, finish=None, new=False)

        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:]))

        # date as ordinal
        ts1 = ts.clone()
        ts1.truncdate(start=date1.toordinal(), finish=None, new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:]))

        # finish date
        ts1 = ts.clone()
        ts1.truncdate(start=None, finish=date2, new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[:18]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[:18]))

        # finish date that is not in dseries
        ts1 = ts.clone()
        ts1.truncdate(start=None, finish=date3, new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[:12]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[:12]))

        # start and finish date
        ts1 = ts.clone()
        ts1.truncdate(start=date1, finish=date2, new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:18]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:18]))

        # start and finish date that is not in dseries
        ts1 = ts.clone()
        ts1.truncdate(start=date1, finish=date3, new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:12]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:12]))

        # start and finish date as a list
        ts1 = ts.clone()
        ts1.truncdate([date1, date3], new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:12]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:12]))

        # start and finish date as a tuple
        ts1 = ts.clone()
        ts1.truncdate((date1, date3), new=False)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries[5:12]))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries[5:12]))

        # start and finish date as a tuple  new=True
        ts1 = ts.clone()
        ts2 = ts1.truncdate((date1, date3), new=True)
        self.assertTrue(np.array_equal(ts1.tseries, ts.tseries))
        self.assertTrue(np.array_equal(ts1.dseries, ts.dseries))
        self.assertTrue(np.array_equal(ts2.tseries, ts.tseries[5:12]))
        self.assertTrue(np.array_equal(ts2.dseries, ts.dseries[5:12]))