temporal framework: Trying to fix import issues that lead to malfunction temporal framework

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@61806 15284696-431f-4ddb-bdfa-cd5b030d7da7

lib/python/temporal/abstract_map_dataset.py

@@ -342,9 +342,9 @@ class AbstractMapDataset(AbstractDataset):
                              'l': self.get_layer()})
                 return False
             else:
-                core.error(_("Start time must be of type datetime for "
-                             "%(type)s map <%(id)s>") % {
-                             'type': self.get_type(), 'id': self.get_map_id()})
+                self.msgr.error(_("Start time must be of type datetime for "
+                                         "%(type)s map <%(id)s>") % {
+                                         'type': self.get_type(), 'id': self.get_map_id()})
                 return False
 
         if end_time and not isinstance(end_time, datetime):

lib/python/temporal/aggregation.py

@@ -24,6 +24,7 @@ for details.
 """
 
 from space_time_datasets import *
+import grass.script as gscript
 
 ###############################################################################
 
@@ -131,7 +132,7 @@ def aggregate_raster_maps(inputs, base, start, end, count, method,
 
     # Check if new map is in the temporal database
     if new_map.is_in_db(dbif):
-        if core.overwrite() == True:
+        if gscript.overwrite() == True:
             # Remove the existing temporal database entry
             new_map.delete(dbif)
             new_map = RasterDataset(map_id)
@@ -144,7 +145,7 @@ def aggregate_raster_maps(inputs, base, start, end, count, method,
                    'st': str(start), 'end': str(end)}))
 
     # Create the r.series input file
-    filename = core.tempfile(True)
+    filename = gscript.tempfile(True)
     file = open(filename, 'w')
 
     for name in inputs:
@@ -155,12 +156,12 @@ def aggregate_raster_maps(inputs, base, start, end, count, method,
     
     # Run r.series
     if len(inputs) > 1000 :
-        ret = core.run_command("r.series", flags="z", file=filename,
-                               output=output, overwrite=core.overwrite(),
+        ret = gscript.run_command("r.series", flags="z", file=filename,
+                               output=output, overwrite=gscript.overwrite(),
                                method=method)
     else:
-        ret = core.run_command("r.series", file=filename,
-                               output=output, overwrite=core.overwrite(),
+        ret = gscript.run_command("r.series", file=filename,
+                               output=output, overwrite=gscript.overwrite(),
                                method=method)
 
     if ret != 0:
@@ -173,7 +174,7 @@ def aggregate_raster_maps(inputs, base, start, end, count, method,
     # In case of a null map continue, do not register null maps
     if new_map.metadata.get_min() is None and new_map.metadata.get_max() is None:
         if not register_null:
-            core.run_command("g.remove", rast=output)
+            gscript.run_command("g.remove", rast=output)
             return None
 
     return new_map
@@ -207,7 +208,6 @@ def aggregate_by_topology(granularity_list,  granularity,  map_list,  topo_list,
        @return A list of RasterDataset objects that contain the new map names and
                the temporal extent for map registration
     """
-    import grass.script as gcore
     import grass.pygrass.modules as pymod
     import copy
 
