temporal framework: Better error handling for temporal operators, Code cleanup, better readability, better dry-run implementation, dry-run tests (merge from relbr72)

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

lib/python/temporal/temporal_algebra.py

@@ -582,7 +582,7 @@ class TemporalAlgebraLexer(object):
     t_QUOTE              = r'[\"\']'
 
     # These are the things that should be ignored.
-    t_ignore = ' \t'
+    t_ignore = ' \t\n'
 
     # Read time string and convert it into a date object
     def t_DATETIME(self, t):
@@ -650,12 +650,13 @@ class TemporalAlgebraLexer(object):
 
     # Handle errors.
     def t_error(self, t):
-        raise SyntaxError("syntax error on line %d near '%s'" %
-            (t.lineno, t.value))
+        raise SyntaxError("syntax error on line %d position %i near '%s'" %
+                          (t.lineno, t.lexpos, t.value))
 
     # Build the lexer
     def build(self,**kwargs):
-        self.lexer = lex.lex(module=self, optimize=False, debug=False, **kwargs)
+        self.lexer = lex.lex(module=self, optimize=False,
+                             nowarn=True, debug=0, **kwargs)
 
     # Just for testing
     def test(self,data):
@@ -794,7 +795,8 @@ class TemporalAlgebraParser(object):
 
         # Check if spatio-temporal operators are present in the expression
         if "{" in expression or "}" in expression:
-            self.msgr.error(_("Spatio temporal operators are not supported in granularity algebra mode"))
+            self.msgr.error(_("Spatio-temporal topological operators are not"
+                              " supported in granularity algebra mode"))
             return False
 
         # detect all STDS
@@ -879,8 +881,7 @@ class TemporalAlgebraParser(object):
         self.expression = expression
         self.parser.parse(expression)
 
-        if self.dry_run is True:
-            return self.process_chain_dict
+        return self.process_chain_dict
 
     def generate_map_name(self):
         """Generate an unique  map name and register it in the objects map list
@@ -897,8 +898,10 @@ class TemporalAlgebraParser(object):
         self.names[name] = name
         return name
 
-    def generate_new_map(self, base_map, bool_op='and',
-                         copy=True,  rename=True,
+    def generate_new_map(self, base_map,
+                         bool_op='and',
+                         copy=True,
+                         rename=True,
                          remove=False):
         """Generate a new map using the spatio-temporal extent of the base map
 
@@ -919,7 +922,7 @@ class TemporalAlgebraParser(object):
         # Create new map based on the related map list.
         map_new = base_map.get_new_instance(mapname)
         # Set initial map extend of new vector map.
-        self.overlay_map_extent(map_new, base_map, bool_op = bool_op, copy = copy)
+        self.overlay_map_extent(map_new, base_map, bool_op=bool_op, copy=copy)
         if not rename:
             name = base_map.get_id()
             map_new.set_id(name)
@@ -929,8 +932,12 @@ class TemporalAlgebraParser(object):
         map_new.uid = name
         return map_new
 
-    def overlay_map_extent(self, mapA, mapB, bool_op = None, temp_op = 'l',
-                            copy = False):
+    def overlay_map_extent(self,
+                           mapA,
+                           mapB,
+                           bool_op=None,
+                           temp_op='l',
+                           copy=False):
         """Compute the spatio-temporal extent of two topological related maps
 
            :param mapA: The first map
@@ -1003,7 +1010,10 @@ class TemporalAlgebraParser(object):
                     returncode = 0
         return(returncode)
 
-    def set_temporal_extent_list(self, maplist, topolist = ["EQUAL"], temporal = 'l' ):
+    def set_temporal_extent_list(self,
+                                 maplist,
+                                 topolist=["EQUAL"],
+                                 temporal='l' ):
         """ Change temporal extent of map list based on temporal relations to
                 other map list and given temporal operator.
 
@@ -1083,7 +1093,9 @@ class TemporalAlgebraParser(object):
                 self.msgr.message(_("Removing un-needed or empty %s maps"%(key)))
                 self._remove_maps(map_names[key],  key)
 
-    def _remove_maps(self,  namelist,  map_type):
+    def _remove_maps(self,
+                     namelist,
+                     map_type):
         """Remove maps of specific type
 
             :param namelist: List of map names to be removed
@@ -1105,17 +1117,20 @@ class TemporalAlgebraParser(object):
                 if self.dry_run is False:
                     m.run()
 
-    def check_stds(self, input, clear=False,  stds_type=None,  check_type=True):
+    def check_stds(self,
+                   input,
+                   clear=False,
+                   stds_type=None,
+                   check_type=True):
         """ Check if input space time dataset exist in database and return its map list.
 
-            :param input: Name of space time data set as string or list of maps.
-            :param clear: Reset the stored conditional values to empty list.
-            :param check_type: Check the type of the space time dataset to match the global stds type
-            :param stds_type: The type of the space time dataset to be opened, if not provided
-                                          then self.stdstype will be used
-
-            :return: List of maps.
+        :param input: Name of space time data set as string or list of maps.
+        :param clear: Reset the stored conditional values to empty list.
+        :param check_type: Check the type of the space time dataset to match the global stds type
+        :param stds_type: The type of the space time dataset to be opened, if not provided
+                                      then self.stdstype will be used
 
+        :return: List of maps.
         """
         if isinstance(input, str):
             # Check for mapset in given stds input.
@@ -1129,7 +1144,7 @@ class TemporalAlgebraParser(object):
             else:
                 stds = dataset_factory(self.stdstype, id_input)
             # Check for occurrence of space time dataset.
-            if stds.is_in_db(dbif=self.dbif) == False:
+            if stds.is_in_db(dbif=self.dbif) is False:
                 raise FatalError(_("Space time %s dataset <%s> not found") %
                     (stds.get_new_map_instance(None).get_type(), id_input))
             else:
@@ -1153,9 +1168,9 @@ class TemporalAlgebraParser(object):
                     if "condition_value" not in dir(map_i):
                         map_i.condition_value = []
                     # Set and check global temporal type variable and map.
-                    if map_i.is_time_absolute() and self.temporaltype == None:
+                    if map_i.is_time_absolute() and self.temporaltype is None:
                         self.temporaltype = 'absolute'
-                    elif map_i.is_time_relative() and self.temporaltype == None:
+                    elif map_i.is_time_relative() and self.temporaltype is None:
                         self.temporaltype = 'relative'
                     elif map_i.is_time_absolute() and self.temporaltype == 'relative':
                         self.msgr.fatal(_("Wrong temporal type of space time dataset <%s> \
@@ -1165,11 +1180,11 @@ class TemporalAlgebraParser(object):
                         self.msgr.fatal(_("Wrong temporal type of space time dataset <%s> \
                                       <%s> time is required") %
                                      (id_input, self.temporaltype))
-        elif isinstance(input,  self.mapclass):
+        elif isinstance(input, self.mapclass):
             # Check if the input is a single map and return it as list with one entry.
             maplist = [input]
 
-        elif isinstance(input,  list):
+        elif isinstance(input, list):
             maplist = input
             # Create map_value as empty list item.
             for map_i in maplist:
@@ -1194,9 +1209,15 @@ class TemporalAlgebraParser(object):
 
         return(maplist)
 
-    def get_temporal_topo_list(self, maplistA, maplistB = None, topolist = ["EQUAL"],
-                               assign_val = False, count_map = False, compare_bool = False,
-                               compop = None, aggregate = None):
+    def get_temporal_topo_list(self,
+                               maplistA,
+                               maplistB=None,
+                               topolist=["EQUAL"],
+                               assign_val=False,
+                               count_map=False,
+                               compare_bool=False,
+                               compop=None,
+                               aggregate=None):
         """Build temporal topology for two space time data sets, copy map objects
           for given relation into map list.
 
