def test_absolute_time_strds_4(self): """Test the registration of maps with absolute time in a space time raster dataset. The timestamps are set via method arguments and with the c-interface. The timestamps of the method arguments should overwrite the time stamps set via the C-interface. The C-interface sets relative time stamps. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 day") tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_abs.get_name(), maps="register_map_1", start="2001-02-01", increment="1 day", interval=True) map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 2, 1)) self.assertEqual(end, datetime.datetime(2001, 2, 2)) self.strds_abs.select() start, end = self.strds_abs.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 2, 1)) self.assertEqual(end, datetime.datetime(2001, 2, 2))
def test_absolute_time_3(self): """Test the registration of maps with absolute time. The timestamps are set using the C-Interface beforehand, so that the register function needs to read the timetsamp from the map metadata. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp( "register_map_1", tgis.get_current_mapset(), "1 Jan 2001 10:30:01" ) ciface.write_raster_timestamp( "register_map_2", tgis.get_current_mapset(), "1 Jan 2001 18:30:01" ) tgis.register_maps_in_space_time_dataset( type="raster", name=None, maps="register_map_1,register_map_2" ) map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1)) map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def test_absolute_time_strds_2(self): """Test the registration of maps with absolute time in a space time raster dataset. The timestamps are set using the C-Interface beforehand, so that the register function needs to read the timetsamp from the map metadata. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001") ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "2 Jan 2001/3 Jan 2001") tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_abs.get_name(), maps="register_map_1,register_map_2") map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1)) self.assertEqual(end, datetime.datetime(2001, 1, 2)) map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 2)) self.assertEqual(end, datetime.datetime(2001, 1, 3)) self.strds_abs.select() start, end = self.strds_abs.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1)) self.assertEqual(end, datetime.datetime(2001, 1, 3))
def test_relative_time_3(self): """Test the registration of maps with relative time. The timetsamps are set beforehand using the C-interface. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp( "register_map_1", tgis.get_current_mapset(), "1000000 seconds/1500000 seconds", ) ciface.write_raster_timestamp( "register_map_2", tgis.get_current_mapset(), "1500000 seconds/2000000 seconds", ) tgis.register_maps_in_space_time_dataset( type="raster", name=None, maps="register_map_1,register_map_2" ) map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1000000) self.assertEqual(end, 1500000) self.assertEqual(unit, "seconds") map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1500000) self.assertEqual(end, 2000000) self.assertEqual(unit, "seconds")
def _checkDatasets(self, datasets, typ): """Checks and validates datasets. Reports also type of dataset (e.g. 'strds'). :param list datasets: list of temporal dataset's name :return: (mapName, mapset, type) """ validated = [] tDict = tgis.tlist_grouped(type=typ, group_type=True, dbif=self.dbif) # nested list with '(map, mapset, etype)' items allDatasets = [[[(map, mapset, etype) for map in maps] for etype, maps in etypesDict.iteritems()] for mapset, etypesDict in tDict.iteritems()] # flatten this list if allDatasets: allDatasets = reduce(lambda x, y: x + y, reduce(lambda x, y: x + y, allDatasets)) mapsets = tgis.get_tgis_c_library_interface().available_mapsets() allDatasets = [ i for i in sorted( allDatasets, key=lambda l: mapsets.index(l[1]))] for dataset in datasets: errorMsg = _("Space time dataset <%s> not found.") % dataset if dataset.find("@") >= 0: nameShort, mapset = dataset.split('@', 1) indices = [n for n, (mapName, mapsetName, etype) in enumerate( allDatasets) if nameShort == mapName and mapsetName == mapset] else: indices = [n for n, (mapName, mapset, etype) in enumerate( allDatasets) if dataset == mapName] if len(indices) == 0: raise GException(errorMsg) elif len(indices) >= 2: dlg = wx.SingleChoiceDialog( self, message=_( "Please specify the " "space time dataset " "<%s>." % dataset), caption=_("Ambiguous dataset name"), choices=[ ("%(map)s@%(mapset)s:" " %(etype)s" % { 'map': allDatasets[i][0], 'mapset': allDatasets[i][1], 'etype': allDatasets[i][2]}) for i in indices], style=wx.CHOICEDLG_STYLE | wx.OK) if dlg.ShowModal() == wx.ID_OK: index = dlg.GetSelection() validated.append(allDatasets[indices[index]]) else: continue else: validated.append(allDatasets[indices[0]]) return validated
def test_relative_time_strds_2(self): """Test the registration of maps with relative time in a space time raster dataset. The timetsamps are set for the maps using the C-interface before registration. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1000000 seconds/1500000 seconds") ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "1500000 seconds/2000000 seconds") tgis.register_maps_in_space_time_dataset(type="raster", name=self.strds_rel.get_name(), maps="register_map_1,register_map_2") map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1000000) self.assertEqual(end, 1500000) self.assertEqual(unit, "seconds") map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1500000) self.assertEqual(end, 2000000) self.assertEqual(unit, "seconds") self.strds_rel.select() start, end, unit = self.strds_rel.get_relative_time() self.assertEqual(start, 1000000) self.assertEqual(end, 2000000) self.assertEqual(unit, "seconds")
def test_absolute_time_stvds_3(self): """Test the registration of maps with absolute time in a space time raster dataset. The timestamps are set via method arguments and with the c-interface. The timestamps of the method arguments should overwrite the time stamps set via the C-interface. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_vector_timestamp( "register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001" ) tgis.register_maps_in_space_time_dataset( type="vector", name=self.stvds_abs.get_name(), maps="register_map_1", start="2001-02-01", increment="1 day", interval=True, ) map = tgis.VectorDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 2, 1)) self.assertEqual(end, datetime.datetime(2001, 2, 2)) self.stvds_abs.select() start, end = self.stvds_abs.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 2, 1)) self.assertEqual(end, datetime.datetime(2001, 2, 2))
def validateTimeseriesName(timeseries, etype='strds'): """Checks if space time dataset exists and completes missing mapset. Raises GException if dataset doesn't exist. """ trastDict = tgis.tlist_grouped(etype) if timeseries.find("@") >= 0: nameShort, mapset = timeseries.split('@', 1) if nameShort in trastDict[mapset]: return timeseries else: raise GException(_("Space time dataset <%s> not found.") % timeseries) mapsets = tgis.get_tgis_c_library_interface().available_mapsets() for mapset in mapsets: if mapset in trastDict.keys(): if timeseries in trastDict[mapset]: return timeseries + "@" + mapset raise GException(_("Space time dataset <%s> not found.") % timeseries)
def validateTimeseriesName(timeseries, etype='strds'): """Checks if space time dataset exists and completes missing mapset. Raises GException if dataset doesn't exist. """ trastDict = tgis.tlist_grouped(etype) if timeseries.find("@") >= 0: nameShort, mapset = timeseries.split('@', 1) if nameShort in trastDict[mapset]: return timeseries else: raise GException( _("Space time dataset <%s> not found.") % timeseries) mapsets = tgis.get_tgis_c_library_interface().available_mapsets() for mapset in mapsets: if mapset in trastDict.keys(): if timeseries in trastDict[mapset]: return timeseries + "@" + mapset raise GException(_("Space time dataset <%s> not found.") % timeseries)
def setUpClass(cls): os.putenv("GRASS_OVERWRITE", "1") for i in range(1, 5): cls.runModule("g.mapset", flags="c", mapset="test%i"%i) cls.runModule("g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10) cls.runModule("t.info", flags="s") cls.runModule("r.mapcalc", expression="a1 = 100") cls.runModule("r.mapcalc", expression="a2 = 200") cls.runModule("r.mapcalc", expression="a3 = 300") cls.runModule("t.create", type="strds", temporaltype="absolute", output="A", title="A test", description="A test") cls.runModule("t.register", flags="i", type="rast", input="A", maps="a1,a2,a3", start="2001-01-01", increment="%i months"%i) # Here we reuse two mapset to share a temporal databse between mapsets tgis.init() ciface = tgis.get_tgis_c_library_interface() cls.runModule("g.mapset", flags="c", mapset="test5") driver = ciface.get_driver_name("test1") database = ciface.get_database_name("test1") cls.runModule("t.connect", driver=driver, database=database) cls.runModule("g.mapset", flags="c", mapset="test6") driver = ciface.get_driver_name("test2") database = ciface.get_database_name("test2") cls.runModule("t.connect", driver=driver, database=database) for i in range(5, 7): cls.runModule("g.mapset", mapset="test%i"%i) cls.runModule("r.mapcalc", expression="a1 = 100") cls.runModule("r.mapcalc", expression="a2 = 200") cls.runModule("r.mapcalc", expression="a3 = 300") cls.runModule("t.create", type="strds", temporaltype="absolute", output="A", title="A test", description="A test") cls.runModule("t.register", flags="i", type="rast", input="A", maps="a1,a2,a3", start="2001-01-01", increment="%i months"%i)
def test_absolute_time_3(self): """!Test the registration of maps with absolute time. The timestamps are set using the C-Interface beforehand, so that the register function needs to read the timetsamp from the map metadata. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1 Jan 2001 10:30:01") ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "1 Jan 2001 18:30:01") tgis.register_maps_in_space_time_dataset(type="rast", name=None, maps="register_map_1,register_map_2") map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1, 10, 30, 1)) map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1, 18, 30, 1))
def test_relative_time_strds_2(self): """!Test the registration of maps with relative time in a space time raster dataset. The timetsamps are set for the maps using the C-interface before registration. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_raster_timestamp("register_map_1", tgis.get_current_mapset(), "1000000 seconds/1500000 seconds") ciface.write_raster_timestamp("register_map_2", tgis.get_current_mapset(), "1500000 seconds/2000000 seconds") tgis.register_maps_in_space_time_dataset( type="rast", name=self.strds_rel.get_name(), maps="register_map_1,register_map_2") map = tgis.RasterDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1000000) self.assertEqual(end, 1500000) self.assertEqual(unit, "seconds") map = tgis.RasterDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end, unit = map.get_relative_time() self.assertEqual(start, 1500000) self.assertEqual(end, 2000000) self.assertEqual(unit, "seconds") self.strds_rel.select() start, end, unit = self.strds_rel.get_relative_time() self.assertEqual(start, 1000000) self.assertEqual(end, 2000000) self.assertEqual(unit, "seconds")
def test_absolute_time_stvds_2(self): """Test the registration of maps with absolute time in a space time raster dataset. The timestamps are set using the C-Interface beforehand, so that the register function needs to read the timetsamp from the map metadata. """ ciface = tgis.get_tgis_c_library_interface() ciface.write_vector_timestamp( "register_map_1", tgis.get_current_mapset(), "1 Jan 2001/2 Jan 2001" ) ciface.write_vector_timestamp( "register_map_2", tgis.get_current_mapset(), "2 Jan 2001/3 Jan 2001" ) tgis.register_maps_in_space_time_dataset( type="vector", name=self.stvds_abs.get_name(), maps="register_map_1,register_map_2", ) map = tgis.VectorDataset("register_map_1@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1)) self.assertEqual(end, datetime.datetime(2001, 1, 2)) map = tgis.VectorDataset("register_map_2@" + tgis.get_current_mapset()) map.select() start, end = map.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 2)) self.assertEqual(end, datetime.datetime(2001, 1, 3)) self.stvds_abs.select() start, end = self.stvds_abs.get_absolute_time() self.assertEqual(start, datetime.datetime(2001, 1, 1)) self.assertEqual(end, datetime.datetime(2001, 1, 3))
def _checkDatasets(self, datasets): """Checks and validates datasets. Reports also type of dataset (e.g. 'strds'). :return: (mapName, mapset, type) """ validated = [] tDict = tgis.tlist_grouped('stds', group_type=True, dbif=self.dbif) # nested list with '(map, mapset, etype)' items allDatasets = [[[(map, mapset, etype) for map in maps] for etype, maps in etypesDict.iteritems()] for mapset, etypesDict in tDict.iteritems()] # flatten this list if allDatasets: allDatasets = reduce( lambda x, y: x + y, reduce( lambda x, y: x + y, allDatasets)) mapsets = tgis.get_tgis_c_library_interface().available_mapsets() allDatasets = [ i for i in sorted( allDatasets, key=lambda l: mapsets.index(l[1]))] for dataset in datasets: errorMsg = _("Space time dataset <%s> not found.") % dataset if dataset.find("@") >= 0: nameShort, mapset = dataset.split('@', 1) indices = [n for n, (mapName, mapsetName, etype) in enumerate( allDatasets) if nameShort == mapName and mapsetName == mapset] else: indices = [n for n, (mapName, mapset, etype) in enumerate( allDatasets) if dataset == mapName] if len(indices) == 0: raise GException(errorMsg) elif len(indices) >= 2: dlg = wx.SingleChoiceDialog( self, message=_( "Please specify the space time dataset <%s>." % dataset), caption=_("Ambiguous dataset name"), choices=[("%(map)s@%(mapset)s: %(etype)s" % {'map': allDatasets[i][0], 'mapset': allDatasets[i][1], 'etype': allDatasets[i][2]}) for i in indices], style=wx.CHOICEDLG_STYLE | wx.OK) if dlg.ShowModal() == wx.ID_OK: index = dlg.GetSelection() validated.append(allDatasets[indices[index]]) else: continue else: validated.append(allDatasets[indices[0]]) return validated
def main(): # lazy imports import grass.temporal as tgis # Get the options type = options["type"] temporal_type = options["temporaltype"] columns = options["columns"] order = options["order"] where = options["where"] separator = gscript.separator(options["separator"]) outpath = options["output"] colhead = flags['c'] # Make sure the temporal database exists tgis.init() sp = tgis.dataset_factory(type, None) dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() first = True if gscript.verbosity() > 0 and not outpath: sys.stderr.write("----------------------------------------------\n") if outpath: outfile = open(outpath, 'w') for ttype in temporal_type.split(","): if ttype == "absolute": time = "absolute time" else: time = "relative time" stds_list = tgis.get_dataset_list(type, ttype, columns, where, order, dbif=dbif) # Use the correct order of the mapsets, hence first the current mapset, then # alphabetic ordering mapsets = tgis.get_tgis_c_library_interface().available_mapsets() # Print for each mapset separately for key in mapsets: if key in stds_list.keys(): rows = stds_list[key] if rows: if gscript.verbosity() > 0 and not outpath: if issubclass(sp.__class__, tgis.AbstractMapDataset): sys.stderr.write(_("Time stamped %s maps with %s available in mapset <%s>:\n")% (sp.get_type(), time, key)) else: sys.stderr.write(_("Space time %s datasets with %s available in mapset <%s>:\n")% (sp.get_new_map_instance(None).get_type(), time, key)) # Print the column names if requested if colhead and first: output = "" count = 0 for key in rows[0].keys(): if count > 0: output += separator + str(key) else: output += str(key) count += 1 if outpath: outfile.write("{st}\n".format(st=output)) else: print(output) first = False for row in rows: output = "" count = 0 for col in row: if count > 0: output += separator + str(col) else: output += str(col) count += 1 if outpath: outfile.write("{st}\n".format(st=output)) else: print(output) if outpath: outfile.close() dbif.close()
def setUpClass(cls): os.putenv("GRASS_OVERWRITE", "1") for i in range(1, 5): cls.runModule("g.mapset", flags="c", mapset="test%i" % i) cls.runModule("g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10) cls.runModule("t.info", flags="s") cls.runModule("r.mapcalc", expression="a1 = 100") cls.runModule("r.mapcalc", expression="a2 = 200") cls.runModule("r.mapcalc", expression="a3 = 300") cls.runModule("t.create", type="strds", temporaltype="absolute", output="A", title="A test", description="A test") cls.runModule("t.register", flags="i", type="rast", input="A", maps="a1,a2,a3", start="2001-01-01", increment="%i months" % i) # Here we reuse two mapset to share a temporal databse between mapsets tgis.init() ciface = tgis.get_tgis_c_library_interface() cls.runModule("g.mapset", flags="c", mapset="test5") driver = ciface.get_driver_name("test1") database = ciface.get_database_name("test1") cls.runModule("t.connect", driver=driver, database=database) cls.runModule("g.mapset", flags="c", mapset="test6") driver = ciface.get_driver_name("test2") database = ciface.get_database_name("test2") cls.runModule("t.connect", driver=driver, database=database) for i in range(5, 7): cls.runModule("g.mapset", mapset="test%i" % i) cls.runModule("r.mapcalc", expression="a1 = 100") cls.runModule("r.mapcalc", expression="a2 = 200") cls.runModule("r.mapcalc", expression="a3 = 300") cls.runModule("t.create", type="strds", temporaltype="absolute", output="A", title="A test", description="A test") cls.runModule("t.register", flags="i", type="rast", input="A", maps="a1,a2,a3", start="2001-01-01", increment="%i months" % i)
def main(): # Get the options type = options["type"] temporal_type = options["temporaltype"] columns = options["columns"] order = options["order"] where = options["where"] separator = gscript.separator(options["separator"]) outpath = options["output"] colhead = flags['c'] # Make sure the temporal database exists tgis.init() sp = tgis.dataset_factory(type, None) dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() first = True if gscript.verbosity() > 0 and not outpath: sys.stderr.write("----------------------------------------------\n") for ttype in temporal_type.split(","): if ttype == "absolute": time = "absolute time" else: time = "relative time" stds_list = tgis.get_dataset_list(type, ttype, columns, where, order, dbif=dbif) # Use the correct order of the mapsets, hence first the current mapset, then # alphabetic ordering mapsets = tgis.get_tgis_c_library_interface().available_mapsets() if outpath: outfile = open(outpath, 'w') # Print for each mapset separately for key in mapsets: if key in stds_list.keys(): rows = stds_list[key] if rows: if gscript.verbosity() > 0 and not outpath: if issubclass(sp.__class__, tgis.AbstractMapDataset): sys.stderr.write(_("Time stamped %s maps with %s available in mapset <%s>:\n")%\ (sp.get_type(), time, key)) else: sys.stderr.write(_("Space time %s datasets with %s available in mapset <%s>:\n")%\ (sp.get_new_map_instance(None).get_type(), time, key)) # Print the column names if requested if colhead == True and first == True: output = "" count = 0 for key in rows[0].keys(): if count > 0: output += separator + str(key) else: output += str(key) count += 1 if outpath: outfile.write("{st}\n".format(st=output)) else: print output first = False for row in rows: output = "" count = 0 for col in row: if count > 0: output += separator + str(col) else: output += str(col) count += 1 if outpath: outfile.write("{st}\n".format(st=output)) else: print output if outpath: outfile.close() dbif.close()