def _latent_time_interval(ts: datetime, ti: Interval) -> Interval:
assert ti.t_from and ti.t_to # guaranteed by the caller
dm_from = ts + relativedelta(hour=ti.t_from.hour,
minute=ti.t_from.minute or 0)
dm_to = ts + relativedelta(hour=ti.t_to.hour, minute=ti.t_to.minute or 0)
if dm_from <= ts:
dm_from += relativedelta(days=1)
dm_to += relativedelta(days=1)
return Interval(
t_from=Time(
year=dm_from.year,
month=dm_from.month,
day=dm_from.day,
hour=dm_from.hour,
minute=dm_from.minute,
period=ti.t_from.period,
),
t_to=Time(
year=dm_to.year,
month=dm_to.month,
day=dm_to.day,
hour=dm_to.hour,
minute=dm_to.minute,
period=ti.t_to.period,
),
)
def test_ruleDOYDate(self):
t1 = Time(month=4, day=12)
t2 = Time(year=2017, month=4, day=12)
self.assertIsNone(ruleDOYDate(None, t1, None, t2))
t1 = Time(month=4, day=12)
t2 = Time(year=2017, month=4, day=13)
self.assertIsNotNone(ruleDOYDate(None, t1, None, t2))
def test_latent_time():
parse = ctparse("8:00 pm",
ts=datetime(2020, 1, 1, 7, 0),
latent_time=False)
assert parse
assert parse.resolution == Time(None, None, None, 20, 00)
parse = ctparse("8:00 pm", ts=datetime(2020, 1, 1, 7, 0), latent_time=True)
assert parse
assert parse.resolution == Time(2020, 1, 1, 20, 00)
def test_ctparse(self):
txt = '12.12.2020'
res = ctparse(txt)
self.assertEqual(res.resolution, Time(year=2020, month=12, day=12))
txt = '12.12.'
res = ctparse(txt, ts=datetime(2020, 12, 1))
self.assertEqual(res.resolution, Time(year=2020, month=12, day=12))
res = ctparse(txt, ts=datetime(2020, 12, 1), debug=True)
self.assertEqual(
next(res).resolution, Time(year=2020, month=12, day=12))
def test_start(self):
t = Time()
self.assertEqual(t.start, Time(hour=0, minute=0))
t = Time(year=2012, month=1, day=1)
self.assertEqual(t.start, Time(2012, 1, 1, 0, 0))
t = Time(year=2012, month=1, day=1, hour=12)
self.assertEqual(t.start, Time(2012, 1, 1, 12, 0))
t = Time(year=2012, month=1, day=1, hour=12, minute=20)
self.assertEqual(t.start, Time(2012, 1, 1, 12, 20))
t = Time(year=2012, month=1, day=1, POD='last')
self.assertEqual(t.start, Time(2012, 1, 1, 23, 00))
def test_end(self):
t = Time()
self.assertEqual(t.end, Time(hour=23, minute=59))
t = Time(year=2012, month=1, day=1)
self.assertEqual(t.end, Time(2012, 1, 1, 23, 59))
t = Time(year=2012, month=1, day=1, hour=12)
self.assertEqual(t.end, Time(2012, 1, 1, 12, 59))
t = Time(year=2012, month=1, day=1, hour=12, minute=20)
self.assertEqual(t.end, Time(2012, 1, 1, 12, 20))
t = Time(year=2012, month=1, day=1, POD='last')
self.assertEqual(t.end, Time(2012, 1, 1, 23, 59))
def test_dt(self):
t = Time(2015, 12, 12, 12, 12)
self.assertEqual(t.dt, datetime(2015, 12, 12, 12, 12))
t = Time(2015, 12, 12, 12)
self.assertEqual(t.dt, datetime(2015, 12, 12, 12))
t = Time(2015, 12, 12)
self.assertEqual(t.dt, datetime(2015, 12, 12))
with self.assertRaises(ValueError):
t = Time(year=2012, month=12, hour=12, minute=12)
t.dt
def test_ctparse(self):
txt = '12.12.2020'
res = ctparse(txt)
self.assertEqual(res.resolution, Time(year=2020, month=12, day=12))
self.assertIsNotNone(str(res))
self.assertIsNotNone(repr(res))
# non sense gives no result
self.assertIsNone(ctparse('gargelbabel'))
txt = '12.12.'
res = ctparse(txt, ts=datetime(2020, 12, 1))
self.assertEqual(res.resolution, Time(year=2020, month=12, day=12))
res = ctparse(txt, ts=datetime(2020, 12, 1), debug=True)
self.assertEqual(next(res).resolution, Time(year=2020, month=12, day=12))
def test_from_str(self):
# Complete time
t = Time(year=1, month=1, day=1, hour=1, minute=1, DOW=1, POD='pod')
t_str = str(t)
t_back = Time.from_str(t_str)
self.assertEqual(t, t_back)
# Incomplete time
t = Time(year=None,
month=1,
day=1,
hour=None,
minute=None,
DOW=None,
POD='pod')
t_str = str(t)
t_back = Time.from_str(t_str)
self.assertEqual(t, t_back)
# Zeroed time
t = Time()
t_str = str(t)
t_back = Time.from_str(t_str)
self.assertEqual(t, t_back)
# Mistake
with self.assertRaises(ValueError):
Time.from_str('0001-01-01 01-01 (1/pod)')
def test_latent_time_interval():
parse = ctparse("8:00 pm - 9:00 pm",
ts=datetime(2020, 1, 1, 7, 0),
latent_time=False)
assert parse
assert parse.resolution == Interval(Time(None, None, None, 20, 00),
Time(None, None, None, 21, 00))
parse = ctparse("8:00 pm - 9:00 pm",
ts=datetime(2020, 1, 1, 7, 0),
latent_time=True)
assert parse
assert parse.resolution == Interval(Time(2020, 1, 1, 20, 00),
Time(2020, 1, 1, 21, 00))
def test_dummy():
scorer = DummyScorer()
pp = PartialParse((Time(), Interval()), ("rule1", "rule2"))
assert scorer.score("a", datetime.datetime(2019, 1, 1), pp) == 0.0
assert scorer.score_final("a", datetime.datetime(2019, 1, 1), pp,
pp.prod[0]) == 0.0
def test_eq(self):
a = Artifact()
b = Artifact()
self.assertEqual(a, b)
a = Time(2017, 12, 12, 12, 12, 4, 'morning')
b = Time(2017, 12, 12, 12, 12, 4, 'morning')
self.assertEqual(a, b)
a = Time(2017, 12, 12, 12, 12, 4, 'morning')
b = Time(2017, 12, 12, 12, 12, 3, 'morning')
self.assertNotEqual(a, b)
a = Time()
b = Interval()
self.assertNotEqual(a, b)
def test_random():
rng = random.Random(42)
scorer = RandomScorer(rng)
pp = PartialParse((Time(), Interval()), ("rule1", "rule2"))
assert 0.0 <= scorer.score("a", datetime.datetime(2019, 1, 1), pp) <= 1.0
assert (0.0 <= scorer.score_final("a", datetime.datetime(2019, 1, 1), pp,
pp.prod[1]) <= 1.0)
def _latent_tod(ts: datetime, tod: Time) -> Time:
dm = ts + relativedelta(hour=tod.hour, minute=tod.minute or 0)
if dm <= ts:
dm += relativedelta(days=1)
return Time(year=dm.year,
month=dm.month,
day=dm.day,
hour=dm.hour,
minute=dm.minute)
def test_ctparse():
txt = "12.12.2020"
res = ctparse(txt)
assert res
assert res.resolution == Time(year=2020, month=12, day=12)
assert str(res)
assert repr(res)
# non sense gives no result
assert ctparse("gargelbabel") is None
txt = "12.12."
res = ctparse(txt, ts=datetime(2020, 12, 1))
assert res
assert res.resolution == Time(year=2020, month=12, day=12)
gres = ctparse_gen(txt, ts=datetime(2020, 12, 1))
first_res = next(gres)
assert first_res
assert first_res.resolution == Time(year=2020, month=12, day=12)
def test_make_partial_rule_dataset() -> None:
ts = datetime(year=2019, month=10, day=1)
entries = [
TimeParseEntry("today at 5 pm", ts, Time(year=2019, month=10, day=1, hour=17, minute=0))
]
X, y = zip(*make_partial_rule_dataset(entries, timeout=0,
max_stack_depth=0, scorer=DummyScorer()))
assert isinstance(y[0], bool)
assert isinstance(X[0][0], str)
def test_ruleDateDate(self):
t1 = Time(year=2017)
t2 = Time(year=2015)
self.assertIsNone(ruleDateDate(None, t1, None, t2))
t1 = Time(year=2017, month=12)
t2 = Time(year=2017, month=11)
self.assertIsNone(ruleDateDate(None, t1, None, t2))
t1 = Time(year=2017, month=12, day=31)
t2 = Time(year=2017, month=12, day=30)
self.assertIsNone(ruleDateDate(None, t1, None, t2))
t1 = Time(year=2017, month=12, day=31)
t2 = Time(year=2017, month=12, day=31)
self.assertIsNone(ruleDateDate(None, t1, None, t2))
t1 = Time(year=2017, month=12, day=30)
t2 = Time(year=2017, month=12, day=31)
self.assertIsNotNone(ruleDateDate(None, t1, None, t2))
def test_from_str(self):
# Complete interval
t1 = Time(year=1, month=1, day=1, hour=1, minute=1, DOW=1, POD='pod')
t2 = Time(year=2, month=1, day=1, hour=1, minute=1, DOW=1, POD='pod')
interval = Interval(t1, t2)
i_back = Interval.from_str(str(interval))
self.assertEqual(interval, i_back)
# Incomplete interval
interval = Interval(None, t2)
i_back = Interval.from_str(str(interval))
self.assertEqual(interval, i_back)
# Zeroed interval
interval = Interval()
i_back = Interval.from_str(str(interval))
self.assertEqual(interval, i_back)
# Mistake
with self.assertRaises(ValueError):
Interval.from_str('X-X-X X: X(X/X) -X-X-X X: X(X/X)')
def test_start(self):
i = Interval(Time(2013, 1, 1), Time(2013, 1, 2))
self.assertEqual(i.start, Time(2013, 1, 1, 0, 0))
i = Interval(Time(2013, 1, 1), None)
self.assertEqual(i.start, Time(2013, 1, 1, 0, 0))
i = Interval(None, Time(2013, 1, 2))
self.assertIsNone(i.start)
def test_end(self):
i = Interval(Time(2013, 1, 1), Time(2013, 1, 2))
self.assertEqual(i.end, Time(2013, 1, 2, 23, 59))
i = Interval(None, Time(2013, 1, 2))
self.assertEqual(i.end, Time(2013, 1, 2, 23, 59))
i = Interval(Time(2013, 1, 1), None)
self.assertIsNone(i.end)
def test_ruleDOMDate(self):
t1 = Time(day=30)
t2 = Time(year=2015, month=1, day=29)
self.assertIsNone(ruleDOMDate(None, t1, None, t2))
t1 = Time(day=30)
t2 = Time(year=2015, month=1, day=30)
self.assertIsNone(ruleDOMDate(None, t1, None, t2))
t1 = Time(day=29)
t2 = Time(year=2015, month=1, day=30)
self.assertIsNotNone(ruleDOMDate(None, t1, None, t2))
def test_nbscorer():
# We only test that it runs just fine
X = [("a", "b"), ("a", ), ("b"), ("a", "b", "a", "b")]
y = [False, True, True, False]
model = train_naive_bayes(X, y)
scorer = NaiveBayesScorer(model)
pp = PartialParse((Time(), Interval()), ("rule1", "rule2"))
pp.prod[0].mstart = 0
pp.prod[1].mend = 1
pp.prod[0].mend = 1
pp.prod[1].mend = 2
assert 0.0 <= scorer.score("ab", datetime.datetime(2019, 1, 1), pp) <= 1.0
assert (0.0 <= scorer.score_final("ab", datetime.datetime(2019, 1, 1), pp,
pp.prod[1]) <= 1.0)
def test_parse_nb_string() -> None:
t = Time(year=1, month=1, day=1, hour=1, minute=1, DOW=1, POD="pod")
assert t == parse_nb_string("Time[]{0001-01-01 01:01 (1/pod)}")
assert Interval(Time(), Time()) == parse_nb_string(
"Interval[]{X-X-X X:X (X/X) - X-X-X X:X (X/X)}")
def test_isTOD(self):
self.assertTrue(Time(hour=1, minute=1).isTOD)
self.assertTrue(Time(hour=1).isTOD)
self.assertFalse(Time(minute=1).isTOD)
self.assertFalse(Time().isTOD)
def test_isPOD(self):
self.assertTrue(Time(POD='morning').isPOD)
self.assertFalse(Time(day=1).isPOD)
self.assertFalse(Time(year=1).isPOD)
def test_isMonth(self):
self.assertTrue(Time(month=1).isMonth)
self.assertFalse(Time(day=1).isMonth)
self.assertFalse(Time(year=1).isMonth)
def test_isDOW(self):
self.assertTrue(Time(DOW=1).isDOW)
self.assertFalse(Time().isDOW)
def test_isHour(self):
self.assertTrue(Time(hour=1).isHour)
self.assertFalse(Time(hour=1, minute=1).isHour)
self.assertFalse(Time(hour=1, month=1).isHour)
def test_isDOM(self):
self.assertTrue(Time(day=1).isDOM)
self.assertFalse(Time(month=1).isDOM)
def test_isDOY(self):
self.assertTrue(Time(month=1, day=1).isDOY)
self.assertFalse(Time(year=1).isDOY)