@@ -1397,9 +1418,12 @@ class TemporalAlgebraParser(object):
 
         return(resultlist)
 
-    def assign_bool_value(self,  map_i, tbrelations, topolist = ["EQUAL"]):
+    def assign_bool_value(self,
+                          map_i,
+                          tbrelations,
+                          topolist=["EQUAL"]):
         """ Function to assign boolean map value based on the map_values from the
-                compared map list by topological relationships.
+        compared map list by topological relationships.
 
           :param map_i: Map object with temporal extent.
           :param tbrelations: List of temporal relation to map_i.
@@ -1428,7 +1452,12 @@ class TemporalAlgebraParser(object):
 
         return(resultbool)
 
-    def compare_bool_value(self,  map_i, tbrelations, compop, aggregate,  topolist = ["EQUAL"]):
+    def compare_bool_value(self,
+                           map_i,
+                           tbrelations,
+                           compop,
+                           aggregate,
+                           topolist=["EQUAL"]):
         """ Function to evaluate two map lists with boolean values by boolean
             comparison operator.
 
@@ -1498,8 +1527,12 @@ class TemporalAlgebraParser(object):
 
         return(p.relations, p.temporal, p.function,  p.aggregate)
 
-    def perform_temporal_selection(self, maplistA, maplistB, topolist = ["EQUAL"],
-                                   inverse = False, assign_val = False):
+    def perform_temporal_selection(self,
+                                   maplistA,
+                                   maplistB,
+                                   topolist=["EQUAL"],
+                                   inverse=False,
+                                   assign_val=False):
         """This function performs temporal selection operation.
 
           :param maplistA:   List of maps representing the left side of a temporal
@@ -1579,7 +1612,11 @@ class TemporalAlgebraParser(object):
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
         return(resultlist)
 
-    def set_granularity(self, maplistA, maplistB, toperator = 'l', topolist = ["EQUAL"]):
+    def set_granularity(self,
+                        maplistA,
+                        maplistB,
+                        toperator='l',
+                        topolist=["EQUAL"]):
         """This function sets the temporal extends of a list of maps based on
              another map list.
 
@@ -1848,7 +1885,7 @@ class TemporalAlgebraParser(object):
                 map_i.condition_value = boolname
         return(maplist)
 
-    def eval_map_list(self, maplist ,thenlist, topolist = ["EQUAL"]):
+    def eval_map_list(self, maplist ,thenlist, topolist=["EQUAL"]):
         """ This function transfers boolean values from temporal expression
              from one map list to another by their topology. These boolean
              values are added to the maps as condition_value.
@@ -1874,7 +1911,7 @@ class TemporalAlgebraParser(object):
 
         return(resultlist)
 
-    def build_condition_list(self, tvarexpr, thenlist,  topolist = ["EQUAL"]):
+    def build_condition_list(self, tvarexpr, thenlist,  topolist=["EQUAL"]):
         """ This function evaluates temporal variable expressions of a conditional
              expression in two steps.
              At first it combines stepwise the single conditions by their relations with LALR.
@@ -1957,7 +1994,7 @@ class TemporalAlgebraParser(object):
              A recursive function is used to evaluate comparison statements
              from left to right in the given conditional list.
 
-             For example:
+             For example::
 
                   - [True,  '||', False, '&&', True]  -> True
                   - [True,  '||', False, '&&', False] -> False
@@ -2089,11 +2126,11 @@ class TemporalAlgebraParser(object):
                             m.flags["overwrite"].value = self.overwrite
 
                             if map_i.get_type() == 'raster':
-                                m.inputs["raster"].value = map_i.get_id(),  newident
+                                m.inputs["raster"].value = map_i.get_id(), newident
                             elif map_i.get_type() == 'raster3d':
-                                m.inputs["raster_3d"].value = map_i.get_id(),  newident
+                                m.inputs["raster_3d"].value = map_i.get_id(), newident
                             elif map_i.get_type() == 'vector':
-                                m.inputs["vector"].value = map_i.get_id(),  newident
+                                m.inputs["vector"].value = map_i.get_id(), newident
 
                             # Add the process description to the dict
                             self.process_chain_dict["processes"].append(m.get_dict())
@@ -2206,7 +2243,7 @@ class TemporalAlgebraParser(object):
         expr : STRDS LPAREN stds RPAREN
         """
         if self.run:
-            t[0] = self.check_stds(t[3], stds_type = "strds",  check_type=False)
+            t[0] = self.check_stds(t[3], stds_type = "strds", check_type=False)
         else:
             t[0] = t[3]
             if self.debug:
@@ -2219,7 +2256,7 @@ class TemporalAlgebraParser(object):
         expr : STR3DS LPAREN stds RPAREN
         """
         if self.run:
-            t[0] = self.check_stds(t[3], stds_type = "str3ds",  check_type=False)
+            t[0] = self.check_stds(t[3], stds_type = "str3ds", check_type=False)
         else:
             t[0] = t[3]
             if self.debug:
@@ -2233,7 +2270,7 @@ class TemporalAlgebraParser(object):
         """
         if self.run:
             print(t[3])
-            t[0] = self.check_stds(t[3], stds_type = "stvds",  check_type=False)
+            t[0] = self.check_stds(t[3], stds_type = "stvds", check_type=False)
         else:
             t[0] = t[3]
             if self.debug:
@@ -2332,8 +2369,9 @@ class TemporalAlgebraParser(object):
         if self.run:
             maplistA   = self.check_stds(t[1])
             maplistB   = self.check_stds(t[3])
-            resultlist = self.get_temporal_topo_list(maplistA, maplistB,
-                                                     count_map = True)
+            resultlist = self.get_temporal_topo_list(maplistA,
+                                                     maplistB,
+                                                     count_map=True)
             t[0] = resultlist
 
     def p_t_hash2(self,t):
@@ -2348,8 +2386,10 @@ class TemporalAlgebraParser(object):
             maplistA   = self.check_stds(t[1])
             maplistB   = self.check_stds(t[3])
             topolist   = self.eval_toperator(t[2], optype='hash')[0]
-            resultlist = self.get_temporal_topo_list(maplistA, maplistB, topolist,
-                                                     count_map = True)
+            resultlist = self.get_temporal_topo_list(maplistA,
+                                                     maplistB,
+                                                     topolist,
+                                                     count_map=True)
             t[0] = resultlist
 
     def p_t_hash_paren(self, t):
@@ -2431,7 +2471,7 @@ class TemporalAlgebraParser(object):
         #    A # B == 2
         #    td(A) < 31
         """
