def test_interval() :
tz = tzlocal.get_localzone()
place = Place(nkpCoord())
place.findSunTimes()
interval = TimeInterval(SunriseTimepoint(datetime.timedelta(hours = 1), place),
AbsoluteTimepoint(datetime.time(13, 10, 5, 0, tz)))
print str(interval.within(datetime.time(12, 10, 5, 0, tz))) + ' expected true.'
print str(interval.within(datetime.time(13, 10, 6, 0, tz))) + ' expected false.'
print str(interval.within(datetime.time(5, 10, 5, 0, tz))) + ' expected false.'
print str(interval.within(datetime.time(8, 10, 5, 0, tz))) + ' expected true.'
def test_str(self):
interval = TimeInterval(
datetime(2017, 1, 1),
datetime(2018, 1, 1),
)
self.assertEqual(str(interval),
'2017-01-01 00:00:00 -> 2018-01-01 00:00:00')
def get_partition_selections(self, selection):
if isinstance(selection, slice):
interval = TimeInterval.from_slice(selection)
return self._get_partition_selection_s_from_interval(interval)
elif isinstance(selection, TimeInterval):
return self._get_partition_selection_s_from_interval(selection)
elif isinstance(selection, pd.DatetimeIndex):
return self._get_partition_selection_s_from_index(selection)
else:
raise NotImplementedError('')
def get_internal_partition_selections(self, interval):
"""
:param interval:
:return: [(<partition key>, selection)]
"""
if isinstance(interval, slice):
interval = TimeInterval.from_slice(interval)
return self._get_internal_partition_selection_s_from_interval(
interval)
elif isinstance(interval, TimeInterval):
return self._get_internal_partition_selection_s_from_interval(
interval)
else:
raise TypeError('')
def load_affected_partitions(self, index):
if len(index) == 0:
return pd.DatetimeIndex([])
elif len(index) == 1:
return self.load_partition(index[0].floor(self.partition_offset))
else:
partitions = self.get_partitions_for_interval(
TimeInterval(index[0], index[-1]))
chunks = [
self._group[self.get_partition_key(partition)][:]
for partition in partitions
]
index = pd.DatetimeIndex(np.concatenate(chunks))
return index
def _get_partition_selection_for_interval(self, partition, interval):
"""interval already sliced!"""
partition_index = self.load_partition(partition)
if TimeInterval(partition, partition +
self.partition_offset.delta).intersect(interval).empty:
return slice(0, 0)
if interval.start > partition_index[0]:
start = partition_index.get_slice_bound(interval.start, 'left',
'ix')
else:
start = None
if interval.end < partition_index[-1]:
stop = partition_index.get_slice_bound(interval.end, 'right', 'ix')
else:
stop = None
return slice(start, stop)