def test_dehumanize_static(self):
now_dehumanized = XArrow.dehumanize("now")
now = XArrow.now()
assert_arrows_soft_eq(now_dehumanized, now)
today = XArrow.dehumanize('today')
assert_arrows_soft_eq(today, now)
yesterday = XArrow.dehumanize('yesterday')
now_shift_yesterday = now.shift(days=-1)
assert_arrows_soft_eq(now_shift_yesterday, yesterday)
tomorrow = XArrow.dehumanize('tomorrow')
now_shift_tomorrow = now.shift(days=+1)
assert_arrows_soft_eq(now_shift_tomorrow, tomorrow)
def test_stop_before_last_entry_started(self):
log.title(f"test_models.test_stop_before_last_entry_started()")
work = default_work(TEST_START_ARROW)
day: Day = work.__getitem__(TEST_START_ARROW.DDMMYY)
assert work[TEST_START_ARROW.DDMMYY] is day
got_to_office_activity: Activity = day.__getitem__("Got to office")
assert got_to_office_activity.ongoing() is True
assert day['Got to office'] is got_to_office_activity
last_entry: Entry = got_to_office_activity[-1]
assert got_to_office_activity.safe_last_entry() is last_entry
yesterday = XArrow.dehumanize('yesterday')
with assert_raises(
ValueError,
f'Cannot stop {got_to_office_activity.shortrepr()} before start time (tried to stop at {yesterday!r})'
):
got_to_office_activity.stop(yesterday)
def test_dehumanize_advanced(
self): # can decide not to support if too difficult
XArrow.dehumanize('1 days from now')
XArrow.dehumanize('1 days from today')
def test_dehumanize_vanilla(self):
"""Make sure we don't break vanilla Arrow.dehumanize() functionality"""
log.title('TestXArrow.Test_dehumanize.test_dehumanize_vanilla')
now = XArrow.now()
now_dehumanized = XArrow.dehumanize("now")
assert_arrows_soft_eq(now_dehumanized, now)
assert_arrows_soft_eq(XArrow.dehumanize("just now"), now)
# * 1 unit
# "hour": "an hour", "days": "{0} days"
for unit, expression in EnglishLocale.timeframes.items():
for relative_fmt in ("{0} ago", "in {0}"):
if 'now' in expression:
continue
if '{0}' in expression:
shift = randint(2, 4)
hardcoded_number = expression.format(
shift) # 3 seconds
human_expression = relative_fmt.format(
hardcoded_number) # 3 seconds ago / in 3 seconds
else:
shift = 1
human_expression = relative_fmt.format(
expression) # a second ago / in a second
dehumanized_static = XArrow.dehumanize(human_expression)
if 'ago' in relative_fmt:
shift *= -1
shift_kwargs = {unit.removesuffix('s') + 's': shift}
now = XArrow.now()
now_shifted = now.shift(**shift_kwargs)
try:
assert_arrows_soft_eq(dehumanized_static, now_shifted)
except AssertionError:
dehumanized_static = XArrow.dehumanize(
human_expression)
now = XArrow.now()
now_shifted = now.shift(**shift_kwargs)
assert_arrows_soft_eq(dehumanized_static, now_shifted)
dehumanized_instance = now.dehumanize(human_expression)
assert_arrows_soft_eq(dehumanized_instance, now_shifted)
# * 2 units
for time_unit_1 in TIME_UNITS:
for time_unit_2 in TIME_UNITS:
if time_unit_1 == time_unit_2:
continue
if random() < 0.5:
continue
shift_1 = randint(2, 4)
shift_2 = randint(2, 4)
singular_time_unit_1 = (f"a" if time_unit_1 != "hour" else
"an") + f" {time_unit_1}"
singular_time_unit_2 = (f"a" if time_unit_2 != "hour" else
"an") + f" {time_unit_2}"
plural_time_unit_1 = f"{shift_1} {time_unit_1}s"
plural_time_unit_2 = f"{shift_2} {time_unit_2}s"
expressions = {}
for fmt in ["{0} and {1}", "{0}, {1}", "{0} {1}"]:
expressions[
fmt.format(plural_time_unit_1, plural_time_unit_2)
+ " ago"] = (True, True)
expressions["in " + fmt.format(
plural_time_unit_1, plural_time_unit_2)] = (True,
True)
expressions[fmt.format(plural_time_unit_1,
singular_time_unit_2) +
" ago"] = (True, False)
expressions["in " +
fmt.format(plural_time_unit_1,
singular_time_unit_2)] = (True,
False)
expressions[fmt.format(singular_time_unit_1,
plural_time_unit_2) +
" ago"] = (False, True)
expressions["in " +
fmt.format(singular_time_unit_1,
plural_time_unit_2)] = (False,
True)
expressions[fmt.format(singular_time_unit_1,
singular_time_unit_2) +
" ago"] = (False, False)
expressions["in " +
fmt.format(singular_time_unit_1,
singular_time_unit_2)] = (False,
False)
for human_expression, quantity_tuple in expressions.items(
):
shift_kwargs = {}
sign = 1 if human_expression.startswith("in ") else -1
if quantity_tuple[0]:
shift_kwargs[time_unit_1 + 's'] = shift_1 * sign
else:
shift_kwargs[time_unit_1 + 's'] = 1 * sign
if quantity_tuple[1]:
shift_kwargs[time_unit_2 + 's'] = shift_2 * sign
else:
shift_kwargs[time_unit_2 + 's'] = 1 * sign
now = XArrow.now()
dehumanized_instance_vanilla = Arrow.now().dehumanize(
human_expression)
dehumanized_instance_vanilla.microsecond = 0
dehumanized_static = XArrow.dehumanize(
human_expression)
now_shifted = now.shift(**shift_kwargs)
dehumanized_instance = now.dehumanize(human_expression)
try:
assert_arrows_soft_eq(dehumanized_instance,
now_shifted)
assert_arrows_soft_eq(dehumanized_static,
now_shifted)
assert_arrows_soft_eq(
dehumanized_instance,
dehumanized_instance_vanilla)
assert_arrows_soft_eq(
dehumanized_static,
dehumanized_instance_vanilla)
except AssertionError:
now = XArrow.now()
dehumanized_instance = now.dehumanize(
human_expression)
now_shifted = now.shift(**shift_kwargs)
assert_arrows_soft_eq(dehumanized_instance,
now_shifted)
dehumanized_static = XArrow.dehumanize(
human_expression)
assert_arrows_soft_eq(dehumanized_static,
now_shifted)
dehumanized_instance_vanilla = Arrow.now(
).dehumanize(human_expression)
assert_arrows_soft_eq(
dehumanized_instance,
dehumanized_instance_vanilla)
assert_arrows_soft_eq(
dehumanized_static,
dehumanized_instance_vanilla)
# * 3 units
for time_unit_3 in TIME_UNITS:
if time_unit_3 == time_unit_1 or time_unit_3 == time_unit_2:
continue
if random() < 0.75:
continue
shift_3 = randint(2, 4)
singular_time_unit_3 = (f"a" if time_unit_3 != "hour"
else "an") + f" {time_unit_3}"
plural_time_unit_3 = f"{shift_3} {time_unit_3}s"
expressions = {}
for fmt in [
"{0} and {1} and {2}",
"{0} and {1}, {2}",
"{0} and {1} {2}",
"{0}, {1}, {2}",
"{0}, {1} and {2}",
"{0}, {1} {2}",
"{0} {1} {2}",
"{0} {1}, {2}",
"{0} {1} and {2}",
]:
for q1, q2, q3 in product(["plural", "singular"],
["plural", "singular"],
["plural", "singular"]):
past_human_expression = eval(
f"fmt.format({q1}_time_unit_1, {q2}_time_unit_2, {q3}_time_unit_3) + ' ago'"
)
future_human_expression = eval(
f"'in ' + fmt.format({q1}_time_unit_1, {q2}_time_unit_2, {q3}_time_unit_3)"
)
quantity_tuple = (q1 == "plural",
q2 == "plural",
q3 == "plural")
expressions[
past_human_expression] = quantity_tuple
expressions[
future_human_expression] = quantity_tuple
for human_expression, quantity_tuple in expressions.items(
):
shift_kwargs = {}
sign = 1 if human_expression.startswith(
"in ") else -1
if quantity_tuple[0]:
shift_kwargs[time_unit_1 +
's'] = shift_1 * sign
else:
shift_kwargs[time_unit_1 + 's'] = 1 * sign
if quantity_tuple[1]:
shift_kwargs[time_unit_2 +
's'] = shift_2 * sign
else:
shift_kwargs[time_unit_2 + 's'] = 1 * sign
if quantity_tuple[2]:
shift_kwargs[time_unit_3 +
's'] = shift_3 * sign
else:
shift_kwargs[time_unit_3 + 's'] = 1 * sign
now = XArrow.now()
dehumanized_instance_vanilla = Arrow.now(
).dehumanize(human_expression)
dehumanized_static = XArrow.dehumanize(
human_expression)
now_shifted = now.shift(**shift_kwargs)
dehumanized_instance = now.dehumanize(
human_expression)
try:
assert_arrows_soft_eq(dehumanized_instance,
now_shifted)
assert_arrows_soft_eq(dehumanized_static,
now_shifted)
assert_arrows_soft_eq(
dehumanized_instance,
dehumanized_instance_vanilla)
assert_arrows_soft_eq(
dehumanized_static,
dehumanized_instance_vanilla)
except AssertionError:
now = XArrow.now()
dehumanized_instance = now.dehumanize(
human_expression)
now_shifted = now.shift(**shift_kwargs)
assert_arrows_soft_eq(dehumanized_instance,
now_shifted)
dehumanized_static = XArrow.dehumanize(
human_expression)
assert_arrows_soft_eq(dehumanized_static,
now_shifted)
dehumanized_instance_vanilla = Arrow.now(
).dehumanize(human_expression)
assert_arrows_soft_eq(
dehumanized_instance,
dehumanized_instance_vanilla)
assert_arrows_soft_eq(
dehumanized_static,
dehumanized_instance_vanilla)