-        t_var_expr : t_td_var comp_op number
+        t_var_expr : t_td_var   comp_op number
                    | t_hash_var comp_op number
         """
         if self.run:
@@ -2493,18 +2533,18 @@ class TemporalAlgebraParser(object):
         # TODO:  Implement statement in backward direction:
         # TIME comp_op START_TIME LPAREN stds RPAREN
         """
-        t_var_expr : START_TIME LPAREN stds RPAREN comp_op TIME
-                   | START_DATE LPAREN stds RPAREN comp_op DATE
+        t_var_expr : START_TIME     LPAREN stds RPAREN comp_op TIME
+                   | START_DATE     LPAREN stds RPAREN comp_op DATE
                    | START_DATETIME LPAREN stds RPAREN comp_op DATETIME
-                   | END_TIME LPAREN stds RPAREN comp_op TIME
-                   | END_DATE LPAREN stds RPAREN comp_op DATE
-                   | END_DATETIME LPAREN stds RPAREN comp_op DATETIME
-                   | START_TIME LPAREN expr RPAREN comp_op TIME
-                   | START_DATE LPAREN expr RPAREN comp_op DATE
+                   | END_TIME       LPAREN stds RPAREN comp_op TIME
+                   | END_DATE       LPAREN stds RPAREN comp_op DATE
+                   | END_DATETIME   LPAREN stds RPAREN comp_op DATETIME
+                   | START_TIME     LPAREN expr RPAREN comp_op TIME
+                   | START_DATE     LPAREN expr RPAREN comp_op DATE
                    | START_DATETIME LPAREN expr RPAREN comp_op DATETIME
-                   | END_TIME LPAREN expr RPAREN comp_op TIME
-                   | END_DATE LPAREN expr RPAREN comp_op DATE
-                   | END_DATETIME LPAREN expr RPAREN comp_op DATETIME
+                   | END_TIME       LPAREN expr RPAREN comp_op TIME
+                   | END_DATE       LPAREN expr RPAREN comp_op DATE
+                   | END_DATETIME   LPAREN expr RPAREN comp_op DATETIME
         """
         if self.run:
             # Check input maplist.
@@ -2627,7 +2667,7 @@ class TemporalAlgebraParser(object):
         # The temporal topology relation equals is implicit
         # Examples:
         #    A {!:} B  # Select the part of A that is temporally unequal to B
-        #    A  {:} B  # Select the part of A that is temporally equal B
+        #    A { :} B  # Select the part of A that is temporally equal B
         #    A {!:, equals} B          # Select the part of A that is temporally unequal to B
         #    A {!:, during} B          # Select the part of A that is temporally not during B
         #    A {:, overlaps} B         # Select the part of A that temporally overlaps B
@@ -2734,8 +2774,8 @@ class TemporalAlgebraParser(object):
             elseresult   = self.eval_condition_list(elsecond, inverse = True)
 
             # Combine and sort else and then statement to result map list.
-            combilist = thenresult + elseresult
-            resultlist = sorted(combilist, key = AbstractDatasetComparisonKeyStartTime)
+            combilist    = thenresult + elseresult
+            resultlist   = sorted(combilist, key = AbstractDatasetComparisonKeyStartTime)
             # Clear the map and conditional values of the map list.
             resultlist   = self.check_stds(resultlist, clear = True)
             # Return resulting map list.
@@ -2763,7 +2803,7 @@ class TemporalAlgebraParser(object):
             elselist     = self.check_stds(t[9])
             # Get temporal conditional statement.
             tvarexpr     = t[5]
-            topolist     = self.eval_toperator(t[3],  optype = 'relation')[0]
+            topolist     = self.eval_toperator(t[3],  optype='relation')[0]
             thencond     = self.build_condition_list(tvarexpr, thenlist, topolist)
             thenresult   = self.eval_condition_list(thencond)
             elsecond     = self.build_condition_list(tvarexpr, elselist, topolist)
@@ -2793,8 +2833,8 @@ class TemporalAlgebraParser(object):
         # buff_t(A : B, "10 minutes")  # Select the part of A that is temporally
         #                                equal to B and create a buffer of 10 minutes around
         """
-        expr : BUFF_T LPAREN stds COMMA QUOTE number NAME QUOTE RPAREN
-             | BUFF_T LPAREN expr COMMA QUOTE number NAME QUOTE RPAREN
+        expr : BUFF_T LPAREN stds COMMA QUOTE  number NAME QUOTE RPAREN
+             | BUFF_T LPAREN expr COMMA QUOTE  number NAME QUOTE RPAREN
              | BUFF_T LPAREN stds COMMA number RPAREN
              | BUFF_T LPAREN expr COMMA number RPAREN
         """
@@ -2815,7 +2855,7 @@ class TemporalAlgebraParser(object):
 
         if self.debug:
             if len(t) == 10:
-                print(str(t[3]) + "* = buff_t(", str(t[3]), "," , '"', str(t[6]), str(t[7]), '"', ")")
+                print(str(t[3]) + "* = buff_t(", str(t[3]), ",", '"', str(t[6]), str(t[7]), '"', ")")
             elif len(t) == 7:
                 print(str(t[3]) + "* = buff_t(", str(t[3]), ",", str(t[5]), ")")
 
@@ -2843,8 +2883,8 @@ class TemporalAlgebraParser(object):
         # tshift(A : B, "10 minutes")  # Shift the selection from A temporally
         #                                by 10 minutes.
         """
