def test_temporal_select_operators2(self):
"""Testing the temporal select operator. Including temporal relations. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = A {:,equal|during} stvds(C)",
stdstype='str3ds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="str3ds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 3)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual( D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
ta = tgis.TemporalAlgebraParser(run=True, debug=True,
dry_run=True)
pc = ta.parse(expression="R = A {:,equal|during} stvds(C)",
stdstype='str3ds', basename="r", overwrite=True)
print(pc)
self.assertEqual(len(pc["register"]), 2)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "str3ds")
def test_temporal_extent3(self):
"""Testing the temporal extent operators."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(
expression="R = A {:,during,u} C",
stdstype="strds",
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
self.assertTrue(D.is_in_db())
D.select()
maplist = D.get_registered_maps_as_objects()
for map_i in maplist:
start_map, end_map = map_i.get_absolute_time()
self.assertEqual(start_map, datetime.datetime(2001, 1, 2))
self.assertEqual(end_map, datetime.datetime(2001, 1, 4))
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 3)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), False)
self.assertEqual(D.get_granularity(), "2 days")
def test_common_granularity_1(self):
"""Testing the common granularity function."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
expr = "R = A : B"
ret = ta.setup_common_granularity(expression=expr)
self.assertEqual(ret, True)
self.assertEqual(ta.granularity, "1 month")
ta.count = 0
ta.stdstype = "strds"
ta.maptype = "raster"
ta.mapclass = tgis.RasterDataset
maplist = ta.check_stds("A")
self.assertEqual(len(maplist), 6)
maplist = ta.check_stds("B")
self.assertEqual(len(maplist), 6)
ta.parse(expression=expr, basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertEqual(D.metadata.get_number_of_maps(), 6)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 6)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 7, 1))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 month")
def test_temporal_select_operators5(self):
"""Testing the temporal select operator. Including temporal relations and
temporal operators. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = C {:,contains} A",
stdstype='strds',
basename="r",
overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertTrue(D.is_in_db())
D.select()
maplist = D.get_registered_maps_as_objects()
for map_i in maplist:
start_map, end_map = map_i.get_absolute_time()
self.assertEqual(start_map, datetime.datetime(2001, 1, 2))
self.assertEqual(end_map, datetime.datetime(2001, 1, 4))
self.assertEqual(D.metadata.get_number_of_maps(), 1)
self.assertEqual(D.metadata.get_min_min(), 7)
self.assertEqual(D.metadata.get_max_max(), 7)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'2 days')
def main():
# lazy imports
import grass.temporal as tgis
expression = options["expression"]
spatial = flags["s"]
dry_run = flags["d"]
stdstype = options["type"]
# Check for PLY istallation
try:
# Intentionally unused imports
import ply.lex as lex # noqa: F401
import ply.yacc as yacc # noqa: F401
except ImportError:
grass.fatal(
_("Please install PLY (Lex and Yacc Python implementation) to use the temporal algebra modules."
))
tgis.init(True)
p = tgis.TemporalAlgebraParser(run=True,
debug=False,
spatial=spatial,
dry_run=dry_run)
pc = p.parse(expression, stdstype, overwrite=grass.overwrite())
if dry_run is True:
import pprint
pprint.pprint(pc)
def test_merge_function3(self):
"""Testing the merge function. """
ta = tgis.TemporalAlgebraParser(run=True, debug=False, dry_run=True)
pc = ta.parse(expression='R = merge(A, D {!:,equal} A)',
stdstype = 'strds', basename="r",
overwrite=True)
self.assertEqual(len(pc["register"]), 5)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "strds")
def test_buff2(self):
"""Testing the shift function. """
ta = tgis.TemporalAlgebraParser(run=True, debug=False, dry_run=True)
pc = ta.parse(expression='R = buff_t(A, "1 day") {:,contains,l} C',
stdstype = 'strds', basename="r",
overwrite=True)
print(pc["register"])
self.assertEqual(len(pc["register"]), 2)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "strds")
def test_different_stds_handling2(self):
"""Testing the handling of different stds types as output. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True,
dry_run=True)
pc = ta.parse(expression="R = if({during}, (stvds(C) {#,contains} str3ds(A)) == 2, str3ds(A))",
stdstype='strds', basename="r", overwrite=True)
self.assertEqual(len(pc["register"]), 2)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "strds")
def test_shift2(self):
"""Testing the shift function."""
ta = tgis.TemporalAlgebraParser(run=True, debug=False, dry_run=True)
pc = ta.parse(
expression='R = tshift(A, "2 days") {:,during,l} C',
stdstype="strds",
basename="r",
overwrite=True,
)
print(pc["register"])
self.assertEqual(len(pc["register"]), 1)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "strds")
def test_merge_function2(self):
"""Testing the merge function."""
ta = tgis.TemporalAlgebraParser(run=True, debug=False, dry_run=True)
pc = ta.parse(
expression="R = merge(A, B {!:,contains} A)",
stdstype="strds",
basename="r",
overwrite=True,
)
self.assertEqual(len(pc["register"]), 4)
self.assertEqual(pc["STDS"]["name"], "R")
self.assertEqual(pc["STDS"]["stdstype"], "strds")
def test_temporal_select_operators4(self):
"""Testing the temporal select operator. Including temporal relations and
temporal operators. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="V = C {:,contains} str3ds(A)",
stdstype='stvds', basename="r", overwrite=True)
D = tgis.open_old_stds("V", type="stvds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 1)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual( D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'2 days')
def test_temporal_select2(self):
"""Testing the temporal select operator with equal relations. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = A : D", stdstype = 'strds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 3)
self.assertEqual(D.metadata.get_max_max(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual( D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_different_stds_handling1(self):
"""Testing the handling of different stds types as output. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = if({during}, stvds(C) {#,contains} str3ds(A) == 2, str3ds(A))",
stdstype='strds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="str3ds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 3)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_temporal_condition_else_3(self):
"""Testing the temporal select operator with equal relations. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression='R = if({during},td(B) == 2 {&&,contains} start_date(D) >= "2001-01-04", A, D)',
basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 8)
self.assertEqual(D.metadata.get_max_max(), 9)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_temporal_condition_12(self):
"""Testing the temporal select operator with equal relations. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression='R = if(start_date(B) <= "2001-01-01" {&&,over,|,r} td(E) == 2, E)',
basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 1)
self.assertEqual(D.metadata.get_min_min(), 11)
self.assertEqual(D.metadata.get_max_max(), 11)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2000, 12, 31))
self.assertEqual(end, datetime.datetime(2001, 1, 2))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'2 days')
def test_temporal_hash_operator2(self):
"""Testing the hash operator function in conditional statement. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = if({during}, stvds(C) {#,contains} A == 2, A)",
stdstype='str3ds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="str3ds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 2)
self.assertEqual(D.metadata.get_max_max(), 3)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 2))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_merge_function2(self):
"""Testing the merge function. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression='R = merge(A, B {!:,contains} A)', stdstype = 'strds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
maplist = D.get_registered_maps_as_objects()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual( D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_temporal_hash1(self):
"""Testing the hash function in conditional statement. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = if(A # D == 1, A)", stdstype = 'strds', basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
maplist = D.get_registered_maps_as_objects()
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 3)
self.assertEqual(D.metadata.get_max_max(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual( D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_temporal_conditional_13(self):
"""Testing the hash operator function in conditional statement. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression='R = if({equal|during},td(B) == 2 {&&,contains} td(A) == 1, A)',
basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
D.select()
maplist = D.get_registered_maps_as_objects()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_common_granularity_6(self):
"""Testing the common granularity function year to month with gaps."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
expr = "R = if(start_month(A) > 2, A : C : D)"
ret = ta.setup_common_granularity(expression=expr)
ta.parse(expression=expr, basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertEqual(D.metadata.get_number_of_maps(), 2)
self.assertEqual(D.metadata.get_min_min(), 3)
self.assertEqual(D.metadata.get_max_max(), 5)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 3, 1))
self.assertEqual(end, datetime.datetime(2001, 6, 1))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 month")
def test_common_granularity_2(self):
"""Testing the common granularity function year to month samping. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
expr = 'R = A : C'
ret = ta.setup_common_granularity(expression=expr)
ta.parse(expression=expr, basename="r", overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertEqual(D.metadata.get_number_of_maps(), 6)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 6)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 7, 1))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 month')
def main():
expression = options['expression']
spatial = flags["s"]
stdstype = options["type"]
# Check for PLY istallation
try:
import ply.lex as lex
import ply.yacc as yacc
except:
grass.fatal(
_("Please install PLY (Lex and Yacc Python implementation) to use the temporal algebra modules."
))
tgis.init(True)
p = tgis.TemporalAlgebraParser(run=True, debug=False, spatial=spatial)
p.parse(expression, stdstype, overwrite=grass.overwrite)
def test_temporal_select_operators5(self):
"""Testing the temporal select operator. Including temporal relations and
temporal operators."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(
expression="R = A {:,during} strds(B)",
stdstype="str3ds",
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="str3ds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 day")
def test_temporal_condition_3(self):
"""Testing the temporal select operator with equal relations."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(
expression='R = if(td(A) == 1 || start_date(A) >= "2001-01-03", A)',
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
D.select()
self.assertEqual(D.metadata.get_number_of_maps(), 4)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 4)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), "1 day")
def test_merge_function1(self):
"""Testing the merge function."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression="R = merge(A,D)",
stdstype="strds",
basename="r",
overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertTrue(D.is_in_db())
D.select()
maplist = D.get_registered_maps_as_objects()
self.assertEqual(D.metadata.get_number_of_maps(), 7)
self.assertEqual(D.metadata.get_min_min(), 1)
self.assertEqual(D.metadata.get_max_max(), 10)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 1))
self.assertEqual(end, datetime.datetime(2001, 1, 6))
self.assertEqual(D.check_temporal_topology(), False)
self.assertEqual(D.get_granularity(), "1 day")
def test_tmap_function1(self):
"""Testing the tmap function. """
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(expression='R = tmap(singletmap)',
stdstype='strds',
basename="r",
overwrite=True)
D = tgis.open_old_stds("R", type="strds")
self.assertTrue(D.is_in_db())
D.select()
maplist = D.get_registered_maps_as_objects()
self.assertEqual(D.metadata.get_number_of_maps(), 1)
self.assertEqual(D.metadata.get_min_min(), 99)
self.assertEqual(D.metadata.get_max_max(), 99)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2001, 1, 3))
self.assertEqual(end, datetime.datetime(2001, 1, 4))
self.assertEqual(D.check_temporal_topology(), True)
self.assertEqual(D.get_granularity(), u'1 day')
def test_temporal_condition_else_4(self):
"""Testing the temporal select operator with equal relations."""
ta = tgis.TemporalAlgebraParser(run=True, debug=True)
ta.parse(
expression=
'R = if({equal|over},start_date(B) <= "2001-01-01" {&&,over,|,r} td(E) == 2, E, B)',
basename="r",
overwrite=True,
)
D = tgis.open_old_stds("R", type="strds")
D.select()
for map in D.get_registered_maps_as_objects():
print(map.get_map_id())
self.assertEqual(D.metadata.get_number_of_maps(), 3)
self.assertEqual(D.metadata.get_min_min(), 5)
self.assertEqual(D.metadata.get_max_max(), 11)
start, end = D.get_absolute_time()
self.assertEqual(start, datetime.datetime(2000, 12, 31))
self.assertEqual(end, datetime.datetime(2001, 1, 5))
self.assertEqual(D.check_temporal_topology(), False)
self.assertEqual(D.get_granularity(), "2 days")