@@ -290,7 +290,7 @@ def aggregate_by_topology(granularity_list,  granularity,  map_list,  topo_list,
 
             if len(aggregation_list) > 1:
                 # Create the r.series input file
-                filename = gcore.tempfile(True)
+                filename = gscript.tempfile(True)
                 file = open(filename, 'w')
                 for name in aggregation_list:
                     string = "%s\n" % (name)
@@ -312,4 +312,4 @@ def aggregate_by_topology(granularity_list,  granularity,  map_list,  topo_list,
 
     msgr.percent(1, 1, 1)
 
-    return output_list
+    return output_list

lib/python/temporal/c_libraries_interface.py

@@ -59,6 +59,7 @@ def _get_driver_name(lock, conn, data):
        
        :returns: Name of the driver or None if no temporal database present
     """
+    
     drstring = libtgis.tgis_get_mapset_driver_name(data[1])
     
     conn.send(drstring) 

lib/python/temporal/core.py

@@ -39,7 +39,7 @@ import locale
 import gettext
 gettext.install('grasslibs', os.path.join(os.getenv("GISBASE"), 'locale'))
 
-import grass.script.core as gcore
+import grass.script as gscript
 from datetime import datetime
 from c_libraries_interface import *
 # Import all supported database backends
@@ -400,6 +400,28 @@ def stop_subprocesses():
 # We register this function to be called at exit
 atexit.register(stop_subprocesses)
 
+def get_available_temporal_mapsets():
+    """Return a list of of mapset names with temporal database driver and names
+        that are accessable from the current mapset.
+        
+        :returns: A dictionary, mapset names are keys, the tuple (driver, database) are the values 
+    """
+    global c_library_interface
+    
+    mapsets = c_library_interface.available_mapsets()
+    
+    tgis_mapsets = {}
+    
+    for mapset in mapsets:
+        driver = c_library_interface.get_driver_name(mapset)
+        database = c_library_interface.get_database_name(mapset)
+        
+        if driver and database:
+            tgis_mapsets[mapset] = (driver,  database)
+            
+    return tgis_mapsets
+    
+
 ###############################################################################
 
 def init(raise_fatal_error=False):
@@ -453,8 +475,8 @@ def init(raise_fatal_error=False):
 
     # We must run t.connect at first to create the temporal database and to
     # get the environmental variables
-    gcore.run_command("t.connect", flags="c")
-    grassenv = gcore.gisenv()
+    gscript.run_command("t.connect", flags="c")
+    grassenv = gscript.gisenv()
 
     # Set the global variable for faster access
     current_mapset = grassenv["MAPSET"]
@@ -467,7 +489,7 @@ def init(raise_fatal_error=False):
 
     # Check if the script library raises on error,
     # if so we do the same
-    if gcore.get_raise_on_error() is True:
+    if gscript.get_raise_on_error() is True:
         raise_on_error = True
 
     # Start the GRASS message interface server
@@ -515,7 +537,7 @@ def init(raise_fatal_error=False):
             dbmi = sqlite3
     else:
         # Set the default sqlite3 connection in case nothing was defined
-        gcore.run_command("t.connect", flags="d")
+        gscript.run_command("t.connect", flags="d")
         driver_string = ciface.get_driver_name()
         database_string = ciface.get_database_name()
         tgis_backend = driver_string

lib/python/temporal/extract.py

@@ -16,6 +16,7 @@ from grass.script import core
 from space_time_datasets import *
 from open_stds import *
 from multiprocessing import Process
+import grass.script as gscript
 
 ############################################################################
 
@@ -62,7 +63,7 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
     sp = open_old_stds(input, type, dbif)
     # Check the new stds
     new_sp = check_new_stds(output, type, dbif,
-                                          core.overwrite())
+                                          gscript.overwrite())
     if type == "vector":
         rows = sp.get_registered_maps(
             "id,name,mapset,layer", where, "start_time", dbif)
@@ -105,7 +106,7 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
 
                 # Check if new map is in the temporal database
                 if new_map.is_in_db(dbif):
-                    if core.overwrite():
+                    if gscript.overwrite():
                         # Remove the existing temporal database entry
                         new_map.delete(dbif)
                         new_map = sp.get_new_map_instance(map_id)
@@ -170,7 +171,7 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
                                              sp.get_temporal_type(),
                                              title, description,
                                              semantic_type, dbif,
-                                             core.overwrite())
+                                             gscript.overwrite())
 
         # collect empty maps to remove them
         empty_maps = []
@@ -235,11 +236,11 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
                     names += ",%s" % (map.get_name())
                 count += 1
             if type == "raster":
-                core.run_command("g.remove", rast=names, quiet=True)
+                gscript.run_command("g.remove", rast=names, quiet=True)
             elif type == "raster3d":
-                core.run_command("g.remove", rast3d=names, quiet=True)
+                gscript.run_command("g.remove", rast3d=names, quiet=True)
             elif type == "vector":
-                core.run_command("g.remove", vect=names, quiet=True)
+                gscript.run_command("g.remove", vect=names, quiet=True)
 
     dbif.close()
 
@@ -248,18 +249,18 @@ def extract_dataset(input, output, type, where, expression, base, nprocs=1,
 
 def run_mapcalc2d(expr):
     """Helper function to run r.mapcalc in parallel"""
-    exit(core.run_command("r.mapcalc", expression=expr,
-                            overwrite=core.overwrite(), quiet=True))
+    exit(gscript.run_command("r.mapcalc", expression=expr,
+                            overwrite=gscript.overwrite(), quiet=True))
 
 
 def run_mapcalc3d(expr):
     """Helper function to run r3.mapcalc in parallel"""
-    exit(core.run_command("r3.mapcalc", expression=expr,
-                            overwrite=core.overwrite(), quiet=True))
+    exit(gscript.run_command("r3.mapcalc", expression=expr,
+                            overwrite=gscript.overwrite(), quiet=True))
 
 
 def run_vector_extraction(input, output, layer, type, where):
     """Helper function to run r.mapcalc in parallel"""
-    exit(core.run_command("v.extract", input=input, output=output,
+    exit(gscript.run_command("v.extract", input=input, output=output,
                             layer=layer, type=type, where=where,
-                            overwrite=core.overwrite(), quiet=True))
+                            overwrite=gscript.overwrite(), quiet=True))

lib/python/temporal/gui_support.py

@@ -15,6 +15,7 @@ for details.
 
 from space_time_datasets import *
 from factory import *
+import grass.script as gscript
 
 ###############################################################################
 
@@ -46,7 +47,7 @@ def tlist_grouped(type, group_type = False, dbif=None):
     for type in types:
         try:
             tlist_result = tlist(type=type, dbif=dbif)
-        except core.ScriptError as e:
+        except gscript.ScriptError as e:
             warning(e)
             continue
 

lib/python/temporal/mapcalc.py

@@ -15,6 +15,7 @@ for details.
 from space_time_datasets import *
 from open_stds import *
 from multiprocessing import Process
+import grass.script as gscript
 
 ############################################################################
 
@@ -98,7 +99,7 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
         input_list.append(copy.copy(sp))
 
     new_sp = check_new_stds(output, type, dbif,
-                                         core.overwrite())
+                                         gscript.overwrite())
 
     # Sample all inputs by the first input and create a sample matrix
     if spatial:
@@ -227,7 +228,7 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
 
             # Check if new map is in the temporal database
             if new_map.is_in_db(dbif):
-                if core.overwrite():
+                if gscript.overwrite():
                     # Remove the existing temporal database entry
                     new_map.delete(dbif)
                     new_map = first_input.get_new_map_instance(map_id)
@@ -284,7 +285,7 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
         new_sp = open_new_stds(output, type,
                                          temporal_type, title, description,
                                          semantic_type, dbif,
-                                         core.overwrite())
+                                         gscript.overwrite())
         count = 0
 
         # collect empty maps to remove them
@@ -329,9 +330,9 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
                     names += ",%s" % (map.get_name())
                 count += 1
             if type == "raster":
-                core.run_command("g.remove", rast=names, quiet=True)
+                gscript.run_command("g.remove", rast=names, quiet=True)
             elif type == "raster3d":
-                core.run_command("g.remove", rast3d=names, quiet=True)
+                gscript.run_command("g.remove", rast3d=names, quiet=True)
 
     dbif.close()
 
@@ -340,16 +341,16 @@ def dataset_mapcalculator(inputs, output, type, expression, base, method,
 
 def _run_mapcalc2d(expr):
     """Helper function to run r.mapcalc in parallel"""
-    exit(core.run_command("r.mapcalc", expression=expr,
-                            overwrite=core.overwrite(), quiet=True))
+    exit(gscript.run_command("r.mapcalc", expression=expr,
+                            overwrite=gscript.overwrite(), quiet=True))
 
 ###############################################################################
 
 
 def _run_mapcalc3d(expr):
     """Helper function to run r3.mapcalc in parallel"""
-    exit(core.run_command("r3.mapcalc", expression=expr,
-                            overwrite=core.overwrite(), quiet=True))
+    exit(gscript.run_command("r3.mapcalc", expression=expr,
+                            overwrite=gscript.overwrite(), quiet=True))
 
 ###############################################################################
 

lib/python/temporal/register.py

@@ -23,6 +23,7 @@ for details.
 """
 
 from open_stds import *
+import grass.script as gscript
 
 ###############################################################################
 
@@ -217,7 +218,7 @@ def register_maps_in_space_time_dataset(
         else:
             is_in_db = True
             # Check the overwrite flag
-            if not core.overwrite():
+            if not gscript.overwrite():
                 if map.get_layer():
                     msgr.warning(_("Map is already registered in temporal "
                                    "database. Unable to update %(t)s map "
@@ -444,13 +445,12 @@ def register_map_object_list(type,  map_list, output_stds,
        @param dbif The database interface to be used
        
     """
-    import grass.script as gcore
     import grass.pygrass.modules as pymod
     import copy
 
     dbif,  connected = init_dbif(dbif)
 
-    filename = gcore.tempfile(True)
+    filename = gscript.tempfile(True)
     file = open(filename, 'w')
 
     empty_maps = []

lib/python/temporal/stds_export.py

@@ -36,6 +36,7 @@ import tempfile
 from space_time_datasets import *
 from factory import *
 from open_stds import *
+import grass.script as gscript
 
 proj_file_name = "proj.txt"
 init_file_name = "init.txt"
@@ -79,31 +80,31 @@ def _export_raster_maps_as_gdal(rows, tar, list_file, new_cwd, fs, format_):
                     gdal_type = "UInt32"
                 else:
                     gdal_type = "Int32"
-                ret = core.run_command("r.out.gdal", flags="c", input=name,
+                ret = gscript.run_command("r.out.gdal", flags="c", input=name,
                                     output=out_name, nodata=nodata,
                                     type=gdal_type, format="GTiff")
             else:
-                ret = core.run_command("r.out.gdal", flags="c",
+                ret = gscript.run_command("r.out.gdal", flags="c",
                                     input=name, output=out_name, format="GTiff")
         elif format_ == "AAIGrid":
             # Export the raster map with r.out.gdal as Arc/Info ASCII Grid
             out_name = name + ".asc"
-            ret = core.run_command("r.out.gdal", flags="c", input=name, output=out_name, format="AAIGrid")
+            ret = gscript.run_command("r.out.gdal", flags="c", input=name, output=out_name, format="AAIGrid")
             
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export raster map <%s>" % name))
+            gscript.fatal(_("Unable to export raster map <%s>" % name))
 
         tar.add(out_name)
 
         # Export the color rules
         out_name = name + ".color"
-        ret = core.run_command("r.colors.out", map=name, rules=out_name)
+        ret = gscript.run_command("r.colors.out", map=name, rules=out_name)
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export color rules for raster "
+            gscript.fatal(_("Unable to export color rules for raster "
                          "map <%s> r.out.gdal" % name))
 
         tar.add(out_name)
@@ -121,11 +122,11 @@ def _export_raster_maps(rows, tar, list_file, new_cwd, fs):
         # Write the filename, the start_time and the end_time
         list_file.write(string)
         # Export the raster map with r.pack
-        ret = core.run_command("r.pack", input=name, flags="c")
+        ret = gscript.run_command("r.pack", input=name, flags="c")
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export raster map <%s> with r.pack" %
+            gscript.fatal(_("Unable to export raster map <%s> with r.pack" %
                          name))
 
         tar.add(name + ".pack")
@@ -146,12 +147,12 @@ def _export_vector_maps_as_gml(rows, tar, list_file, new_cwd, fs):
         # Write the filename, the start_time and the end_time
         list_file.write(string)
         # Export the vector map with v.out.ogr
-        ret = core.run_command("v.out.ogr", input=name, dsn=(name + ".xml"),
+        ret = gscript.run_command("v.out.ogr", input=name, dsn=(name + ".xml"),
                                layer=layer, format="GML")
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export vector map <%s> as "
+            gscript.fatal(_("Unable to export vector map <%s> as "
                          "GML with v.out.ogr" % name))
 
         tar.add(name + ".xml")
@@ -178,11 +179,11 @@ def _export_vector_maps(rows, tar, list_file, new_cwd, fs):
         # Write the filename, the start_time and the end_time
         list_file.write(string)
         # Export the vector map with v.pack
-        ret = core.run_command("v.pack", input=name, flags="c")
+        ret = gscript.run_command("v.pack", input=name, flags="c")
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export vector map <%s> with v.pack" %
+            gscript.fatal(_("Unable to export vector map <%s> with v.pack" %
                          name))
 
         tar.add(name + ".pack")
@@ -203,11 +204,11 @@ def _export_raster3d_maps(rows, tar, list_file, new_cwd, fs):
         # Write the filename, the start_time and the end_time
         list_file.write(string)
         # Export the raster 3d map with r3.pack
-        ret = core.run_command("r3.pack", input=name, flags="c")
+        ret = gscript.run_command("r3.pack", input=name, flags="c")
         if ret != 0:
             shutil.rmtree(new_cwd)
             tar.close()
-            core.fatal(_("Unable to export raster map <%s> with r3.pack" %
+            gscript.fatal(_("Unable to export raster map <%s> with r3.pack" %
                          name))
 
         tar.add(name + ".pack")
@@ -295,7 +296,7 @@ def export_stds(input, output, compression, workdir, where, format_="pack",
     list_file.close()
 
     # Write projection and metadata
-    proj = core.read_command("g.proj", flags="j")
+    proj = gscript.read_command("g.proj", flags="j")
 
     proj_file = open(proj_file_name, "w")
     proj_file.write(proj)
@@ -324,7 +325,7 @@ def export_stds(input, output, compression, workdir, where, format_="pack",
     init_file.write(string)
     init_file.close()
 
-    metadata = core.read_command("t.info", type=type_, input=sp.get_id())
+    metadata = gscript.read_command("t.info", type=type_, input=sp.get_id())
     metadata_file = open(metadata_file_name, "w")
     metadata_file.write(metadata)
     metadata_file.close()

lib/python/temporal/stds_import.py

@@ -40,6 +40,7 @@ from space_time_datasets import *
 from register import *
 import factory
 from factory import *
+import grass.script as gscript
 
 proj_file_name = "proj.txt"
 init_file_name = "init.txt"
@@ -70,33 +71,33 @@ def _import_raster_maps_from_gdal(maplist, overr, exp, location, link, format_,
                 impflags += "o"
 
         if link:
-            ret = core.run_command("r.external", input=filename,
+            ret = gscript.run_command("r.external", input=filename,
                                    output=name,
                                    flags=impflags,
-                                   overwrite=core.overwrite())
+                                   overwrite=gscript.overwrite())
         else:
-            ret = core.run_command("r.in.gdal", input=filename,
+            ret = gscript.run_command("r.in.gdal", input=filename,
                                    output=name,
                                    flags=impflags,
-                                   overwrite=core.overwrite())
+                                   overwrite=gscript.overwrite())
 
         if ret != 0:
-            core.fatal(_("Unable to import/link raster map <%s> from file %s.") %(name, 
+            gscript.fatal(_("Unable to import/link raster map <%s> from file %s.") %(name, 
                                                                      filename))
 
         # Set the color rules if present
         filename = row["filename"] + ".color"
         if os.path.isfile(filename):
-            ret = core.run_command("r.colors", map=name,
+            ret = gscript.run_command("r.colors", map=name,
                                    rules=filename,
-                                   overwrite=core.overwrite())
+                                   overwrite=gscript.overwrite())
             if ret != 0:
-                core.fatal(_("Unable to set the color rules for "
+                gscript.fatal(_("Unable to set the color rules for "
                              "raster map <%s>.") % name)
 
     # Set the computational region from the last map imported
     if set_current_region is True:
-        core.run_command("g.region", rast=name)
+        gscript.run_command("g.region", rast=name)
 
 ############################################################################
 
@@ -108,19 +109,19 @@ def _import_raster_maps(maplist, set_current_region=False):
     for row in maplist:
         name = row["name"]
         filename = row["filename"] + ".pack"
-        ret = core.run_command("r.unpack", input=filename,
+        ret = gscript.run_command("r.unpack", input=filename,
                                output=name,
                                flags=impflags,
-                               overwrite=core.overwrite(),
+                               overwrite=gscript.overwrite(),
                                verbose=True)
 
         if ret != 0:
-            core.fatal(_("Unable to unpack raster map <%s> from file %s.") % (name, 
+            gscript.fatal(_("Unable to unpack raster map <%s> from file %s.") % (name, 
                                                                               filename))
 
     # Set the computational region from the last map imported
     if set_current_region is True:
-        core.run_command("g.region", rast=name)
+        gscript.run_command("g.region", rast=name)
 
 ############################################################################
 
@@ -133,13 +134,13 @@ def _import_vector_maps_from_gml(maplist, overr, exp, location, link):
         name = row["name"]
         filename = row["filename"] + ".xml"
 
-        ret = core.run_command("v.in.ogr", dsn=filename,
+        ret = gscript.run_command("v.in.ogr", dsn=filename,
                                output=name,
                                flags=impflags,
-                               overwrite=core.overwrite())
+                               overwrite=gscript.overwrite())
 
         if ret != 0:
-            core.fatal(_("Unable to import vector map <%s> from file %s.") % (name,
+            gscript.fatal(_("Unable to import vector map <%s> from file %s.") % (name,
                                                                               filename))
 
 ############################################################################
@@ -156,14 +157,14 @@ def _import_vector_maps(maplist):
         if name in imported_maps:
             continue
         filename = row["filename"] + ".pack"
-        ret = core.run_command("v.unpack", input=filename,
+        ret = gscript.run_command("v.unpack", input=filename,
                                output=name,
                                flags=impflags,
-                               overwrite=core.overwrite(),
+                               overwrite=gscript.overwrite(),
                                verbose=True)
 
         if ret != 0:
-            core.fatal(_("Unable to unpack vector map <%s> from file %s.") % (name, 
+            gscript.fatal(_("Unable to unpack vector map <%s> from file %s.") % (name, 
                                                                               filename))
 
         imported_maps[name] = name
@@ -196,15 +197,15 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
     """
 
     global raise_on_error
-    old_state = core.raise_on_error
-    core.set_raise_on_error(True)
+    old_state = gscript.raise_on_error
+    gscript.set_raise_on_error(True)
 
     # Check if input file and extraction directory exits
     if not os.path.exists(input):
-        core.fatal(_("Space time raster dataset archive <%s> not found")
+        gscript.fatal(_("Space time raster dataset archive <%s> not found")
                    % input)
     if not create and not os.path.exists(extrdir):
-        core.fatal(_("Extraction directory <%s> not found") % extrdir)
+        gscript.fatal(_("Extraction directory <%s> not found") % extrdir)
 
     tar = tarfile.open(name=input, mode='r')
 
@@ -212,11 +213,11 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
     members = tar.getnames()
 
     if init_file_name not in members:
-        core.fatal(_("Unable to find init file <%s>") % init_file_name)
+        gscript.fatal(_("Unable to find init file <%s>") % init_file_name)
     if list_file_name not in members:
-        core.fatal(_("Unable to find list file <%s>") % list_file_name)
+        gscript.fatal(_("Unable to find list file <%s>") % list_file_name)
     if proj_file_name not in members:
-        core.fatal(_("Unable to find projection file <%s>") % proj_file_name)
+        gscript.fatal(_("Unable to find projection file <%s>") % proj_file_name)
 
     tar.extractall(path=extrdir)
     tar.close()
@@ -231,31 +232,31 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
 
     # Check projection information
     if not location:
-        temp_name = core.tempfile()
+        temp_name = gscript.tempfile()
         temp_file = open(temp_name, "w")
         proj_name = os.path.abspath(proj_file_name)
 
-        p = core.start_command("g.proj", flags="j", stdout=temp_file)
+        p = gscript.start_command("g.proj", flags="j", stdout=temp_file)
         p.communicate()
         temp_file.close()
 
-        if not core.compare_key_value_text_files(temp_name, proj_name, sep="="):
+        if not gscript.compare_key_value_text_files(temp_name, proj_name, sep="="):
             if overr:
-                core.warning(_("Projection information does not match. "
+                gscript.warning(_("Projection information does not match. "
                                "Proceeding..."))
             else:
-                diff = ''.join(core.diff_files(temp_name, proj_name))
-                core.warning(_("Difference between PROJ_INFO file of imported map "
+                diff = ''.join(gscript.diff_files(temp_name, proj_name))
+                gscript.warning(_("Difference between PROJ_INFO file of imported map "
                                "and of current location:\n{diff}").format(diff=diff))
-                core.fatal(_("Projection information does not match. Aborting."))
+                gscript.fatal(_("Projection information does not match. Aborting."))
 
     # Create a new location based on the projection information and switch
     # into it
-    old_env = core.gisenv()
+    old_env = gscript.gisenv()
     if location:
         try:
             proj4_string = open(proj_file_name, 'r').read()
-            core.create_location(dbase=old_env["GISDBASE"],
+            gscript.create_location(dbase=old_env["GISDBASE"],
                                  location=location,
                                  proj4=proj4_string)
             # Just create a new location and return
@@ -263,18 +264,18 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
                 os.chdir(old_cwd)
                 return
         except Exception as e:
-            core.fatal(_("Unable to create location %(l)s. Reason: %(e)s")
+            gscript.fatal(_("Unable to create location %(l)s. Reason: %(e)s")
                          % {'l': location, 'e': str(e)})
         # Switch to the new created location
-        ret = core.run_command("g.mapset", mapset="PERMANENT",
+        ret = gscript.run_command("g.mapset", mapset="PERMANENT",
                                location=location,
                                gisdbase=old_env["GISDBASE"])
         if ret != 0:
-            core.fatal(_("Unable to switch to location %s") % location)
+            gscript.fatal(_("Unable to switch to location %s") % location)
         # create default database connection
-        ret = core.run_command("t.connect", flags="d")
+        ret = gscript.run_command("t.connect", flags="d")
         if ret != 0:
-            core.fatal(_("Unable to create default temporal database "
+            gscript.fatal(_("Unable to create default temporal database "
                          "in new location %s") % location)
 
     try:
@@ -339,13 +340,13 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
         if "temporal_type" not in init or \
            "semantic_type" not in init or \
            "number_of_maps" not in init:
-            core.fatal(_("Key words %(t)s, %(s)s or %(n)s not found in init"
+            gscript.fatal(_("Key words %(t)s, %(s)s or %(n)s not found in init"
                          " file.") % {'t': "temporal_type",
                                       's': "semantic_type",
                                       'n': "number_of_maps"})
 
         if line_count != int(init["number_of_maps"]):
-            core.fatal(_("Number of maps mismatch in init and list file."))
+            gscript.fatal(_("Number of maps mismatch in init and list file."))
 
         format_ = "GTiff"
         type_ = "strds"
@@ -356,26 +357,26 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
             format_ = init["format"]
 
         if stds_type != type_:
-            core.fatal(_("The archive file is of wrong space time dataset type"))
+            gscript.fatal(_("The archive file is of wrong space time dataset type"))
 
         # Check the existence of the files
         if format_ == "GTiff":
             for row in maplist:
                 filename = row["filename"] + ".tif"
                 if not os.path.exists(filename):
-                    core.fatal(_("Unable to find GeoTIFF raster file "
+                    gscript.fatal(_("Unable to find GeoTIFF raster file "
                                  "<%s> in archive.") % filename)
         elif format_ == "AAIGrid":
             for row in maplist:
                 filename = row["filename"] + ".asc"
                 if not os.path.exists(filename):
-                    core.fatal(_("Unable to find AAIGrid raster file "
+                    gscript.fatal(_("Unable to find AAIGrid raster file "
                                  "<%s> in archive.") % filename)
         elif format_ == "GML":
             for row in maplist:
                 filename = row["filename"] + ".xml"
                 if not os.path.exists(filename):
-                    core.fatal(_("Unable to find GML vector file "
+                    gscript.fatal(_("Unable to find GML vector file "
                                  "<%s> in archive.") % filename)
         elif format_ == "pack":
             for row in maplist:
@@ -384,16 +385,16 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
                 else:
                     filename = row["filename"] + ".pack"
                 if not os.path.exists(filename):
-                    core.fatal(_("Unable to find GRASS package file "
+                    gscript.fatal(_("Unable to find GRASS package file "
                                  "<%s> in archive.") % filename)
         else:
-            core.fatal(_("Unsupported input format"))
+            gscript.fatal(_("Unsupported input format"))
 
         # Check the space time dataset
         id = output + "@" + mapset
         sp = dataset_factory(type_, id)
-        if sp.is_in_db() and core.overwrite() == False:
-            core.fatal(_("Space time %(t)s dataset <%(sp)s> is already in the "
+        if sp.is_in_db() and gscript.overwrite() == False:
+            gscript.fatal(_("Space time %(t)s dataset <%(sp)s> is already in the "
                          "database. Use the overwrite flag.") % {'t': type_,
                                                                  'sp': sp.get_id()})
 
@@ -412,8 +413,8 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
                 _import_vector_maps(maplist)
 
         # Create the space time dataset
-        if sp.is_in_db() and core.overwrite() == True:
-            core.info(_("Overwrite space time %(sp)s dataset "
+        if sp.is_in_db() and gscript.overwrite() == True:
+            gscript.info(_("Overwrite space time %(sp)s dataset "
                         "<%(id)s> and unregister all maps.") % {
                         'sp': sp.get_new_map_instance(None).get_type(),
                         'id': sp.get_id()})
@@ -425,11 +426,11 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
         relative_time_unit = None
         if temporal_type == "relative":
             if "relative_time_unit" not in init:
-                core.fatal(_("Key word %s not found in init file.") % ("relative_time_unit"))
+                gscript.fatal(_("Key word %s not found in init file.") % ("relative_time_unit"))
             relative_time_unit = init["relative_time_unit"]
             sp.set_relative_time_unit(relative_time_unit)
 
-        core.verbose(_("Create space time %s dataset.") %
+        gscript.verbose(_("Create space time %s dataset.") %
                      sp.get_new_map_instance(None).get_type())
 
         sp.set_initial_values(temporal_type=temporal_type,
@@ -453,8 +454,8 @@ def import_stds(input, output, extrdir, title=None, descr=None, location=None,
     finally:
         if location:
             # Switch to the old location
-            ret = core.run_command("g.mapset", mapset=old_env["MAPSET"],
+            ret = gscript.run_command("g.mapset", mapset=old_env["MAPSET"],
                                    location=old_env["LOCATION_NAME"],
                                    gisdbase=old_env["GISDBASE"])
 
-        core.set_raise_on_error(old_state)
+        gscript.set_raise_on_error(old_state)

lib/python/temporal/temporal_algebra.py

@@ -1434,8 +1434,7 @@ class TemporalAlgebraParser(object):
             tvardict["END_DATE"]       = end.date()
             tvardict["END_DATETIME"]   = end
             tvardict["END_TIME"]       = end.time()
-            #core.fatal(_("The temporal functions for map <%s> only supported for absolute"\
-                #          "time." % (str(map.get_id()))))
+
         return(tvardict)
 
     def eval_datetime_str(self, tfuncval, comp, value):

lib/python/temporal/univar_statistics.py

@@ -24,6 +24,7 @@ for details.
 """
 
 from open_stds import *
+import grass.script as gscript
 
 ###############################################################################
 
@@ -51,7 +52,7 @@ def print_gridded_dataset_univar_statistics(type, input, where, extended,
 
     if not rows:
         dbif.close()
-        core.fatal(_("Space time %(sp)s dataset <%(i)s> is empty") % {
+        gscript.fatal(_("Space time %(sp)s dataset <%(i)s> is empty") % {
                      'sp': sp.get_new_map_instance(None).get_type(), 'i': sp.get_id()})
 
     if no_header is False:
@@ -78,15 +79,15 @@ def print_gridded_dataset_univar_statistics(type, input, where, extended,
             flag += "e"
 
         if type == "strds":
-            stats = core.parse_command("r.univar", map=id, flags=flag)
+            stats = gscript.parse_command("r.univar", map=id, flags=flag)
         elif type == "str3ds":
-            stats = core.parse_command("r3.univar", map=id, flags=flag)
+            stats = gscript.parse_command("r3.univar", map=id, flags=flag)
 
         if not stats:
             if type == "strds":
-                core.warning(_("Unable to get statistics for raster map <%s>") % id)
+                gscript.warning(_("Unable to get statistics for raster map <%s>") % id)
             elif type == "str3ds":
-                core.warning(_("Unable to get statistics for 3d raster map <%s>") % id)
+                gscript.warning(_("Unable to get statistics for 3d raster map <%s>") % id)
             continue
         
         string += str(id) + fs + str(start) + fs + str(end)
@@ -136,7 +137,7 @@ def print_vector_dataset_univar_statistics(input, twhere, layer, type, column,
 
     if sp.is_in_db(dbif) == False:
         dbif.close()
-        core.fatal(_("Space time %(sp)s dataset <%(i)s> not found") % {
+        gscript.fatal(_("Space time %(sp)s dataset <%(i)s> not found") % {
                      'sp': sp.get_new_map_instance(None).get_type(), 'i': id})
 
     sp.select(dbif)
@@ -146,7 +147,7 @@ def print_vector_dataset_univar_statistics(input, twhere, layer, type, column,
 
     if not rows:
         dbif.close()
-        core.fatal(_("Space time %(sp)s dataset <%(i)s> is empty") % {
+        gscript.fatal(_("Space time %(sp)s dataset <%(i)s> is empty") % {
                      'sp': sp.get_new_map_instance(None).get_type(), 'i': id})
 
     string = ""
@@ -180,14 +181,14 @@ def print_vector_dataset_univar_statistics(input, twhere, layer, type, column,
         if not mylayer:
             mylayer = layer
 
-        stats = core.parse_command("v.univar", map=id, where=where,
+        stats = gscript.parse_command("v.univar", map=id, where=where,
                                    column=column, layer=mylayer,
                                    type=type, flags=flags)
 
         string = ""
 
         if not stats:
-            core.warning(_("Unable to get statistics for vector map <%s>") % id)
+            gscript.warning(_("Unable to get statistics for vector map <%s>") % id)
             continue
         
         string += str(id) + fs + str(start) + fs + str(end)