-        expr : TSHIFT LPAREN stds COMMA QUOTE number NAME QUOTE RPAREN
-             | TSHIFT LPAREN expr COMMA QUOTE number NAME QUOTE RPAREN
+        expr : TSHIFT LPAREN stds COMMA QUOTE  number NAME QUOTE RPAREN
+             | TSHIFT LPAREN expr COMMA QUOTE  number NAME QUOTE RPAREN
              | TSHIFT LPAREN stds COMMA number RPAREN
              | TSHIFT LPAREN expr COMMA number RPAREN
         """
@@ -2857,7 +2897,8 @@ class TemporalAlgebraParser(object):
             elif len(t) == 7:
                 increment = str(t[5])
             # Perform shifting.
-            shiftlist = AbstractSpaceTimeDataset.shift_map_list(maplist, increment)
+            shiftlist = AbstractSpaceTimeDataset.shift_map_list(maplist,
+                                                                increment)
             t[0] = shiftlist
         else:
             t[0] = t[3] + "*"
@@ -2871,8 +2912,8 @@ class TemporalAlgebraParser(object):
     # Handle errors.
     def p_error(self, t):
         if t:
-            raise SyntaxError("syntax error on line %d, token %s near '%s' expression '%s'" %
-                             (t.lineno, t.type, t.value, self.expression))
+            raise SyntaxError("syntax error on line %d, position %i token %s near '%s' expression '%s'" %
+                              (t.lineno, t.lexpos, t.type, t.value, self.expression))
         else:
             raise SyntaxError("Unexpected syntax error")
 

lib/python/temporal/temporal_operator.py

@@ -24,32 +24,32 @@ for details.
     >>> p = TemporalOperatorParser()
     >>> expression =  "{&&, during}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['during'], 'l', '&&', '&')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{||, equal | during}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['equal', 'during'], 'l', '||', '|')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{||, equal | during, &}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['equal', 'during'], 'l', '||', '&')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{&&, during, |}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['during'], 'l', '&&', '|')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{&&, during, |, r}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['during'], 'r', '&&', '|')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{&&, during, u}"
     >>> p.parse(expression, optype = 'boolean')
-    >>> print((p.relations, p.temporal, p.function,p.aggregate))
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
     (['during'], 'u', '&&', '&')
     >>> p = TemporalOperatorParser()
     >>> expression =  "{:, during, r}"
@@ -101,6 +101,36 @@ for details.
     >>> p.parse(expression, optype = 'overlay')
     >>> print((p.relations, p.temporal, p.function))
     (['overlaps', 'overlapped'], 'r', '^')
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{&&, equal | during | contains | starts, &}"
+    >>> p.parse(expression, optype = 'boolean')
+    >>> print((p.relations, p.temporal, p.function, p.aggregate))
+    (['equal', 'during', 'contains', 'starts'], 'l', '&&', '&')
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{&&, equal | during | contains | starts, &&&&&}"
+    >>> p.parse(expression, optype = 'boolean')
+    Traceback (most recent call last):
+    SyntaxError: Unexpected syntax error in expression "{&&, equal | during | contains | starts, &&&&&}" at position 42 near &
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{+, starting}"
+    >>> p.parse(expression)
+    Traceback (most recent call last):
+    SyntaxError: syntax error on line 1 position 4 near 'starting'
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{nope, start, |, l}"
+    >>> p.parse(expression)
+    Traceback (most recent call last):
+    SyntaxError: syntax error on line 1 position 1 near 'nope'
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{++, start, |, l}"
+    >>> p.parse(expression)
+    Traceback (most recent call last):
+    SyntaxError: Unexpected syntax error in expression "{++, start, |, l}" at position 2 near +
+    >>> p = TemporalOperatorParser()
+    >>> expression =  "{^, over, right}"
+    >>> p.parse(expression, optype='rter')
+    Traceback (most recent call last):
+    SyntaxError: Unknown optype rter, must be one of ['select', 'boolean', 'raster', 'hash', 'relation', 'overlay']
 
 """
 from __future__ import print_function
@@ -163,7 +193,7 @@ class TemporalOperatorLexer(object):
     t_T_NOT_SELECT   = r'!:'
     t_COMMA          = r','
     t_LEFTREF        = '^[l|left]'
-    t_RIGHTREF       ='^[r|right]'
+    t_RIGHTREF       = '^[r|right]'
     t_UNION          = '^[u|union]'
     t_DISJOINT       = '^[d|disjoint]'
     t_INTERSECT      = '^[i|intersect]'
@@ -182,7 +212,7 @@ class TemporalOperatorLexer(object):
     t_CRPAREN        = r'\}'
 
     # These are the things that should be ignored.
-    t_ignore = ' \t'
+    t_ignore = ' \t\n'
 
     # Track line numbers.
     def t_newline(self, t):
@@ -191,8 +221,7 @@ class TemporalOperatorLexer(object):
 
     def t_NAME(self, t):
         r'[a-zA-Z_][a-zA-Z_0-9]*'
-        self.temporal_symbol(t)
-        return t
+        return self.temporal_symbol(t)
 
     # Parse symbols
     def temporal_symbol(self, t):
@@ -214,18 +243,19 @@ class TemporalOperatorLexer(object):
         elif t.value == 'i' or t.value == 'intersect':
             t.value = 'i'
             t.type = 'INTERSECT'
-        #else:
-        #    t.type = 'NAME'
+        else:
+            self.t_error(t)
         return(t)
 
     # Handle errors.
     def t_error(self, t):
-        raise SyntaxError("syntax error on line %d near '%s'" %
-                          (t.lineno, t.value))
+        raise SyntaxError("syntax error on line %d position %i near '%s'" %
+                          (t.lineno, t.lexpos, t.value))
 
     # Build the lexer
     def build(self,**kwargs):
-        self.lexer = lex.lex(module=self, **kwargs)
+        self.lexer = lex.lex(module=self, optimize=False,
+                             nowarn=True, debug=0, **kwargs)
 
     # Just for testing
     def test(self,data):
@@ -245,13 +275,15 @@ class TemporalOperatorParser(object):
     def __init__(self):
         self.lexer = TemporalOperatorLexer()
         self.lexer.build()
-        self.parser = yacc.yacc(module=self)
-        self.relations = None   # Temporal relations equals, contain, during, ...
-        self.temporal  = None   # Temporal operation like intersect, left, right, ...
-        self.function  = None   # Actual operation
-        self.aggregate = None   # Aggregation function
+        self.parser = yacc.yacc(module=self, debug=0)
+        self.relations = None   # Temporal relations (equals, contain, during, ...)
+        self.temporal  = None   # Temporal operation (intersect, left, right, ...)
+        self.function  = None   # Actual operation (+, -, /, *, ... )
+        self.aggregate = None   # Aggregation function (|, &)
 
-    def parse(self, expression,  optype='relation'):
+        self.optype_list = ["select", "boolean", "raster", "hash", "relation", "overlay"]
+
+    def parse(self, expression, optype='relation'):
         """Parse the expression and fill the object variables
 
         :param expression:
@@ -259,30 +291,38 @@ class TemporalOperatorParser(object):
                        - select   { :, during,   r}
                        - boolean  {&&, contains, |}
                        - raster   { *, equal,    |}
-                       - vector   { |, starts,   &}
+                       - overlay  { |, starts,   &}
                        - hash     { #, during,   l}
                        - relation {during}
         :return:
         """
         self.optype = optype
+
+        if optype not in self.optype_list:
+            raise SyntaxError("Unknown optype %s, must be one of %s"%(self.optype, str(self.optype_list)))
+        self.expression = expression
         self.parser.parse(expression)
-        #
 
     # Error rule for syntax errors.
     def p_error(self, t):
-        raise SyntaxError("Unexpected syntax error")
+        raise SyntaxError("Unexpected syntax error in expression"
+                          " \"%s\" at position %i near %s"%(self.expression,
+                                                            t.lexpos,
+                                                            t.value))
 
     # Get the tokens from the lexer class
     tokens = TemporalOperatorLexer.tokens
 
     def p_relation_operator(self, t):
+        # {during}
+        # {during | equal | starts}
         """
         operator : CLPAREN relation CRPAREN
                  | CLPAREN relationlist CRPAREN
         """
         # Check for correct type.
         if not self.optype == 'relation':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"relation\""%self.optype)
         else:
             # Set three operator components.
             if isinstance(t[2], list):
