def _intervalize(self, sorted_iter: dicts) -> Iterator['TimeInterval']:
"""Returns a list with of TimeIntervals objects.
If there is an incomplete interval, y create an empty starting
or ending interval
"""
skip_loop = False
# Compere every item with the next one to find his pair.
for i, el in enumerate(sorted_iter):
if skip_loop == True:
skip_loop = False
continue
el1 = sorted_iter[i + 1] if (i + 1) < len(sorted_iter) else None
# Creates a perfect pair interval if finds a proper initial
# and final point. Else, an incomplete interval is created,
# depending on wich limit is missiing, start or end.
kwargs = {k: v for k, v in el.items() if k in self._args}
if self._are_pair(el, el1):
interval = TimeInterval(start=el[self._dt_loc],
end=el1[self._dt_loc],
**kwargs)
skip_loop = True
elif self._is_start(el):
interval = TimeInterval(start=el[self._dt_loc], **kwargs)
skip_loop = False
elif self._is_end(el):
interval = TimeInterval(end=el[self._dt_loc], **kwargs)
skip_loop = False
yield interval
def setUp(self):
self.dt_111710 = datetime(year=2019,
month=12,
day=19,
hour=11,
minute=17,
second=10)
self.dt_121710 = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
self.dt_131710 = datetime(year=2019,
month=12,
day=19,
hour=13,
minute=17,
second=10)
self.dt_134710 = self.dt_131710 + timedelta(minutes=30)
self.dt_141710 = self.dt_121710 + timedelta(hours=2)
self.dt_151710 = self.dt_131710 + timedelta(hours=2)
self.int_111710_121710 = TimeInterval(start=self.dt_111710,
end=self.dt_121710)
self.int_121710_131710 = TimeInterval(start=self.dt_121710,
end=self.dt_131710)
self.int_131710_141710 = TimeInterval(start=self.dt_131710,
end=self.dt_141710)
self.int_121710_151710 = TimeInterval(start=self.dt_121710,
end=self.dt_151710)
self.int_131710_141710 = TimeInterval(start=self.dt_131710,
end=self.dt_141710)
self.int_111710_empty = TimeInterval(start=self.dt_111710, end='')
self.int_121710_empty = TimeInterval(start=self.dt_121710, end='')
self.int_empty_111710 = TimeInterval(start='', end=self.dt_111710)
self.int_empty_121710 = TimeInterval(start='', end=self.dt_121710)
self.all = []
self.perfect = []
# Filling the perfect list, with only complete intervals
for key, value in self.__dict__.items():
if key.startswith("int_") and key.find('empty') is -1:
self.perfect.append(value)
# Filling the all list, with every interval
for key, value in self.__dict__.items():
if key.startswith("int_"):
self.all.append(value)
def test_duration_and_is_perfect_not_end(self):
# Test duration and is_perfect prop without `end` attributte.
# Should return an empty str and False.
interval = TimeInterval(start=self.start_str)
self.assertEqual(interval.duration,
'',
msg="interval.duration should be an empty string")
self.assertEqual(interval.is_perfect, False)
def test_empty_end_attr(self):
# Test that an empty `end` attr creates an empty string as
# end property
start = '12/12/2019 12:03:52'
interval = TimeInterval(start=start)
self.assertEqual(interval.end,
'',
msg='end property must be an empty string')
def setUp(self):
self.dt_111710 = datetime(year=2019,
month=12,
day=19,
hour=11,
minute=17,
second=10)
self.dt_121710 = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
self.dt_131710 = datetime(year=2019,
month=12,
day=19,
hour=13,
minute=17,
second=10)
self.int_111710_121710_1 = TimeInterval(start=self.dt_111710,
end=self.dt_121710)
self.int_111710_121710_2 = TimeInterval(start=self.dt_111710,
end=self.dt_121710)
self.int_111710_empty_1 = TimeInterval(start=self.dt_111710, end='')
self.int_111710_empty_2 = TimeInterval(start=self.dt_111710, end='')
self.int_empty_111710_1 = TimeInterval(start='', end=self.dt_111710)
self.int_empty_111710_2 = TimeInterval(start='', end=self.dt_111710)
self.int_empty_121710 = TimeInterval(start='', end=self.dt_121710)
def test_duration_and_is_perfect_normal_str(self):
# Test duration and is_perfect with valid str format datetime
interval = TimeInterval(start=self.start_str, end=self.end_str)
self.assertEqual(
interval.duration,
self.str_duration,
msg="interval.duration and self.str_duration should have same value"
)
self.assertEqual(interval.is_perfect, True)
def test_aditional_params_dict(self):
# Test passing aditional params in a dictionary
interval = TimeInterval(start=self.strat_dt,
end=self.end_dt,
**self.aditional)
self.assertEqual(interval.name, 'Peter')
self.assertEqual(interval.age, 58)
self.assertEqual(interval.email, '*****@*****.**')
self.assertEqual(interval.height, 1.56)
def test_duration_and_is_perfect_normal_datetime(self):
# Test the properties with normal and valid attribbutes
# That means that `start` and `end` are valid datetime and that
# `start` < `end`.
interval = TimeInterval(start=self.strat_dt, end=self.end_dt)
self.assertEqual(
interval.duration,
self.dt_duration,
msg="interval.duration and self.dt_duration should be the same")
self.assertEqual(interval.is_perfect, True)
def test_string_iso_date(self):
# Test that a string datetimeISO format objet returns a valid
# datetime object for the `start` attribute.
for sep in DATE_SEPARATORS:
date_str = '2019{s}12{s}01 17:00:59'.format(s=sep)
formated_date = datetime.strptime(
date_str, '%Y{s}%m{s}%d %H:%M:%S'.format(s=sep))
eep_date = TimeInterval(start=date_str).start
self.assertEqual(
formated_date,
eep_date,
msg="string datetime and `start` property shoud be the same")
def test_string_iso_date_non_padded_decimals(self):
# Test a non string date ISO format is a valid datetime object
# for the `start` attribute.
for sep in DATE_SEPARATORS:
date_str = '2019{s}2{s}1 23:00:00'.format(s=sep)
formated_date = datetime.strptime(
date_str, '%Y{s}%m{s}%d %H:%M:%S'.format(s=sep))
eep_date = TimeInterval(start=date_str).start
self.assertEqual(
formated_date,
eep_date,
msg="string datetime and `start` property shoud be the same")
def test_end_lower_value(self):
# Test that an `end` param < than an `start` param, both
# datetime objects raises a ValueError
start = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
end = start + timedelta(hours=-1)
with self.assertRaises(ValueError):
TimeInterval(start=start, end=end)
def test_little_endian_format_date_non_padded_decimals(self):
# Test a non zedro padded string little endian format is a valid
# datetime object for the `start` attribute.
# Little endian format is: dd-mm-yyyy
for sep in DATE_SEPARATORS:
date_str = '1{s}2{s}2019 00:15:23'.format(s=sep)
formated_date = datetime.strptime(
date_str, '%d{s}%m{s}%Y %H:%M:%S'.format(s=sep))
eep_date = TimeInterval(start=date_str).start
self.assertEqual(
formated_date,
eep_date,
msg="string datetime and `start` property shoud be the same")
def test_datetime_datetime_object(self):
# Test that a datetime object returns a valid datetime object
# for the `start` attribute.
date_time_ob = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
eep_date = TimeInterval(start=date_time_ob).start
self.assertEqual(
date_time_ob,
eep_date,
msg="datetime from datetime and property `start` are different")
def test_little_endian_format_date(self):
# Test that a string datetime with little endian format is a
# valid datetime object for the `start` attribute.
# Little endian format is: dd-mm-yyyy
for sep in DATE_SEPARATORS:
date_str = '01{s}02{s}2019 12:24:59'.format(s=sep)
formated_date = datetime.strptime(
date_str, '%d{s}%m{s}%Y %H:%M:%S'.format(s=sep))
eep_date = TimeInterval(start=date_str).start
self.assertEqual(
formated_date,
eep_date,
msg="string datetime and `start` property shoud be the same")
def setUp(self):
self.dt_111710 = datetime(year=2019,
month=12,
day=19,
hour=11,
minute=17,
second=10)
self.dt_121710 = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
self.dt_131710 = datetime(year=2019,
month=12,
day=19,
hour=13,
minute=17,
second=10)
self.dt_134710 = self.dt_131710 + timedelta(minutes=30)
self.dt_141710 = self.dt_121710 + timedelta(hours=2)
self.dt_151710 = self.dt_131710 + timedelta(hours=2)
self.int_111710_121710 = TimeInterval(start=self.dt_111710,
end=self.dt_121710)
self.int_121710_131710 = TimeInterval(start=self.dt_121710,
end=self.dt_131710)
self.int_131710_141710 = TimeInterval(start=self.dt_131710,
end=self.dt_141710)
self.int_121710_151710 = TimeInterval(start=self.dt_121710,
end=self.dt_151710)
self.int_131710_141710 = TimeInterval(start=self.dt_131710,
end=self.dt_141710)
self.int_111710_empty = TimeInterval(start=self.dt_111710, end='')
self.int_121710_empty = TimeInterval(start=self.dt_121710, end='')
self.int_empty_111710 = TimeInterval(start='', end=self.dt_111710)
self.int_empty_121710 = TimeInterval(start='', end=self.dt_121710)
def test_complete_datetime_interval(self):
# Test that an `start` param < than an `end` param, both
# datetime objects creates valid values for `start and `end`
# properties
start = datetime(year=2019,
month=12,
day=19,
hour=12,
minute=17,
second=10)
end = start + timedelta(hours=1)
interval = TimeInterval(start=start, end=end)
self.assertEqual(interval.start,
start,
msg="start var and interval.start should be equals")
self.assertEqual(interval.end,
end,
msg="end var and interval.end should be equals")
def test_aditional_params(self):
# Test that aditional params are callables.
# The must return the expected value.
interval = TimeInterval(start=self.strat_dt,
end=self.end_dt,
name='Tom',
age=45,
height=1.78,
is_employ=True)
self.assertEqual(interval.name,
'Tom',
msg="interva.name should be 'Tom'")
self.assertEqual(interval.age, 45, msg="interva.age should be 45")
self.assertEqual(interval.height,
1.78,
msg="interva.height should be 1.78")
self.assertEqual(interval.is_employ,
True,
msg="interva.is_employ should be True")
def test_empty_start_attr(self):
# Test that an empty `start` attribute creates an object with an
# empty string start attribbute
self.assertEqual(TimeInterval().start, '')
def test_date_object(self):
# Test that a date object returns a ValueError
date_ob = date(year=2019, month=12, day=19)
with self.assertRaises(ValueError):
TimeInterval(start=date_ob)
def test_string_iso_date_error(self):
# Test an string ISO datetime format with an error
for sep in DATE_SEPARATORS:
date_str = '209{s}12{s}01'.format(s=sep)
with self.assertRaises(ValueError):
TimeInterval(start=date_str)
