def test_ambiguous_format_resolution_yyymmdd_vs_epoch(self):
val = "20140306"
dt = time_util.str_to_datetime(val, "%Y%m%d")
assert (dt == datetime(2014, 3, 6))
dt = time_util.str_to_datetime(val, time_util.UTC)
assert (dt == datetime.utcfromtimestamp(int(val)))
dt = time_util.str_to_datetime(val, time_util.PENDING)
assert (dt == datetime.utcfromtimestamp(int(val)))
def test_ambiguous_format_resolution_years_vs_epoch(self):
val="1600"
dt = time_util.str_to_datetime(val, "%Y")
assert(dt == datetime(1600,1,1))
dt = time_util.str_to_datetime(val, time_util.UTC)
assert(dt == datetime.utcfromtimestamp(int(val)))
dt = time_util.str_to_datetime(val, time_util.PENDING) # if not specified, will infer as epoch
assert(dt == datetime.utcfromtimestamp(int(val)))
def test_ambiguous_format_resolution_years_vs_epoch(self):
val = "1600"
dt = time_util.str_to_datetime(val, "%Y")
assert (dt == datetime(1600, 1, 1))
dt = time_util.str_to_datetime(val, time_util.UTC)
assert (dt == datetime.utcfromtimestamp(int(val)))
dt = time_util.str_to_datetime(val,
time_util.PENDING) # if not specified, will infer as epoch
assert (dt == datetime.utcfromtimestamp(int(val)))
def test_export(self):
self.registerTweetsTimeLayer()
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("hours")
start_time = time_util.str_to_datetime(self.timeLayer.getMinMaxValues()[0])
end_time = time_util.str_to_datetime(self.timeLayer.getMinMaxValues()[1])
layer_duration_in_hours = (end_time-start_time).total_seconds() / 3600.0
self.ctrl.exportVideoAtPath(tmpdir)
screenshots_generated = glob.glob(os.path.join(tmpdir, FRAME_FILENAME_PREFIX+"*"))
self.assertEqual(len(screenshots_generated), math.ceil(layer_duration_in_hours + 1))
for i in range(int(math.ceil(layer_duration_in_hours + 1))):
fn = self.ctrl.generate_frame_filename(tmpdir,i, start_time + timedelta(hours=i))
self.assertIn(fn, screenshots_generated)
shutil.rmtree(tmpdir)
def test_bc_date_conversions_epoch(self):
for datestr in self.bc_dates:
print datestr
dt = time_util.str_to_datetime(datestr)
epoch = time_util.datetime_to_epoch(dt)
dt2 = time_util.epoch_to_datetime(epoch)
assert (dt == dt2)
def test_str_to_bcdate_wrong_digits_when_set_to_default(self):
self.assertEqual(conf.DEFAULT_DIGITS,
bcdate_util.getGlobalDigitSetting())
dateStrs = ["00005 BC", "123 AD"]
for dateStr in dateStrs:
with self.assertRaises(time_util.UnsupportedFormatException):
dt = time_util.str_to_datetime(dateStr)
def test_bc_date_conversions_epoch(self):
for datestr in self.bc_dates:
print datestr
dt = time_util.str_to_datetime(datestr)
epoch = time_util.datetime_to_epoch(dt)
dt2 = time_util.epoch_to_datetime(epoch)
assert (dt == dt2)
def test_str_with_microseconds_returns_float(self):
dtstr ="2013-06-14 11:30:23.100000"
dt = time_util.str_to_datetime(dtstr,time_util.PENDING) # test that inference works correctly
assert(dt.microsecond==100000)
numeric = time_util.datetime_to_epoch(dt)
assert(int(numeric)<float(numeric))
assert(numeric == 1371209423.1)
def test_str_to_bcdate_wrong_digits_when_explicitly_set(self):
time_util.setArchDigits(5)
self.assertEqual(5, bcdate_util.getGlobalDigitSetting())
dateStrs = ["0005 BC", "123 AD"]
for dateStr in dateStrs:
with self.assertRaises(time_util.UnsupportedFormatException):
dt = time_util.str_to_datetime(dateStr)
time_util.setArchDigits(conf.DEFAULT_DIGITS)
def test_str_with_microseconds_returns_float(self):
dtstr = "2013-06-14 11:30:23.100000"
dt = time_util.str_to_datetime(dtstr,
time_util.PENDING) # test that inference works correctly
assert (dt.microsecond == 100000)
numeric = time_util.datetime_to_epoch(dt)
assert (int(numeric) < float(numeric))
assert (numeric == 1371209423.1)
def _test_spatialite_layer(self, attr, layer, is_int=False):
timeLayer = timevectorlayer.TimeVectorLayer(layer, attr, attr, True,
time_util.DEFAULT_FORMAT,
0)
self.tlm.registerTimeLayer(timeLayer)
if is_int:
self.assertEquals(timeLayer.getDateType(),
timevectorlayer.DateTypes.IntegerTimestamps)
self.assertEquals(timeLayer.getTimeFormat(), time_util.UTC)
else:
self.assertEquals(timeLayer.getDateType(),
timevectorlayer.DateTypes.DatesAsStrings)
self.assertEquals(timeLayer.getTimeFormat(),
time_util.DEFAULT_FORMAT)
start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0],
time_util.DEFAULT_FORMAT)
self.assertEquals(time_util.epoch_to_datetime(STARTTIME), start_time)
self.tlm.setTimeFrameType("minutes")
self.tlm.stepForward()
assert (start_time +
timedelta(minutes=1) == self.tlm.getCurrentTimePosition())
# only one feature is selected now, because there is one feature per minute
self.assertEquals(layer.featureCount(), 1)
FS = 5
self.tlm.setTimeFrameSize(FS)
# we have one feature per minute
self.assertEquals(layer.featureCount(), FS)
subsetString = layer.subsetString()
if is_int:
expectedSubsetString = INT_FORMAT.format(
attr, self.comparison_op,
time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition() +
timedelta(minutes=FS)), attr,
time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition()))
self.assertEquals(subsetString, expectedSubsetString)
minimum_bound_seconds = int(subsetString.split(" ")[6])
self.assertEquals(
self.tlm.getCurrentTimePosition(),
time_util.epoch_to_datetime(minimum_bound_seconds))
if not is_int:
self.assertEqual(timeLayer.getTimeFormat(),
time_util.DEFAULT_FORMAT)
expectedSubsetString = STRING_FORMAT.format(
attr, self.comparison_op,
time_util.datetime_to_str(
self.tlm.getCurrentTimePosition() + timedelta(minutes=FS),
timeLayer.getTimeFormat()), attr,
time_util.datetime_to_str(self.tlm.getCurrentTimePosition(),
timeLayer.getTimeFormat()))
self.assertEquals(subsetString, expectedSubsetString)
self.tlm.stepForward()
self.assertEquals(layer.featureCount(), FS)
def _test_spatialite_layer(self, attr, layer, is_int=False):
settings = LayerSettings()
settings.layer = layer
settings.startTimeAttribute = attr
settings.endTimeAttribute = attr
timeLayer = timevectorlayer.TimeVectorLayer(settings, iface=Mock())
self.tlm.registerTimeLayer(timeLayer)
if is_int:
self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.IntegerTimestamps)
self.assertEquals(timeLayer.getTimeFormat(), time_util.UTC)
else:
self.assertEquals(timeLayer.getDateType(), timevectorlayer.DateTypes.DatesAsStrings)
self.assertEquals(timeLayer.getTimeFormat(), time_util.DEFAULT_FORMAT)
start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0], time_util.PENDING)
self.assertEquals(time_util.epoch_to_datetime(STARTTIME), start_time)
self.tlm.setTimeFrameType("minutes")
self.tlm.stepForward()
assert start_time + timedelta(minutes=1) == self.tlm.getCurrentTimePosition()
# only one feature is selected now, because there is one feature per minute
self.assertEquals(layer.featureCount(), 1)
FS = 5
self.tlm.setTimeFrameSize(FS)
# we have one feature per minute
self.assertEquals(layer.featureCount(), FS)
subsetString = layer.subsetString()
if is_int:
expectedSubsetString = INT_FORMAT.format(
attr,
self.comparison_op,
time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition() + timedelta(minutes=FS)),
attr,
time_util.datetime_to_epoch(self.tlm.getCurrentTimePosition()),
)
self.assertEquals(subsetString, expectedSubsetString)
minimum_bound_seconds = int(subsetString.split(" ")[6])
self.assertEquals(self.tlm.getCurrentTimePosition(), time_util.epoch_to_datetime(minimum_bound_seconds))
if not is_int:
self.assertEqual(timeLayer.getTimeFormat(), time_util.DEFAULT_FORMAT)
expectedSubsetString = STRING_FORMAT.format(
attr,
self.comparison_op,
time_util.datetime_to_str(
self.tlm.getCurrentTimePosition() + timedelta(minutes=FS), timeLayer.getTimeFormat()
),
attr,
time_util.datetime_to_str(self.tlm.getCurrentTimePosition(), timeLayer.getTimeFormat()),
)
self.assertEquals(subsetString, expectedSubsetString)
self.tlm.stepForward()
self.assertEquals(layer.featureCount(), FS)
def test_export_exports_last_frame(self):
settings = ls.LayerSettings()
settings.layer = self.layer
settings.startTimeAttribute = DATE_COL
settings.endTimeAttribute = DATE_COL
iface=Mock()
timeLayer = timevectorlayer.TimeVectorLayer(settings, iface)
self.tlm.registerTimeLayer(timeLayer)
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("seconds")
start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0])
end_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[1])
self.ctrl.exportVideo(tmpdir,100,False)
screenshots_generated = glob.glob(os.path.join(tmpdir, FRAME_FILENAME_PREFIX+"*"))
#import ipdb; ipdb.set_trace()
last_fn = self.ctrl.generate_frame_filename(tmpdir,len(screenshots_generated)-1, end_time)
self.assertEquals(6, len(screenshots_generated))
self.assertIn(last_fn, screenshots_generated)
print screenshots_generated
shutil.rmtree(tmpdir)
def test_export(self):
self.registerTweetsTimeLayer()
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("hours")
start_time = time_util.str_to_datetime(
self.timeLayer.getMinMaxValues()[0])
end_time = time_util.str_to_datetime(
self.timeLayer.getMinMaxValues()[1])
layer_duration_in_hours = (end_time -
start_time).total_seconds() / 3600.0
self.ctrl.exportVideo(tmpdir, 100, False)
screenshots_generated = glob.glob(
os.path.join(tmpdir, FRAME_FILENAME_PREFIX + "*"))
self.assertEqual(len(screenshots_generated),
math.ceil(layer_duration_in_hours + 1))
for i in range(int(math.ceil(layer_duration_in_hours + 1))):
fn = self.ctrl.generate_frame_filename(
tmpdir, i, start_time + timedelta(hours=i))
self.assertIn(fn, screenshots_generated)
shutil.rmtree(tmpdir)
def test_export_exports_last_frame(self):
settings = ls.LayerSettings()
settings.layer = self.layer
settings.startTimeAttribute = DATE_COL
settings.endTimeAttribute = DATE_COL
iface = Mock()
timeLayer = timevectorlayer.TimeVectorLayer(settings, iface)
self.tlm.registerTimeLayer(timeLayer)
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("seconds")
start_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[0])
end_time = time_util.str_to_datetime(timeLayer.getMinMaxValues()[1])
self.ctrl.exportVideo(tmpdir, 100, False)
screenshots_generated = glob.glob(
os.path.join(tmpdir, FRAME_FILENAME_PREFIX + "*"))
# import ipdb; ipdb.set_trace()
last_fn = self.ctrl.generateFrameFilename(
tmpdir,
len(screenshots_generated) - 1, end_time)
self.assertEquals(6, len(screenshots_generated))
self.assertIn(last_fn, screenshots_generated)
print screenshots_generated
shutil.rmtree(tmpdir)
def test_export_with_empty(self):
"""The tweets layer doesn't have tweets for every second. Test that when exporting part
of it with exportEmpty = False, not all possible frames are exported"""
self.registerTweetsTimeLayer()
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("seconds")
self.ctrl.exportEmpty = lambda: False
assert(self.ctrl.exportEmpty() == False)
end_time = time_util.str_to_datetime(self.timeLayer.getMinMaxValues()[1])
start_time = end_time - timedelta(seconds=100)
self.tlm.setCurrentTimePosition(start_time)
layer_duration_in_seconds = (end_time-start_time).total_seconds()
self.ctrl.exportVideoAtPath(tmpdir)
screenshots_generated = glob.glob(os.path.join(tmpdir, FRAME_FILENAME_PREFIX+"*"))
self.assertTrue(len(screenshots_generated) < math.ceil(layer_duration_in_seconds + 1))
shutil.rmtree(tmpdir)
def go_back_and_forth(self,fromAttr, toAttr):
self.registerTweetsTimeLayer(fromAttr, toAttr)
# The currentTimePosition should now be the first date in the shapefile
start_time = time_util.str_to_datetime(self.timeLayer.getMinMaxValues()[0])
assert( start_time == self.tlm.getCurrentTimePosition())
self.tlm.setTimeFrameType("hours")
self.tlm.stepForward()
assert( start_time + timedelta(hours=1)==self.tlm.getCurrentTimePosition())
self.tlm.stepForward()
assert( start_time + timedelta(hours=2)==self.tlm.getCurrentTimePosition())
self.tlm.stepBackward()
assert( start_time + timedelta(hours=1)==self.tlm.getCurrentTimePosition())
self.tlm.setTimeFrameType("seconds")
self.tlm.stepForward()
assert( start_time + timedelta(hours=1,seconds=1)==self.tlm.getCurrentTimePosition())
def test_export_with_empty(self):
"""The tweets layer doesn't have tweets for every second. Test that when exporting part
of it with exportEmpty = False, not all possible frames are exported"""
self.registerTweetsTimeLayer()
tmpdir = tempfile.mkdtemp()
self.tlm.setTimeFrameType("seconds")
self.ctrl.exportEmpty = lambda: False
assert (self.ctrl.exportEmpty() == False)
end_time = time_util.str_to_datetime(
self.timeLayer.getMinMaxValues()[1])
start_time = end_time - timedelta(seconds=100)
self.tlm.setCurrentTimePosition(start_time)
layer_duration_in_seconds = (end_time - start_time).total_seconds()
self.ctrl.exportVideo(tmpdir, 100, False)
screenshots_generated = glob.glob(
os.path.join(tmpdir, FRAME_FILENAME_PREFIX + "*"))
self.assertTrue(
len(screenshots_generated) < math.ceil(layer_duration_in_seconds +
1))
shutil.rmtree(tmpdir)
def go_back_and_forth(self, fromAttr, toAttr):
self.registerTweetsTimeLayer(fromAttr, toAttr)
# The currentTimePosition should now be the first date in the shapefile
start_time = time_util.str_to_datetime(
self.timeLayer.getMinMaxValues()[0])
assert (start_time == self.tlm.getCurrentTimePosition())
self.tlm.setTimeFrameType("hours")
self.tlm.stepForward()
assert (start_time +
timedelta(hours=1) == self.tlm.getCurrentTimePosition())
self.tlm.stepForward()
assert (start_time +
timedelta(hours=2) == self.tlm.getCurrentTimePosition())
self.tlm.stepBackward()
assert (start_time +
timedelta(hours=1) == self.tlm.getCurrentTimePosition())
self.tlm.setTimeFrameType("seconds")
self.tlm.stepForward()
assert (
start_time +
timedelta(hours=1, seconds=1) == self.tlm.getCurrentTimePosition())
def test_bc_date_additions(self):
for datestr in self.bc_dates:
dt = time_util.str_to_datetime(datestr)
new_date = dt + relativedelta(years=1)
assert (new_date.y == dt.y + 1)
def test_bc_date_conversions_str(self):
for datestr in self.bc_dates:
dt = time_util.str_to_datetime(datestr)
datestr2 = time_util.datetime_to_str(dt, None)
assert (datestr == datestr2)
def test_bc_date_additions(self):
for datestr in self.bc_dates:
dt = time_util.str_to_datetime(datestr)
new_date = dt + relativedelta(years=1)
assert (new_date.y == dt.y + 1)
def test_bc_date_conversions_str(self):
for datestr in self.bc_dates:
dt = time_util.str_to_datetime(datestr)
datestr2 = time_util.datetime_to_str(dt, None)
assert (datestr == datestr2)