@@ -295,6 +335,8 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_relation_bool_operator(self, t):
+        # {||, during}
+        # {&&, during | equal | starts}
         """
         operator : CLPAREN OR  OR  COMMA relation     CRPAREN
                  | CLPAREN AND AND COMMA relation     CRPAREN
@@ -302,7 +344,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN AND AND COMMA relationlist CRPAREN
         """
         if not self.optype == 'boolean':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"boolean\""%self.optype)
         else:
             # Set three operator components.
             if isinstance(t[5], list):
@@ -316,6 +358,8 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_relation_bool_combi_operator(self, t):
+        # {||, during, &}
+        # {&&, during | equal | starts, |}
         """
         operator : CLPAREN OR  OR  COMMA relation     COMMA OR  CRPAREN
                  | CLPAREN OR  OR  COMMA relation     COMMA AND CRPAREN
@@ -327,7 +371,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN AND AND COMMA relationlist COMMA AND CRPAREN
         """
         if not self.optype == 'boolean':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"boolean\""%self.optype)
         else:
             # Set three operator components.
             if isinstance(t[5], list):
@@ -341,6 +385,8 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_relation_bool_combi_operator2(self, t):
+        # {||, during, left}
+        # {&&, during | equal | starts, union}
         """
         operator : CLPAREN OR  OR  COMMA relation     COMMA temporal CRPAREN
                  | CLPAREN AND AND COMMA relation     COMMA temporal CRPAREN
@@ -348,7 +394,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN AND AND COMMA relationlist COMMA temporal CRPAREN
         """
         if not self.optype == 'boolean':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"boolean\""%self.optype)
         else:
             # Set three operator components.
             if isinstance(t[5], list):
@@ -362,6 +408,8 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_relation_bool_combi_operator3(self, t):
+        # {||, during, |, left}
+        # {&&, during | equal | starts, &, union}
         """
         operator : CLPAREN OR  OR  COMMA relation     COMMA OR  COMMA temporal CRPAREN
                  | CLPAREN OR  OR  COMMA relation     COMMA AND COMMA temporal CRPAREN
@@ -373,7 +421,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN AND AND COMMA relationlist COMMA AND COMMA temporal CRPAREN
         """
         if not self.optype == 'boolean':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"relation\""%self.optype)
         else:
             # Set three operator components.
             if isinstance(t[5], list):
@@ -387,6 +435,10 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_select_relation_operator(self, t):
+        # {!:}
+        # { :, during}
+        # {!:, during | equal | starts}
+        # { :, during | equal | starts, l}
         """
         operator : CLPAREN select CRPAREN
                  | CLPAREN select COMMA relation     CRPAREN
@@ -395,7 +447,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN select COMMA relationlist COMMA temporal CRPAREN
         """
         if not self.optype == 'select':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"select\""%self.optype)
         else:
             if len(t) == 4:
                 # Set three operator components.
@@ -419,6 +471,10 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_hash_relation_operator(self, t):
+        # {#}
+        # {#, during}
+        # {#, during | equal | starts}
+        # {#, during | equal | starts, l}
         """
         operator : CLPAREN HASH CRPAREN
                  | CLPAREN HASH COMMA relation     CRPAREN
@@ -427,7 +483,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN HASH COMMA relationlist COMMA temporal CRPAREN
         """
         if not self.optype == 'hash':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"hash\""%self.optype)
         else:
             if len(t) == 4:
                 # Set three operator components.
@@ -451,7 +507,10 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_raster_relation_operator(self, t):
-        # The expression should always return a list of maps.
+        # {+}
+        # {-, during}
+        # {*, during | equal | starts}
+        # {/, during | equal | starts, l}
         """
         operator : CLPAREN arithmetic CRPAREN
                  | CLPAREN arithmetic COMMA relation     CRPAREN
@@ -460,7 +519,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN arithmetic COMMA relationlist COMMA temporal CRPAREN
         """
         if not self.optype == 'raster':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"raster\""%self.optype)
         else:
             if len(t) == 4:
                 # Set three operator components.
@@ -484,7 +543,10 @@ class TemporalOperatorParser(object):
             t[0] = t[2]
 
     def p_overlay_relation_operator(self, t):
-        # The expression should always return a list of maps.
+        # {+}
+        # {-, during}
+        # {~, during | equal | starts}
+        # {^, during | equal | starts, l}
         """
         operator : CLPAREN overlay CRPAREN
                  | CLPAREN overlay COMMA relation     CRPAREN
@@ -493,7 +555,7 @@ class TemporalOperatorParser(object):
                  | CLPAREN overlay COMMA relationlist COMMA temporal CRPAREN
         """
         if not self.optype == 'overlay':
-            raise SyntaxError("invalid syntax")
+            raise SyntaxError("Wrong optype \"%s\" must be \"overlay\""%self.optype)
         else:
             if len(t) == 4:
                 # Set three operator components.
@@ -534,7 +596,7 @@ class TemporalOperatorParser(object):
         t[0] = t[1]
 
     def p_over(self, t):
-        # The list of relations.
+        # The the over keyword
         """
         relation : OVER
         """

lib/python/temporal/temporal_raster3d_algebra.py

@@ -53,6 +53,8 @@ class TemporalRaster3DAlgebraParser(TemporalRasterBaseAlgebraParser):
         self.expression = expression
         self.parser.parse(expression)
 
+        return self.process_chain_dict
+
     ######################### Temporal functions ##############################
 
     def p_statement_assign(self, t):

lib/python/temporal/temporal_raster_algebra.py

@@ -95,8 +95,7 @@ class TemporalRasterAlgebraParser(TemporalRasterBaseAlgebraParser):
         self.expression = expression
         self.parser.parse(expression)
 
-        if self.dry_run is True:
-            return self.process_chain_dict
+        return self.process_chain_dict
 
     ######################### Temporal functions ##############################
 

lib/python/temporal/temporal_vector_algebra.py

@@ -370,8 +370,8 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                     vectormap = VectorDataset(vectorname + "@" + get_current_mapset())
                     if vectormap.map_exists() and self.overwrite == False:
                         self.msgr.fatal(_("Error vector maps with basename %s exist. "
-                                      "Use --o flag to overwrite existing file") \
-                                      %(vectorname))
+                                          "Use --o flag to overwrite existing file") \
+                                          %(vectorname))
                 for map_i in t[3]:
                     if "cmd_list" in dir(map_i):
                         # Execute command list.
@@ -381,7 +381,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                                 # otherwise v.overlay will break
                                 if cmd.name == "v.overlay":
                                     for name in (cmd.inputs["ainput"].value,
-                                                    cmd.inputs["binput"].value):
+                                                 cmd.inputs["binput"].value):
                                         #self.msgr.message("Check if map <" + name + "> exists")
                                         if name.find("@") < 0:
                                             name = name + "@" + get_current_mapset()
@@ -400,10 +400,11 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                             # print the command that will be executed
                             self.msgr.message("Run command:\n" + cmd.get_bash())
                             cmd.run()
+
                             if cmd.popen.returncode != 0:
-                                self.msgr.fatal(_("Error starting %s : \n%s") \
-                                                    %(cmd.get_bash(), \
-                                                    cmd.popen.stderr))
+                                self.msgr.fatal(_("Error starting %s : \n%s")
+                                                  %(cmd.get_bash(),
+                                                  cmd.popen.stderr))
                             mapname = cmd.outputs['output'].value
                             if mapname.find("@") >= 0:
                                 map_test = map_i.get_new_instance(mapname)
@@ -438,9 +439,10 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                             newident = self.basename + "_" + str(count)
                             map_result = map_i.get_new_instance(newident + "@" + self.mapset)
 
-                            if map_test.map_exists() and self.overwrite == False:
-                                self.msgr.fatal("Error raster maps with basename %s exist. Use --o flag to overwrite existing file" \
-                                                    %(mapname))
+                            if map_test.map_exists() and self.overwrite is False:
+                                self.msgr.fatal("Error raster maps with basename %s exist. "
+                                                "Use --o flag to overwrite existing file"
+                                                %(mapname))
 
                             map_result.set_temporal_extent(map_i.get_temporal_extent())
                             map_result.set_spatial_extent(map_i.get_spatial_extent())
@@ -459,10 +461,10 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
 
                 if len(register_list) > 0:
                     # Create result space time dataset.
-                    resultstds = open_new_stds(t[1], self.stdstype, \
-                                                                'absolute', t[1], t[1], \
-                                                                "temporal vector algebra", self.dbif,
-                                                                overwrite = self.overwrite)
+                    resultstds = open_new_stds(t[1], self.stdstype,
+                                               'absolute', t[1], t[1],
+                                               "temporal vector algebra", self.dbif,
+                                               overwrite=self.overwrite)
                     for map_i in register_list:
                         # Check if modules should be executed from command list.
                         if hasattr(map_i, "cmd_list") or hasattr(map_i, "is_new"):

lib/python/temporal/testsuite/unittests_temporal_algebra_grs.py

@@ -109,7 +109,7 @@ class TestTemporalAlgebraGranularity(TestCase):
        
     def test_common_granularity_2(self):
         """Testing the common granularity function year to month samping. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = A : C'
         ret = ta.setup_common_granularity(expression=expr)
         
@@ -129,7 +129,7 @@ class TestTemporalAlgebraGranularity(TestCase):
 
     def test_common_granularity_3(self):
         """Testing the common granularity function with gaps. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = A : D'
         ret = ta.setup_common_granularity(expression=expr)
         
@@ -149,7 +149,7 @@ class TestTemporalAlgebraGranularity(TestCase):
 
     def test_common_granularity_4(self):
         """Testing the common granularity function year to month with gaps. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = C : D'
         ret = ta.setup_common_granularity(expression=expr)
         
@@ -168,7 +168,7 @@ class TestTemporalAlgebraGranularity(TestCase):
        
     def test_common_granularity_4(self):
         """Testing the common granularity function year to month with gaps. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = C : D'
         ret = ta.setup_common_granularity(expression=expr)
         
