diff --git a/python/grass/temporal/register.py b/python/grass/temporal/register.py index f223e74398a..f5ac1eef577 100644 --- a/python/grass/temporal/register.py +++ b/python/grass/temporal/register.py @@ -154,18 +154,12 @@ def register_maps_in_space_time_dataset( maplist = maps.split(",") # Build the map list again with the ids - for count in range(len(maplist)): - row = {} - mapname = maplist[count] - map_mapset = mapset - if "@" not in mapname: - found = gscript.find_file(element=type, name=mapname) - if found["mapset"] is not None and len(found["mapset"]) > 0: - map_mapset = found["mapset"] - mapid = AbstractMapDataset.build_id(mapname, map_mapset, None) - - row["id"] = mapid - maplist[count] = row + for idx, maplist_item in enumerate(maplist): + maplist[idx] = { + "id": AbstractMapDataset.build_id( + maplist_item, mapset, check_mapset_element=type + ) + } # Read the map list from file if file: @@ -209,24 +203,20 @@ def register_maps_in_space_time_dataset( mapname = line_list[0].strip() row = {} - if start_time_in_file and end_time_in_file: + if start_time_in_file: row["start"] = line_list[1].strip() - row["end"] = line_list[2].strip() - if start_time_in_file and not end_time_in_file: - row["start"] = line_list[1].strip() + if end_time_in_file: + row["end"] = line_list[2].strip() if semantic_label_in_file: idx = 3 if end_time_in_file else 2 # case-sensitive, the user decides on the band name row["semantic_label"] = line_list[idx].strip() - map_mapset = mapset - if "@" not in mapname: - found = gscript.find_file(element=type, name=mapname) - if found["mapset"] is not None and len(found["mapset"]) > 0: - map_mapset = found["mapset"] - row["id"] = AbstractMapDataset.build_id(mapname, map_mapset) + row["id"] = AbstractMapDataset.build_id( + mapname, mapset, check_mapset_element=type + ) maplist.append(row) diff --git a/temporal/t.register/test.t.register.raster.file.sh b/temporal/t.register/test.t.register.raster.file.sh deleted file mode 100755 index ce23b19f1fe..00000000000 --- a/temporal/t.register/test.t.register.raster.file.sh +++ /dev/null @@ -1,83 +0,0 @@ -#!/bin/sh -# This is a test to register and unregister raster maps in -# space time raster input. -# The raster maps will be registered in different space time raster -# inputs - -# We need to set a specific region in the -# @preprocess step of this test. We generate -# raster with r.mapcalc and create two space time raster inputs -# with absolute time -# The region setting should work for UTM and LL test locations -g.region s=0 n=80 w=0 e=120 b=0 t=50 res=10 res3=10 -p3 - -# Generate data -r.mapcalc --o expr="prec_1 = rand(0, 550)" -s -r.mapcalc --o expr="prec_2 = rand(0, 450)" -s -r.mapcalc --o expr="prec_3 = rand(0, 320)" -s -r.mapcalc --o expr="prec_4 = rand(0, 510)" -s -r.mapcalc --o expr="prec_5 = rand(0, 300)" -s -r.mapcalc --o expr="prec_6 = rand(0, 650)" -s - -n1=`g.tempfile pid=1 -d` # Only map names -n2=`g.tempfile pid=2 -d` # Map names and start time -n3=`g.tempfile pid=3 -d` # Map names start time and increment - -cat > "${n1}" << EOF -prec_1 -prec_2 -prec_3 -prec_4 -prec_5 -prec_6 -EOF -cat "${n1}" - -cat > "${n2}" << EOF -prec_1|2001-01-01 -prec_2|2001-02-01 -prec_3|2001-03-01 -prec_4|2001-04-01 -prec_5|2001-05-01 -prec_6|2001-06-01 -EOF -cat "${n2}" - -cat > "${n3}" << EOF -prec_1|2001-01-01|2001-04-01 -prec_2|2001-04-01|2001-07-01 -prec_3|2001-07-01|2001-10-01 -prec_4|2001-10-01|2002-01-01 -prec_5|2002-01-01|2002-04-01 -prec_6|2002-04-01|2002-07-01 -EOF -cat "${n3}" - -# The first @test -# We create the space time raster inputs and register the raster maps with absolute time interval -t.create --o type=strds temporaltype=absolute output=precip_abs8 title="A test with input files" descr="A test with input files" - -# Test with input files -# File 1 -t.register --o -i input=precip_abs8 file="${n1}" start="2001-01-01" increment="1 months" -t.info type=strds input=precip_abs8 -t.rast.list input=precip_abs8 -# File 1 -t.register --o input=precip_abs8 file="${n1}" start="2001-01-01" -t.info type=strds input=precip_abs8 -t.rast.list input=precip_abs8 -# File 2 -t.register --o input=precip_abs8 file="${n2}" -t.info type=strds input=precip_abs8 -t.rast.list input=precip_abs8 -# File 2 -t.register --o input=precip_abs8 file="${n2}" increment="1 months" -t.info type=strds input=precip_abs8 -t.rast.list input=precip_abs8 -# File 3 -t.register --o -i input=precip_abs8 file="${n3}" -t.info type=strds input=precip_abs8 -t.rast.list input=precip_abs8 - -t.remove --v type=strds input=precip_abs8 -t.unregister --v type=raster file="${n1}" diff --git a/temporal/t.register/test.t.register.raster.sh b/temporal/t.register/test.t.register.raster.sh deleted file mode 100755 index f27d133e9a7..00000000000 --- a/temporal/t.register/test.t.register.raster.sh +++ /dev/null @@ -1,128 +0,0 @@ -#!/bin/sh -# This is a test to register and unregister raster maps in -# space time raster datasets. -# The raster maps will be registered in different space time raster -# datasets. - -export GRASS_OVERWRITE=1 - -# We need to set a specific region in the -# @preprocess step of this test. We generate -# raster with r.mapcalc and create several space time raster datasets -# with absolute time -# The region setting should work for UTM and LL test locations -g.region s=0 n=80 w=0 e=120 b=0 t=50 res=10 res3=10 -p3 - -# Generate data -r.mapcalc expr="prec_1 = rand(0, 550)" -s -r.mapcalc expr="prec_2 = rand(0, 450)" -s -r.mapcalc expr="prec_3 = rand(0, 320)" -s -r.mapcalc expr="prec_4 = rand(0, 510)" -s -r.mapcalc expr="prec_5 = rand(0, 300)" -s -r.mapcalc expr="prec_6 = rand(0, 650)" -s - -# The first @test -# We create the space time raster inputs and register the raster maps with absolute time interval - -t.create type=strds temporaltype=absolute output=precip_abs1 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs2 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs3 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs4 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs5 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs6 title="A test" descr="A test" -t.create type=strds temporaltype=absolute output=precip_abs7 title="A test" descr="A test" - -t.register -i input=precip_abs1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="1 seconds" -t.info type=strds input=precip_abs1 -t.info -g type=strds input=precip_abs1 -r.info map=prec_1 -t.rast.list input=precip_abs1 -t.topology input=precip_abs1 - -t.register -i input=precip_abs2 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="20 seconds, 5 minutes" -t.info type=strds input=precip_abs2 -t.info -g type=strds input=precip_abs2 -r.info map=prec_1 -t.rast.list input=precip_abs2 -t.topology input=precip_abs2 - -t.register -i input=precip_abs3 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="8 hours" -t.info -g type=strds input=precip_abs3 -r.info map=prec_1 -t.rast.list input=precip_abs3 -t.topology input=precip_abs3 - -t.register input=precip_abs4 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="3 days" -t.info -g type=strds input=precip_abs4 -r.info map=prec_1 -t.rast.list input=precip_abs4 -t.topology input=precip_abs4 - -t.register input=precip_abs5 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="4 weeks" -t.info -g type=strds input=precip_abs5 -r.info map=prec_1 -t.rast.list input=precip_abs5 -t.topology input=precip_abs5 - -t.register input=precip_abs6 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-08-01" increment="2 months" -t.info -g type=strds input=precip_abs6 -r.info map=prec_1 -t.rast.list input=precip_abs6 -t.topology input=precip_abs6 - -t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="20 years, 3 months, 1 days, 4 hours" -t.info -g type=strds input=precip_abs7 -r.info map=prec_1 -t.rast.list input=precip_abs7 -t.topology input=precip_abs7 -# Register with different valid time again -t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="99 years, 9 months, 9 days, 9 hours" -t.info -g type=strds input=precip_abs7 -r.info map=prec_1 -t.rast.list input=precip_abs7 -t.topology input=precip_abs7 -# Register with different valid time again creating an interval -t.register -i input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="99 years, 9 months, 9 days, 9 hours" -t.info -g type=strds input=precip_abs7 -r.info map=prec_1 -t.rast.list input=precip_abs7 -t.topology input=precip_abs7 - -t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" end="2002-01-01" -t.info -g type=strds input=precip_abs7 -r.info map=prec_1 -t.rast.list input=precip_abs7 -t.topology input=precip_abs7 - -# Check for correct errors -# Increment format error -t.register -i input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="months" - -# Check UnicodeDecodeError -LANG=fr_BE \ -LANGUAGE=fr_BE \ -LC_CTYPE=fr_BE.UTF-8 \ -LC_NUMERIC=C \ -LC_TIME=fr_BE.UTF-8 \ -LC_COLLATE=fr_BE.UTF-8 \ -LC_MONETARY=fr_BE.UTF-8 \ -LC_MESSAGES=fr_BE.UTF-8 \ -LC_PAPER=fr_BE.UTF-8 \ -LC_NAME=fr_BE.UTF-8 \ -LC_ADDRESS=fr_BE.UTF-8 \ -LC_TELEPHONE=fr_BE.UTF-8 \ -LC_MEASUREMENT=fr_BE.UTF-8 \ -LC_IDENTIFICATION=fr_BE.UTF-8 \ -LC_ALL="" \ -t.create output=pluies_nc semantictype=sum title=precipitation_mois description="Précipitation totale mensuelle NC" --o -t.register -i input=pluies_nc type=raster start=2000-01-01 increment="1 months" maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 --o -t.info pluies_nc -t.topology pluies_nc -t.remove -f pluies_nc - -t.unregister type=raster maps=prec_1,prec_2,prec_3 -# Test the warning message -t.unregister type=raster maps=prec_1,prec_2,prec_3 -t.remove type=strds input=precip_abs1,precip_abs2,precip_abs3,precip_abs4,precip_abs5,precip_abs6,precip_abs7 -t.unregister type=raster maps=prec_4,prec_5,prec_6 -r.info map=prec_1 diff --git a/temporal/t.register/testsuite/test_t_register_raster.py b/temporal/t.register/testsuite/test_t_register_raster.py new file mode 100755 index 00000000000..12522ce062b --- /dev/null +++ b/temporal/t.register/testsuite/test_t_register_raster.py @@ -0,0 +1,463 @@ +"""Test t.register + +(C) 2014-2023 by the GRASS Development Team +This program is free software under the GNU General Public +License (>=v2). Read the file COPYING that comes with GRASS +for details. + +@author Soeren Gebbert + Ported to Python by Stefan Blumentrath + +This is a test to register and unregister raster maps in +space time raster input. +The raster maps will be registered in different space time raster +inputs + +We need to set a specific region in the +@preprocess step of this test. We generate +raster with r.mapcalc and create two space time raster inputs +with absolute time +The region setting should work for UTM and LL test locations + +""" + +from datetime import datetime + +import grass.script as gs +import grass.temporal as tgis + +from grass.gunittest.case import TestCase +from grass.gunittest.gmodules import SimpleModule + + +class TestRegister(TestCase): + @classmethod + def setUpClass(cls): + """Initiate the temporal GIS and set the region""" + + tgis.init() + # cls.mapset = gs.gisenv()["MAPSET"] + cls.use_temp_region() + cls.runModule( + "g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10, flags="p3" + ) + + # Generate data + cls.runModule( + "r.mapcalc", flags="s", expression="prec_1 = rand(0, 550)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_2 = rand(0, 450)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_3 = rand(0, 320)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_4 = rand(0, 510)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_5 = rand(0, 300)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_6 = rand(0, 650)", overwrite=True + ) + + for strds_id in range(1, 9): + cls.runModule( + "t.create", + type="strds", + temporaltype="absolute", + output=f"precip_abs{strds_id}", + title="A test", + description="A test", + overwrite=True, + ) + + @classmethod + def tearDownClass(cls): + """Remove the temporary region""" + stds = gs.read_command("t.list") + for strds_id in range(1, 9): + if f"precip_abs{strds_id}" in stds: + cls.runModule( + "t.remove", flags="df", type="strds", inputs=f"precip_abs{strds_id}" + ) + cls.del_temp_region() + + def test_with_second_increment_and_intervall(self): + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs1", + start="2001-01-01", + increment="1 seconds", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs1", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1, 0, 0, 0)) + self.assertEqual(end, datetime(2001, 1, 1, 0, 0, 6)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "1 second") + + print(gs.read_command("t.info", type="strds", input="precip_abs1")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs1") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-01-01 00:00:01", + "prec_2|...|2001-01-01 00:00:01|2001-01-01 00:00:02", + "prec_3|...|2001-01-01 00:00:02|2001-01-01 00:00:03", + "prec_4|...|2001-01-01 00:00:03|2001-01-01 00:00:04", + "prec_5|...|2001-01-01 00:00:04|2001-01-01 00:00:05", + "prec_6|...|2001-01-01 00:00:05|2001-01-01 00:00:06", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_minutes_seconds_increment_and_intervall(self): + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs2", + start="2001-01-01", + increment="20 seconds, 5 minutes", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs2", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 1, 1, 0, 32)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "320 seconds") + + print(gs.read_command("t.info", type="strds", input="precip_abs2")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs2") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-01-01 00:05:20", + "prec_2|...|2001-01-01 00:05:20|2001-01-01 00:10:40", + "prec_3|...|2001-01-01 00:10:40|2001-01-01 00:16:00", + "prec_4|...|2001-01-01 00:16:00|2001-01-01 00:21:20", + "prec_5|...|2001-01-01 00:21:20|2001-01-01 00:26:40", + "prec_6|...|2001-01-01 00:26:40|2001-01-01 00:32:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_hours_increment_and_intervall(self): + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs3", + start="2001-01-01", + increment="8 hours", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + print(gs.read_command("t.info", type="strds", input="precip_abs3")) + strds = tgis.open_old_stds("precip_abs3", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 1, 3)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "8 hours") + + print(gs.read_command("t.info", type="strds", input="precip_abs3")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs3") + t_rast_list.run() + + # Check registered raster maps + ref_str = "\n".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-01-01 08:00:00", + "prec_2|...|2001-01-01 08:00:00|2001-01-01 16:00:00", + "prec_3|...|2001-01-01 16:00:00|2001-01-02 00:00:00", + "prec_4|...|2001-01-02 00:00:00|2001-01-02 08:00:00", + "prec_5|...|2001-01-02 08:00:00|2001-01-02 16:00:00", + "prec_6|...|2001-01-02 16:00:00|2001-01-03 00:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_days_increment_and_no_intervall(self): + register_module = SimpleModule( + "t.register", + input="precip_abs4", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-01-01", + increment="3 days", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs4", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 1, 16)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "3 days") + + print(gs.read_command("t.info", type="strds", input="precip_abs4")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs4") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2001-01-04 00:00:00|None", + "prec_3|...|2001-01-07 00:00:00|None", + "prec_4|...|2001-01-10 00:00:00|None", + "prec_5|...|2001-01-13 00:00:00|None", + "prec_6|...|2001-01-16 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_weeks_increment_and_no_intervall(self): + register_module = SimpleModule( + "t.register", + input="precip_abs5", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-01-01", + increment="4 weeks", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs5", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 5, 21)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "28 days") + + print(gs.read_command("t.info", type="strds", input="precip_abs5")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs5") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2001-01-29 00:00:00|None", + "prec_3|...|2001-02-26 00:00:00|None", + "prec_4|...|2001-03-26 00:00:00|None", + "prec_5|...|2001-04-23 00:00:00|None", + "prec_6|...|2001-05-21 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_months_increment_and_no_intervall(self): + register_module = SimpleModule( + "t.register", + input="precip_abs6", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-08-01", + increment="2 months", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs6", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 8, 1)) + self.assertEqual(end, datetime(2002, 6, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "2 months") + + print(gs.read_command("t.info", type="strds", input="precip_abs6")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs6") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-08-01 00:00:00|None", + "prec_2|...|2001-10-01 00:00:00|None", + "prec_3|...|2001-12-01 00:00:00|None", + "prec_4|...|2002-02-01 00:00:00|None", + "prec_5|...|2002-04-01 00:00:00|None", + "prec_6|...|2002-06-01 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_re_registering(self): + # t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="20 years, 3 months, 1 days, 4 hours" + # t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="99 years, 9 months, 9 days, 9 hours" + # t.register -i input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" increment="99 years, 9 months, 9 days, 9 hours" + # t.register input=precip_abs7 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-01-01" end="2002-01-01" + register_module = SimpleModule( + "t.register", + input="precip_abs7", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-01-01", + increment="20 years, 3 months, 1 days, 4 hours", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs7", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2102, 4, 6, 20, 0)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "4 hours") + + print(gs.read_command("t.info", type="strds", input="precip_abs7")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs7") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2021-04-02 04:00:00|None", + "prec_3|...|2041-07-03 08:00:00|None", + "prec_4|...|2061-10-04 12:00:00|None", + "prec_5|...|2082-01-05 16:00:00|None", + "prec_6|...|2102-04-06 20:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + # Register with different valid time again + register_module = SimpleModule( + "t.register", + input="precip_abs7", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-01-01", + increment="99 years, 9 months, 9 days, 9 hours", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs7", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2499, 11, 16, 21, 0)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "3 hours") + + # Check raster map metadata (time stamp) + self.assertRasterFitsInfo( + raster="prec_3", + reference='timestamp="19 Jul 2200 18:00:00"', + ) + + print(gs.read_command("t.info", type="strds", input="precip_abs7")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs7") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2100-10-10 09:00:00|None", + "prec_3|...|2200-07-19 18:00:00|None", + "prec_4|...|2300-04-29 03:00:00|None", + "prec_5|...|2400-02-07 12:00:00|None", + "prec_6|...|2499-11-16 21:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + # Register with different valid time again creating an interval + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs7", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + start="2001-01-01", + increment="99 years, 9 months, 9 days, 9 hours", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs7", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2599, 8, 26, 6, 0)) + self.assertEqual(strds.check_temporal_topology(), False) + self.assertEqual(strds.get_granularity(), "3 hours") + + # Check raster map metadata (time stamp) + self.assertRasterFitsInfo( + raster="prec_3", + reference='timestamp="19 Jul 2200 18:00:00 / 29 Apr 2300 03:00:00"', + ) + + print(gs.read_command("t.info", type="strds", input="precip_abs7")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs7") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2100-10-10 09:00:00", + "prec_2|...|2100-10-10 09:00:00|2200-07-19 18:00:00", + "prec_3|...|2200-07-19 18:00:00|2300-04-29 03:00:00", + "prec_4|...|2300-04-29 03:00:00|2400-02-07 12:00:00", + "prec_5|...|2400-02-07 12:00:00|2499-11-17 21:00:00", + "prec_6|...|2499-11-16 21:00:00|2599-08-26 06:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + +if __name__ == "__main__": + from grass.gunittest.main import test + + test() diff --git a/temporal/t.register/testsuite/test_t_register_raster_different_local.py b/temporal/t.register/testsuite/test_t_register_raster_different_local.py new file mode 100644 index 00000000000..f66d4297f32 --- /dev/null +++ b/temporal/t.register/testsuite/test_t_register_raster_different_local.py @@ -0,0 +1,150 @@ +"""Test t.register + +(C) 2014-2023 by the GRASS Development Team +This program is free software under the GNU General Public +License (>=v2). Read the file COPYING that comes with GRASS +for details. + +@author Soeren Gebbert + Ported to Python by Stefan Blumentrath + +This is a test to register and unregister raster maps in +space time raster input. +The raster maps will be registered in different space time raster +inputs + +We need to set a specific region in the +@preprocess step of this test. We generate +raster with r.mapcalc and create two space time raster inputs +with absolute time +The region setting should work for UTM and LL test locations + +""" + +import os +from datetime import datetime + +import grass.script as gs +import grass.temporal as tgis + +from grass.gunittest.case import TestCase +from grass.gunittest.gmodules import SimpleModule + + +class TestRegisterDifferentLocal(TestCase): + @classmethod + def setUpClass(cls): + """Initiate the temporal GIS and set the region""" + + # Check UnicodeDecodeError + os.environ["LANG"] = "fr_BE" + os.environ["LANGUAGE"] = "fr_BE" + os.environ["LC_CTYPE"] = "fr_BE.UTF-8" + os.environ["LC_NUMERIC"] = "C" + os.environ["LC_TIME"] = "fr_BE.UTF-8" + os.environ["LC_COLLATE"] = "fr_BE.UTF-8" + os.environ["LC_MONETARY"] = "fr_BE.UTF-8" + os.environ["LC_MESSAGES"] = "fr_BE.UTF-8" + os.environ["LC_PAPER"] = "fr_BE.UTF-8" + os.environ["LC_NAME"] = "fr_BE.UTF-8" + os.environ["LC_ADDRESS"] = "fr_BE.UTF-8" + os.environ["LC_TELEPHONE"] = "fr_BE.UTF-8" + os.environ["LC_MEASUREMENT"] = "fr_BE.UTF-8" + os.environ["LC_IDENTIFICATION"] = "fr_BE.UTF-8" + os.environ["LC_ALL"] = "" + + tgis.init() + # cls.mapset = gs.gisenv()["MAPSET"] + cls.use_temp_region() + cls.runModule( + "g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10, flags="p3" + ) + + for raster_map_id, parameters in enumerate( + [ + (550, "2001-01-01 00:00:00|2001-01-01 08:00:00"), + (450, "2001-01-01 08:00:00|2001-01-01 16:00:00"), + (320, "2001-01-01 16:00:00|2001-01-02 00:00:00"), + (510, "2001-01-02 00:00:00|2001-01-02 08:00:00"), + (300, "2001-01-02 08:00:00|2001-01-02 16:00:00"), + (650, "2001-01-02 16:00:00|2001-01-03 00:00:00"), + ] + ): + # Generate data + cls.runModule( + "r.mapcalc", + flags="s", + expression=f"prec_{raster_map_id + 1} = rand(0, {parameters[0]})", + overwrite=True, + ) + cls.runModule( + "r.support", + map=f"prec_{raster_map_id + 1}", + # Note: Non-ascii characters in semantic labels lead to decode error + # semantic_label="Précipitation_totale", + semantic_label="semantic_label", + ) + + cls.runModule( + "t.create", + output="pluies_nc", + semantictype="sum", + title="precipitation_mois", + description="Précipitation totale mensuelle NC", + overwrite=True, + ) + + @classmethod + def tearDownClass(cls): + """Remove the temporary region""" + cls.runModule("t.remove", flags="df", type="strds", inputs="pluies_nc") + cls.del_temp_region() + + def test_with_different_local(self): + register_module = SimpleModule( + "t.register", + flags="i", + input="pluies_nc", + type="raster", + start="2000-01-01", + increment="1 months", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + overwrite=True, + ) + # t.info pluies_nc + # t.topology pluies_nc + # t.remove -f pluies_nc + self.assertModule(register_module) + + strds = tgis.open_old_stds("pluies_nc", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2000, 1, 1)) + self.assertEqual(end, datetime(2000, 7, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "1 month") + + print(gs.read_command("t.info", type="strds", input="pluies_nc")) + t_rast_list = SimpleModule("t.rast.list", input="pluies_nc") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2000-01-01 00:00:00|2000-02-01 00:00:00", + "prec_2|...|2000-02-01 00:00:00|2000-03-01 00:00:00", + "prec_3|...|2000-03-01 00:00:00|2000-04-01 00:00:00", + "prec_4|...|2000-04-01 00:00:00|2000-05-01 00:00:00", + "prec_5|...|2000-05-01 00:00:00|2000-06-01 00:00:00", + "prec_6|...|2000-06-01 00:00:00|2000-07-01 00:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + +if __name__ == "__main__": + from grass.gunittest.main import test + + test() diff --git a/temporal/t.register/testsuite/test_t_register_raster_file.py b/temporal/t.register/testsuite/test_t_register_raster_file.py new file mode 100755 index 00000000000..b99fa7c8e6e --- /dev/null +++ b/temporal/t.register/testsuite/test_t_register_raster_file.py @@ -0,0 +1,380 @@ +"""Test t.register + +(C) 2014-2023 by the GRASS Development Team +This program is free software under the GNU General Public +License (>=v2). Read the file COPYING that comes with GRASS +for details. + +@author Soeren Gebbert + Ported to Python by Stefan Blumentrath + +This is a test to register and unregister raster maps in +space time raster input. +The raster maps will be registered in different space time raster +inputs + +We need to set a specific region in the +@preprocess step of this test. We generate +raster with r.mapcalc and create two space time raster inputs +with absolute time +The region setting should work for UTM and LL test locations + +""" + +from datetime import datetime + +import grass.script as gs +import grass.temporal as tgis + +from grass.gunittest.case import TestCase +from grass.gunittest.gmodules import SimpleModule + + +class TestRegisterFile(TestCase): + @classmethod + def setUpClass(cls): + """Initiate the temporal GIS and set the region""" + + tgis.init() + # cls.mapset = gs.gisenv()["MAPSET"] + cls.use_temp_region() + cls.runModule( + "g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10, flags="p3" + ) + + # Generate data + cls.runModule( + "r.mapcalc", flags="s", expression="prec_1 = rand(0, 550)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_2 = rand(0, 450)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_3 = rand(0, 320)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_4 = rand(0, 510)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_5 = rand(0, 300)", overwrite=True + ) + cls.runModule( + "r.mapcalc", flags="s", expression="prec_6 = rand(0, 650)", overwrite=True + ) + + cls.runModule( + "t.create", + type="strds", + temporaltype="absolute", + output="precip_abs8", + title="A test with input files", + description="A test with input files", + overwrite=True, + ) + + @classmethod + def tearDownClass(cls): + """Remove the temporary region""" + cls.runModule("t.remove", flags="df", type="strds", inputs="precip_abs8") + cls.del_temp_region() + + def test_with_file_and_increment(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write("prec_1\nprec_2\nprec_3\nprec_4\nprec_5\nprec_6") + + register_module = SimpleModule( + "t.register", + input="precip_abs8", + start="2001-01-01", + increment="1 months", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs8", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 6, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "1 month") + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs8") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2001-02-01 00:00:00|None", + "prec_3|...|2001-03-01 00:00:00|None", + "prec_4|...|2001-04-01 00:00:00|None", + "prec_5|...|2001-05-01 00:00:00|None", + "prec_6|...|2001-06-01 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_file_and_no_increment(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write("prec_1\nprec_2\nprec_3\nprec_4\nprec_5\nprec_6") + + register_module = SimpleModule( + "t.register", + input="precip_abs8", + start="2001-01-01", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs8", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 1, 1)) + self.assertEqual(strds.check_temporal_topology(), False) + self.assertEqual(strds.get_granularity(), None) + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs8") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2001-01-01 00:00:00|None", + "prec_3|...|2001-01-01 00:00:00|None", + "prec_4|...|2001-01-01 00:00:00|None", + "prec_5|...|2001-01-01 00:00:00|None", + "prec_6|...|2001-01-01 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_file_increment_and_intervall(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write("prec_1\nprec_2\nprec_3\nprec_4\nprec_5\nprec_6") + + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs8", + start="2001-01-01", + increment="1 months", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + strds = tgis.open_old_stds("precip_abs8", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 7, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "1 month") + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs8") + t_rast_list.run() + + # Check registered raster maps + ref_str = "\n".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-02-01 00:00:00", + "prec_2|...|2001-02-01 00:00:00|2001-03-01 00:00:00", + "prec_3|...|2001-03-01 00:00:00|2001-04-01 00:00:00", + "prec_4|...|2001-04-01 00:00:00|2001-05-01 00:00:00", + "prec_5|...|2001-05-01 00:00:00|2001-06-01 00:00:00", + "prec_6|...|2001-06-01 00:00:00|2001-07-01 00:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_start_in_file(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write( + "\n".join( + [ + "prec_1|2001-01-01", + "prec_2|2001-02-01", + "prec_3|2001-03-01", + "prec_4|2001-04-01", + "prec_5|2001-05-01", + "prec_6|2001-06-01", + ] + ) + ) + + register_module = SimpleModule( + "t.register", + input="precip_abs8", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs8", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 6, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "1 month") + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs8") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|None", + "prec_2|...|2001-02-01 00:00:00|None", + "prec_3|...|2001-03-01 00:00:00|None", + "prec_4|...|2001-04-01 00:00:00|None", + "prec_5|...|2001-05-01 00:00:00|None", + "prec_6|...|2001-06-01 00:00:00|None", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + def test_with_start_in_file_and_increment(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write( + "\n".join( + [ + "prec_1|2001-01-01", + "prec_2|2001-02-01", + "prec_3|2001-03-01", + "prec_4|2001-04-01", + "prec_5|2001-05-01", + "prec_6|2001-06-01", + ] + ) + ) + + register_module = SimpleModule( + "t.register", + input="precip_abs8", + increment="1 months", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModuleFail(register_module) + + # print(gs.read_command("t.info", type="strds", input="precip_abs8")) + # print(gs.read_command("t.rast.list", input="precip_abs8")) + + def test_with_start_and_end_in_file_and_interval(self): + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write( + "\n".join( + [ + "prec_1|2001-01-01|2001-04-01", + "prec_2|2001-04-01|2001-07-01", + "prec_3|2001-07-01|2001-10-01", + "prec_4|2001-10-01|2002-01-01", + "prec_5|2002-01-01|2002-04-01", + "prec_6|2002-04-01|2002-07-01", + ] + ) + ) + + register_module = SimpleModule( + "t.register", + flags="i", + input="precip_abs8", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModuleFail(register_module) + + # print(gs.read_command("t.info", type="strds", input="precip_abs8")) + # print(gs.read_command("t.rast.list", input="precip_abs8")) + + def test_with_mapset_and_semantic_label(self): + mapset = gs.gisenv()["MAPSET"] + tmp_file = gs.tempfile() + with open(tmp_file, "w") as register_file: + register_file.write( + "\n".join( + [ + f"prec_1@{mapset}|2001-01-01|2001-04-01|semantic_label", + f"prec_2@{mapset}|2001-04-01|2001-07-01|semantic_label", + f"prec_3@{mapset}|2001-07-01|2001-10-01|semantic_label", + f"prec_4@{mapset}|2001-10-01|2002-01-01|semantic_label", + f"prec_5@{mapset}|2002-01-01|2002-04-01|semantic_label", + f"prec_6@{mapset}|2002-04-01|2002-07-01|semantic_label", + ] + ) + ) + + register_module = SimpleModule( + "t.register", + input="precip_abs8", + file=tmp_file, + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + strds = tgis.open_old_stds("precip_abs8", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2002, 7, 1)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "3 months") + self.assertEqual(strds.metadata.get_number_of_semantic_labels(), 1) + self.assertEqual(strds.metadata.get_semantic_labels(), "semantic_label") + + print(gs.read_command("t.info", type="strds", input="precip_abs8")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs8") + t_rast_list.run() + + # Check registered raster maps + ref_str = "...".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-04-01 00:00:00", + "prec_2|...|2001-04-01 00:00:00|2001-07-01 00:00:00", + "prec_3|...|2001-07-01 00:00:00|2001-10-01 00:00:00", + "prec_4|...|2001-10-01 00:00:00|2002-01-01 00:00:00", + "prec_5|...|2002-01-01 00:00:00|2002-04-01 00:00:00", + "prec_6|...|2002-04-01 00:00:00|2002-07-01 00:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + +if __name__ == "__main__": + from grass.gunittest.main import test + + test() diff --git a/temporal/t.register/testsuite/test_t_register_raster_mapmetadata.py b/temporal/t.register/testsuite/test_t_register_raster_mapmetadata.py new file mode 100644 index 00000000000..914e91cda6f --- /dev/null +++ b/temporal/t.register/testsuite/test_t_register_raster_mapmetadata.py @@ -0,0 +1,141 @@ +"""Test t.register + +(C) 2014-2023 by the GRASS Development Team +This program is free software under the GNU General Public +License (>=v2). Read the file COPYING that comes with GRASS +for details. + +@author Soeren Gebbert + Ported to Python by Stefan Blumentrath + +This is a test to register and unregister raster maps in +space time raster input. +The raster maps will be registered in different space time raster +inputs + +We need to set a specific region in the +@preprocess step of this test. We generate +raster with r.mapcalc and create two space time raster inputs +with absolute time +The region setting should work for UTM and LL test locations + +""" + +from datetime import datetime + +import grass.script as gs +import grass.temporal as tgis + +from grass.gunittest.case import TestCase +from grass.gunittest.gmodules import SimpleModule +from grass.temporal.datetime_math import ( + datetime_to_grass_datetime_string as datetime_to_grass, +) + + +class TestRegisterMapMetadata(TestCase): + @classmethod + def setUpClass(cls): + """Initiate the temporal GIS and set the region""" + + tgis.init() + # cls.mapset = gs.gisenv()["MAPSET"] + cls.use_temp_region() + cls.runModule( + "g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10, flags="p3" + ) + + for raster_map_id, parameters in enumerate( + [ + (550, "2001-01-01 00:00:00|2001-01-01 08:00:00"), + (450, "2001-01-01 08:00:00|2001-01-01 16:00:00"), + (320, "2001-01-01 16:00:00|2001-01-02 00:00:00"), + (510, "2001-01-02 00:00:00|2001-01-02 08:00:00"), + (300, "2001-01-02 08:00:00|2001-01-02 16:00:00"), + (650, "2001-01-02 16:00:00|2001-01-03 00:00:00"), + ] + ): + # Generate data + cls.runModule( + "r.mapcalc", + flags="s", + expression=f"prec_{raster_map_id + 1} = rand(0, {parameters[0]})", + overwrite=True, + ) + cls.runModule( + "r.timestamp", + map=f"prec_{raster_map_id + 1}", + date="/".join( + [ + datetime_to_grass(datetime.fromisoformat(ts)) + for ts in parameters[1].split("|") + ] + ), + ) + cls.runModule( + "r.support", + map=f"prec_{raster_map_id + 1}", + semantic_label="semantic_label", + ) + + cls.runModule( + "t.create", + type="strds", + temporaltype="absolute", + output="precip_abs1", + title="A test", + description="A test", + overwrite=True, + ) + + @classmethod + def tearDownClass(cls): + """Remove the temporary region""" + cls.runModule("t.remove", flags="df", type="strds", inputs="precip_abs1") + cls.del_temp_region() + + def test_register_metadata_from_file(self): + register_module = SimpleModule( + "t.register", + input="precip_abs1", + maps="prec_1,prec_2,prec_3,prec_4,prec_5,prec_6", + overwrite=True, + verbose=True, + ) + self.assertModule(register_module) + + print(gs.read_command("t.info", type="strds", input="precip_abs1")) + strds = tgis.open_old_stds("precip_abs1", type="strds") + + self.assertEqual(strds.metadata.get_number_of_maps(), 6) + start, end = strds.get_absolute_time() + self.assertEqual(start, datetime(2001, 1, 1)) + self.assertEqual(end, datetime(2001, 1, 3)) + self.assertEqual(strds.check_temporal_topology(), True) + self.assertEqual(strds.get_granularity(), "8 hours") + self.assertEqual(strds.metadata.get_number_of_semantic_labels(), 1) + self.assertEqual(strds.metadata.get_semantic_labels(), "semantic_label") + + print(gs.read_command("t.info", type="strds", input="precip_abs1")) + t_rast_list = SimpleModule("t.rast.list", input="precip_abs1") + t_rast_list.run() + + # Check registered raster maps + ref_str = "\n".join( + [ + "name|mapset|start_time|end_time", + "prec_1|...|2001-01-01 00:00:00|2001-01-01 08:00:00", + "prec_2|...|2001-01-01 08:00:00|2001-01-01 16:00:00", + "prec_3|...|2001-01-01 16:00:00|2001-01-02 00:00:00", + "prec_4|...|2001-01-02 00:00:00|2001-01-02 08:00:00", + "prec_5|...|2001-01-02 08:00:00|2001-01-02 16:00:00", + "prec_6|...|2001-01-02 16:00:00|2001-01-03 00:00:00", + ] + ) + self.assertLooksLike(str(t_rast_list.outputs.stdout), ref_str) + + +if __name__ == "__main__": + from grass.gunittest.main import test + + test()