@@ -187,7 +187,7 @@ class TestTemporalAlgebraGranularity(TestCase):
        
     def test_common_granularity_5(self):
         """Testing the common granularity function year to month with gaps. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = A : C : D'
         ret = ta.setup_common_granularity(expression=expr)
         
@@ -206,7 +206,7 @@ class TestTemporalAlgebraGranularity(TestCase):
          
     def test_common_granularity_6(self):
         """Testing the common granularity function year to month with gaps. """
-        ta = tgis.TemporalAlgebraParser(run = True, debug = True)
+        ta = tgis.TemporalAlgebraParser(run=True, debug=True)
         expr = 'R = if(start_month(A) > 2, A : C : D)'
         ret = ta.setup_common_granularity(expression=expr)
         

lib/python/temporal/testsuite/unittests_temporal_raster_algebra.py

@@ -77,14 +77,14 @@ class TestTemporalRasterAlgebra(TestCase):
         D.select()
         maplist = D.get_registered_maps_as_objects()
         self.assertEqual(D.metadata.get_number_of_maps(), 2)
-        self.assertEqual(D.metadata.get_min_min(), 2) 
-        self.assertEqual(D.metadata.get_max_max(), 3) 
+        self.assertEqual(D.metadata.get_min_min(), 2)
+        self.assertEqual(D.metadata.get_max_max(), 3)
         start, end = D.get_absolute_time()
         self.assertEqual(start, datetime.datetime(2001, 1, 2))
         self.assertEqual(end, datetime.datetime(2001, 1, 4))
         self.assertEqual( D.check_temporal_topology(),  False)
         self.assertEqual(D.get_granularity(),  u'2 days')
-        
+
         ta = tgis.TemporalRasterAlgebraParser(run=True, debug=True, dry_run=True)
         pc = ta.parse(expression="R = A {:,during,r} C", basename="r", overwrite=True)
 
@@ -717,6 +717,30 @@ class TestTemporalRasterAlgebra(TestCase):
         self.assertEqual( D.check_temporal_topology(),  True)
         self.assertEqual(D.get_granularity(),  u'1 day')
 
+    def test_capacity_1(self):
+        """Arithmetic test with temporal intersection"""
+        tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True)
+        expr = "R = (((((((A + A) - A) * A) / A) % A) - td(A)) - (A # A))"
+        tra.parse(expression=expr, basename="r", overwrite=True)
+
+        D = tgis.open_old_stds("R", type="strds")
+        D.select()
+        self.assertEqual(D.metadata.get_number_of_maps(), 4)
+        self.assertEqual(D.metadata.get_min_min(), -2)
+        self.assertEqual(D.metadata.get_max_max(), -2)
+        start, end = D.get_absolute_time()
+        self.assertEqual(start, datetime.datetime(2001, 1, 1))
+        self.assertEqual(end, datetime.datetime(2001, 1, 5))
+        self.assertEqual( D.check_temporal_topology(),  True)
+        self.assertEqual(D.get_granularity(),  u'1 day')
+
+        tra = tgis.TemporalRasterAlgebraParser(run=True, debug=True, dry_run=True)
+        pc = tra.parse(expression=expr, basename="r", overwrite=True)
+
+        self.assertEqual(len(pc["register"]), 4)
+        self.assertEqual(len(pc["processes"]), 4)
+        self.assertEqual(pc["STDS"]["name"], "R")
+        self.assertEqual(pc["STDS"]["stdstype"], "strds")
 
 if __name__ == '__main__':
     test()

temporal/t.rast.algebra/t.rast.algebra.py

@@ -63,6 +63,10 @@
 #% description: Use granularity sampling instead of the temporal topology approach
 #%end
 
+#%flag
+#% key: d
+#% description: Perform a dry run, compute all depenencies and module calls but don't run them
+#%end
 
 import grass.script
 import grass.temporal as tgis
@@ -75,6 +79,7 @@ def main():
     spatial = flags["s"]
     register_null = flags["n"]
     granularity = flags["g"]
+    dry_run = flags["d"]
 
     # Check for PLY istallation
     try:
@@ -86,13 +91,22 @@ def main():
                              "t.rast.algebra without PLY requirement."))
 
     tgis.init(True)
-    p = tgis.TemporalRasterAlgebraParser(run = True, debug=False, spatial = spatial, nprocs = nprocs, register_null = register_null)
+    p = tgis.TemporalRasterAlgebraParser(run = True,
+                                         debug=False,
+                                         spatial=spatial,
+                                         nprocs=nprocs,
+                                         register_null=register_null,
+                                         dry_run=dry_run)
     
     if granularity:
         if not p.setup_common_granularity(expression=expression,  lexer = tgis.TemporalRasterAlgebraLexer()):
             grass.script.fatal(_("Unable to process the expression in granularity algebra mode"))
     
-    p.parse(expression, basename, grass.script.overwrite())
+    pc = p.parse(expression, basename, grass.script.overwrite())
+
+    if dry_run is True:
+        import pprint
+        pprint.pprint(pc)
 
 if __name__ == "__main__":
     options, flags = grass.script.parser()

temporal/t.rast.algebra/testsuite/test_raster_algebra.py

@@ -74,8 +74,10 @@ class TestTRastAlgebra(TestCase):
         """Testing the conditional time dimension bug, that uses the time 
             dimension of the conditional statement instead the time dimension 
             of the then/else statement."""
-        self.assertModule("t.rast.algebra",  expression="R = if({contains}, B == 5,  A - 1,  A + 1)", 
-                                                                 basename="r")
+        self.assertModule("t.rast.algebra", expression="R = if({contains}, B == 5, "
+                                                       "A - 1,  A + 1)", basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression="R = if({contains}, B == 5, "
+                                                       "A - 1,  A + 1)", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -90,8 +92,9 @@ class TestTRastAlgebra(TestCase):
 
     def test_simple_arith_hash_1(self):
         """Simple arithmetic test including the hash operator"""
-       
-        self.assertModule("t.rast.algebra",  expression='R = A + (A {#, equal,l} A)', basename="r")
+
+        self.assertModule("t.rast.algebra", expression='R = A + (A {#, equal,l} A)', basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression='R = A + (A {#, equal,l} A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -106,7 +109,8 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_td_1(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A + td(A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = A + td(A)', basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression='R = A + td(A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -120,7 +124,8 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_td_2(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A / td(A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = A / td(A)', basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression='R = A / td(A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -134,7 +139,8 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_td_3(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A {+,equal} td(A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = A {+,equal} td(A)', basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression='R = A {+,equal} td(A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -148,7 +154,8 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_td_4(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A {/, equal} td(A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = A {/, equal} td(A)', basename="r", flags="d")
+        self.assertModule("t.rast.algebra", expression='R = A {/, equal} td(A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -163,7 +170,8 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_if_1(self):
         """Simple arithmetic test with if condition"""
        
-        self.assertModule("t.rast.algebra",  expression='R = if({equal}, start_date(A) >= "2001-01-02", A + A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = if({equal}, start_date(A)'
+                                                       ' >= "2001-01-02", A + A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -177,7 +185,7 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_if_2(self):
         """Simple arithmetic test with if condition"""
        
-        self.assertModule("t.rast.algebra",  expression='R = if({equal}, A#A == 1, A - A)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = if({equal}, A#A == 1, A - A)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -191,8 +199,9 @@ class TestTRastAlgebra(TestCase):
     def test_complex_arith_if_1(self):
         """Complex arithmetic test with if condition"""
        
-        self.assertModule("t.rast.algebra",  expression='R = if(start_date(A) < "2001-01-03" && A#A == 1, A{+, starts,l}C, A{+, finishes,l}C)', \
-                  basename="r")
+        self.assertModule("t.rast.algebra", expression='R = if(start_date(A) < "2001-01-03" && A#A == 1,'
+                                                        ' A{+, starts,l}C, A{+, finishes,l}C)',
+                          basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -206,7 +215,7 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_1(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {*, equal} A {+, equal} A", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {*, equal} A {+, equal} A", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -220,7 +229,7 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_2(self):
         """Simple arithmetic test that creates an empty strds"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {*, during} A {+, during} A", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {*, during} A {+, during} A", basename="r")
         D = tgis.open_old_stds("R", type="strds")
         
         self.assertEqual(D.metadata.get_number_of_maps(), 0)
@@ -228,7 +237,7 @@ class TestTRastAlgebra(TestCase):
     def test_simple_arith_3(self):
         """Simple arithmetic test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A / A + A*A/A", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A / A + A*A/A", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -242,7 +251,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_1(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {+,equal,i} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {+,equal,i} B", basename="r")
         D = tgis.open_old_stds("R", type="strds")
         
         self.assertEqual(D.metadata.get_number_of_maps(), 0)
@@ -250,7 +259,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_2(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {+,during,i} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {+,during,i} B", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -264,7 +273,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_3(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {+,starts,i} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {+,starts,i} B", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -278,7 +287,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_4(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {+,finishes,intersect} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {+,finishes,intersect} B", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -292,7 +301,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_5(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {+,starts|finishes,i} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {+,starts|finishes,i} B", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -306,7 +315,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_6(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = B {+,overlaps,u} C", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = B {+,overlaps,u} C", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -320,7 +329,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_7(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression="R = B {+,overlapped,u} C", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = B {+,overlapped,u} C", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -334,7 +343,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_intersection_8(self):
         """Simple temporal intersection test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A {+,during,l} buff_t(C, "1 day") ',
+        self.assertModule("t.rast.algebra", expression='R = A {+,during,l} buff_t(C, "1 day") ',
                   basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -349,7 +358,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_neighbors_1(self):
         """Simple temporal neighborhood computation test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A[-1] + A[1]',
+        self.assertModule("t.rast.algebra", expression='R = A[-1] + A[1]',
                   basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -364,7 +373,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_neighbors_2(self):
         """Simple temporal neighborhood computation test"""
        
-        self.assertModule("t.rast.algebra",  expression='R = A[0,0,-1] + A[0,0,1]',
+        self.assertModule("t.rast.algebra", expression='R = A[0,0,-1] + A[0,0,1]',
                   basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -379,7 +388,7 @@ class TestTRastAlgebra(TestCase):
     def test_tmap_function1(self):
         """Testing the tmap function. """
        
-        self.assertModule("t.rast.algebra",  expression='R = tmap(singletmap)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = tmap(singletmap)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -396,7 +405,7 @@ class TestTRastAlgebra(TestCase):
     def test_tmap_function2(self):
         """Testing the tmap function. """
        
-        self.assertModule("t.rast.algebra",  expression='R = tmap(singletmap) + 1', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = tmap(singletmap) + 1', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -413,7 +422,7 @@ class TestTRastAlgebra(TestCase):
     def test_map_function1(self):
         """Testing the map function. """
        
-        self.assertModule("t.rast.algebra",  expression='R = map(singlemap) + A', basename="r")
+        self.assertModule("t.rast.algebra", expression='R = map(singlemap) + A', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -430,7 +439,7 @@ class TestTRastAlgebra(TestCase):
     def test_map_function2(self):
         """Testing the map function. """
        
-        self.assertModule("t.rast.algebra",  expression='R =  A * map(singlemap)', basename="r")
+        self.assertModule("t.rast.algebra", expression='R =  A * map(singlemap)', basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -447,7 +456,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_select(self):
         """Testing the temporal select operator. """
        
-        self.assertModule("t.rast.algebra",  expression="R = A : A", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A : A", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -463,7 +472,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_select(self):
         """Testing the temporal select operator. """
        
-        self.assertModule("t.rast.algebra",  expression="R = A : D", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A : D", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -479,7 +488,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_select_operators1(self):
         """Testing the temporal select operator. Including temporal relations. """
        
-        self.assertModule("t.rast.algebra",  expression="R = A : D", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A : D", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -495,7 +504,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_select_operators2(self):
         """Testing the temporal select operator. Including temporal relations. """
        
-        self.assertModule("t.rast.algebra",  expression="R = A {!:,during} C", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {!:,during} C", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -512,7 +521,7 @@ class TestTRastAlgebra(TestCase):
         """Testing the temporal select operator. Including temporal relations and 
             different temporal operators (lr|+&)"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {:,during,d} B", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {:,during,d} B", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -529,7 +538,7 @@ class TestTRastAlgebra(TestCase):
         """Testing the temporal select operator. Including temporal relations and 
             different temporal operators (lr|+&)"""
        
-        self.assertModule("t.rast.algebra",  expression="R = A {:,equal|during,r} C", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A {:,equal|during,r} C", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -550,7 +559,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_hash_operator1(self):
         """Testing the temporal hash operator in the raster algebra. """
        
-        self.assertModule("t.rast.algebra",  expression="R = if(A # D == 1, A)", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = if(A # D == 1, A)", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -566,7 +575,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_hash_operator2(self):
         """Testing the temporal hash operator in the raster algebra. """
        
-        self.assertModule("t.rast.algebra",  expression="R = A # D", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = A # D", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -582,7 +591,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_hash_operator3(self):
         """Testing the temporal hash operator in the raster algebra. """
        
-        self.assertModule("t.rast.algebra",  expression="R = C {#,contains} A", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = C {#,contains} A", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -598,7 +607,7 @@ class TestTRastAlgebra(TestCase):
     def test_temporal_hash_operator4(self):
         """Testing the temporal hash operator in the raster algebra. """
        
-        self.assertModule("t.rast.algebra",  expression="R = if({contains},A # D == 1, C {#,contains} A)", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = if({contains},A # D == 1, C {#,contains} A)", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -614,7 +623,7 @@ class TestTRastAlgebra(TestCase):
     def test_raster_arithmetic_relation_1(self):
         """Arithmetic test with temporal intersection"""
        
-        self.assertModule("t.rast.algebra",  expression="R = B {+,contains,l} A ", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = B {+,contains,l} A ", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -630,7 +639,7 @@ class TestTRastAlgebra(TestCase):
     def test_raster_arithmetic_relation_2(self):
         """Arithmetic test with temporal intersection"""
        
-        self.assertModule("t.rast.algebra",  expression="R = B {*,contains,l} A ", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = B {*,contains,l} A ", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -646,7 +655,7 @@ class TestTRastAlgebra(TestCase):
     def test_raster_arithmetic_relation_3(self):
         """Arithmetic test with temporal intersection"""
        
-        self.assertModule("t.rast.algebra",  expression="R = B {+,contains,l} A ", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = B {+,contains,l} A ", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -661,8 +670,8 @@ class TestTRastAlgebra(TestCase):
     
     def test_raster_arithmetic_relation_4(self):
         """Arithmetic test with temporal intersection"""
-       
-        self.assertModule("t.rast.algebra",  expression="R = B {+,contains,r} A ", basename="r")
+
+        self.assertModule("t.rast.algebra", expression="R = B {+,contains,r} A ", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         
@@ -678,7 +687,9 @@ class TestTRastAlgebra(TestCase):
     def test_raster_arithmetic_relation_5(self):
         """Complex arithmetic test with temporal intersection"""
        
-        self.assertModule("t.rast.algebra",  expression="R = tmap(singletmap) {+,equal| precedes| follows,l} A + map(singlemap)", basename="r")
+        self.assertModule("t.rast.algebra", expression="R = tmap(singletmap) "
+                                                        "{+,equal| precedes| follows,l} "
+                                                        "A + map(singlemap)", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
         

temporal/t.rast.algebra/testsuite/test_raster_algebra_granularity.py

@@ -78,6 +78,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_1(self):
         """Simple arithmetik test"""
         expr = "R = if(C == 9,  A - 1)"
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -94,6 +95,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_2(self):
         """Simple arithmetik test"""
         expr = "R = if(D == 11,  A - 1, A + 1)"
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -110,6 +112,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_simple_arith_hash_1(self):
         """Simple arithmetic test including the hash operator"""
         expr ='R = A + (A # A)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
         
         D = tgis.open_old_stds("R", type="strds")
@@ -125,6 +128,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_simple_arith_td_1(self):
         """Simple arithmetic test"""
         expr = 'R = A + td(A:D)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
         
         D = tgis.open_old_stds("R", type="strds")
@@ -141,6 +145,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_simple_arith_if_1(self):
         """Simple arithmetic test with if condition"""
         expr = 'R = if(start_date(A) >= "2001-02-01", A + A)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -155,6 +160,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_simple_arith_if_2(self):
         """Simple arithmetic test with if condition"""
         expr = 'R = if(A#A == 1, A - A)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -169,6 +175,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_complex_arith_if_1(self):
         """Complex arithmetic test with if condition"""
         expr = 'R = if(start_date(A) < "2001-03-01" && A#A == 1, A+C, A-C)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -183,6 +190,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_temporal_neighbors(self):
         """Simple temporal neighborhood computation test"""
         expr ='R = (A[0,0,-1] : D) + (A[0,0,1] : D)'
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -197,6 +205,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_map(self):
         """Test STDS + single map without timestamp"""
         expr = "R = A + map(singletmap)"
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")
@@ -211,6 +220,7 @@ class TestTRastAlgebraGranularity(TestCase):
     def test_tmap_map(self):
         """Test STDS + single map with and without timestamp"""
         expr = "R = tmap(singletmap) + A + map(singletmap)"
+        self.assertModule("t.rast.algebra",  expression=expr, flags="gd", basename="r")
         self.assertModule("t.rast.algebra",  expression=expr, flags="g", basename="r")
 
         D = tgis.open_old_stds("R", type="strds")

temporal/t.select/t.select.py

@@ -71,9 +71,8 @@ def main():
     pc = p.parse(expression, stdstype,  overwrite=grass.overwrite)
 
     if dry_run is True:
-        import simplejson
-        s = simplejson.dumps(pc)
-        print(s)
+        import pprint
+        pprint.pprint(pc)
 
 
 if __name__ == "__main__":