temporal: support python3

Fix conflicts during rebasing

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

lib/python/temporal/__init__.py

@@ -1,33 +1,35 @@
-from core import *
-from base import *
-from spatial_extent import *
-from metadata import *
-from abstract_dataset import *
-from abstract_map_dataset import *
-from abstract_space_time_dataset import *
-from space_time_datasets import *
-from datetime_math import *
-from open_stds import *
-from factory import *
-from gui_support import *
-from list_stds import *
-from register import *
-from sampling import *
-from aggregation import *
-from extract import *
-from stds_export import *
-from stds_import import *
-from mapcalc import *
-from univar_statistics import *
-from c_libraries_interface import *
-from spatio_temporal_relationships import *
-from spatial_topology_dataset_connector import *
-from temporal_extent import *
-from temporal_topology_dataset_connector import *
-from temporal_granularity import *
-from temporal_algebra import *
-from temporal_vector_algebra import *
-from temporal_raster_base_algebra import *
-from temporal_raster_algebra import *
-from temporal_raster3d_algebra import *
-from temporal_operator import *
+from __future__ import (absolute_import)
+
+from .core import *
+from .base import *
+from .spatial_extent import *
+from .metadata import *
+from .abstract_dataset import *
+from .abstract_map_dataset import *
+from .abstract_space_time_dataset import *
+from .space_time_datasets import *
+from .datetime_math import *
+from .open_stds import *
+from .factory import *
+from .gui_support import *
+from .list_stds import *
+from .register import *
+from .sampling import *
+from .aggregation import *
+from .extract import *
+from .stds_export import *
+from .stds_import import *
+from .mapcalc import *
+from .univar_statistics import *
+from .c_libraries_interface import *
+from .spatio_temporal_relationships import *
+from .spatial_topology_dataset_connector import *
+from .temporal_extent import *
+from .temporal_topology_dataset_connector import *
+from .temporal_granularity import *
+from .temporal_algebra import *
+from .temporal_vector_algebra import *
+from .temporal_raster_base_algebra import *
+from .temporal_raster_algebra import *
+from .temporal_raster3d_algebra import *
+from .temporal_operator import *

lib/python/temporal/abstract_dataset.py

@@ -11,11 +11,11 @@ for details.
 :authors: Soeren Gebbert
 """
 from abc import ABCMeta, abstractmethod
-from temporal_extent import *
-from spatial_extent import *
-from metadata import *
-from temporal_topology_dataset_connector import *
-from spatial_topology_dataset_connector import *
+from .temporal_extent import *
+from .spatial_extent import *
+from .metadata import *
+from .temporal_topology_dataset_connector import *
+from .spatial_topology_dataset_connector import *
 
 ###############################################################################
 

lib/python/temporal/abstract_map_dataset.py

@@ -10,8 +10,9 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from abstract_dataset import *
-from datetime_math import *
+from __future__ import print_function
+from .abstract_dataset import *
+from .datetime_math import *
 
 
 class AbstractMapDataset(AbstractDataset):
@@ -199,16 +200,16 @@ class AbstractMapDataset(AbstractDataset):
         if self.get_type() == "raster":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- Raster Dataset ----------------------------------------+"
+            print(" +-------------------- Raster Dataset ----------------------------------------+")
         if self.get_type() == "raster3d":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- 3D Raster Dataset -------------------------------------+"
+            print(" +-------------------- 3D Raster Dataset -------------------------------------+")
         if self.get_type() == "vector":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- Vector Dataset ----------------------------------------+"
-        print " |                                                                            |"
+            print(" +-------------------- Vector Dataset ----------------------------------------+")
+        print(" |                                                                            |")
         self.base.print_info()
         self.temporal_extent.print_info()
         if self.is_topology_build():
@@ -228,8 +229,8 @@ class AbstractMapDataset(AbstractDataset):
                 else:
                     string += ",%s" % ds
                 count += 1
-        print " | Registered datasets ........ " + string
-        print " +----------------------------------------------------------------------------+"
+        print(" | Registered datasets ........ " + string)
+        print(" +----------------------------------------------------------------------------+")
 
     def print_shell_info(self):
         """Print information about this object in shell style"""
@@ -247,7 +248,7 @@ class AbstractMapDataset(AbstractDataset):
                 else:
                     string += ",%s" % ds
                 count += 1
-            print "registered_datasets=" + string
+            print("registered_datasets=" + string)
 
         if self.is_topology_build():
             self.print_topology_shell_info()
@@ -539,25 +540,25 @@ class AbstractMapDataset(AbstractDataset):
                >>> map      = tgis.RasterDataset(None)
                >>> temp_ext = tgis.RasterRelativeTime(start_time=1, end_time=2, unit="years")
                >>> map.set_temporal_extent(temp_ext)
-               >>> print map.get_temporal_extent_as_tuple()
+               >>> print(map.get_temporal_extent_as_tuple())
                (1, 2)
                >>> map      = tgis.VectorDataset(None)
                >>> temp_ext = tgis.VectorAbsoluteTime(start_time=datetime.datetime(2000, 1, 1),
                ...                                        end_time=datetime.datetime(2001, 1, 1))
                >>> map.set_temporal_extent(temp_ext)
-               >>> print map.get_temporal_extent_as_tuple()
+               >>> print(map.get_temporal_extent_as_tuple())
                (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2001, 1, 1, 0, 0))
 
                >>> map1 = tgis.VectorDataset("A@P")
                >>> check = map1.set_absolute_time(datetime.datetime(2000,5,5), datetime.datetime(2005,6,6))
-               >>> print map1.get_temporal_extent_as_tuple()
+               >>> print(map1.get_temporal_extent_as_tuple())
                (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
                >>> map2 = tgis.RasterDataset("B@P")
                >>> check = map2.set_absolute_time(datetime.datetime(1990,1,1), datetime.datetime(1999,8,1))
-               >>> print map2.get_temporal_extent_as_tuple()
+               >>> print(map2.get_temporal_extent_as_tuple())
                (datetime.datetime(1990, 1, 1, 0, 0), datetime.datetime(1999, 8, 1, 0, 0))
                >>> map2.set_temporal_extent(map1.get_temporal_extent())
-               >>> print map2.get_temporal_extent_as_tuple()
+               >>> print(map2.get_temporal_extent_as_tuple())
                (datetime.datetime(2000, 5, 5, 0, 0), datetime.datetime(2005, 6, 6, 0, 0))
 
         """
@@ -710,7 +711,7 @@ class AbstractMapDataset(AbstractDataset):
                >>> map      = tgis.RasterDataset(None)
                >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
                >>> map.set_spatial_extent(spat_ext)
-               >>> print map.get_spatial_extent_as_tuple()
+               >>> print(map.get_spatial_extent_as_tuple())
                (10.0, -10.0, 20.0, -20.0, 5.0, -5.0)
 
         """
@@ -729,7 +730,7 @@ class AbstractMapDataset(AbstractDataset):
                >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
                >>> map.set_spatial_extent(spat_ext)
                >>> map.spatial_buffer(10)
-               >>> print map.get_spatial_extent_as_tuple()
+               >>> print(map.get_spatial_extent_as_tuple())
                (20.0, -20.0, 30.0, -30.0, 15.0, -15.0)
 
         """
@@ -756,7 +757,7 @@ class AbstractMapDataset(AbstractDataset):
                >>> spat_ext = tgis.SpatialExtent(north=10, south=-10, east=20, west=-20, top=5, bottom=-5)
                >>> map.set_spatial_extent(spat_ext)
                >>> map.spatial_buffer_2d(10)
-               >>> print map.get_spatial_extent_as_tuple()
+               >>> print(map.get_spatial_extent_as_tuple())
                (20.0, -20.0, 30.0, -30.0, 5.0, -5.0)
 
         """

lib/python/temporal/abstract_space_time_dataset.py

@@ -10,11 +10,12 @@ for details.
 
 :authors: Soeren Gebbert
 """
+from __future__ import print_function
 import sys
 import uuid
-from abstract_dataset import *
-from temporal_granularity import *
-from spatio_temporal_relationships import *
+from .abstract_dataset import *
+from .temporal_granularity import *
+from .spatio_temporal_relationships import *
 
 ###############################################################################
 
@@ -98,21 +99,21 @@ class AbstractSpaceTimeDataset(AbstractDataset):
         if self.get_type() == "strds":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- Space Time Raster Dataset -----------------------------+"
+            print(" +-------------------- Space Time Raster Dataset -----------------------------+")
         if self.get_type() == "str3ds":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- Space Time 3D Raster Dataset --------------------------+"
+            print(" +-------------------- Space Time 3D Raster Dataset --------------------------+")
         if self.get_type() == "stvds":
             #                1         2         3         4         5         6         7
             #      0123456789012345678901234567890123456789012345678901234567890123456789012345678
-            print " +-------------------- Space Time Vector Dataset -----------------------------+"
-        print " |                                                                            |"
+            print(" +-------------------- Space Time Vector Dataset -----------------------------+")
+        print(" |                                                                            |")
         self.base.print_info()
         self.temporal_extent.print_info()
         self.spatial_extent.print_info()
         self.metadata.print_info()
-        print " +----------------------------------------------------------------------------+"
+        print(" +----------------------------------------------------------------------------+")
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
@@ -1137,7 +1138,7 @@ class AbstractSpaceTimeDataset(AbstractDataset):
                 ...     maps.append(map)
                 >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,8,1)
                 >>> for map_list in grans:
-                ...    print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+                ...    print(map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple())
                 None (0, 1)
                 None (1, 2)
                 map0@PERMANENT (2, 3)
@@ -1156,7 +1157,7 @@ class AbstractSpaceTimeDataset(AbstractDataset):
                 >>> maps.append(map2)
                 >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
                 >>> for map_list in grans:
-                ...    print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+                ...    print(map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple())
                 None (0, 2)
                 map1@PERMANENT (2, 4)
                 map1@PERMANENT (4, 6)
@@ -1175,7 +1176,7 @@ class AbstractSpaceTimeDataset(AbstractDataset):
                 >>> maps.append(map2)
                 >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,0,16,2)
                 >>> for map_list in grans:
-                ...    print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+                ...    print(map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple())
                 None (0, 2)
                 map1@PERMANENT (2, 4)
                 None (4, 6)
@@ -1194,7 +1195,7 @@ class AbstractSpaceTimeDataset(AbstractDataset):
                 >>> maps.append(map2)
                 >>> grans = tgis.AbstractSpaceTimeDataset.resample_maplist_by_granularity(maps,datetime(2000,1,1),datetime(2001,4,1),"1 month")
                 >>> for map_list in grans:
-                ...    print map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple()
+                ...    print(map_list[0].get_id(), map_list[0].get_temporal_extent_as_tuple())
                 None (datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2000, 2, 1, 0, 0))
                 None (datetime.datetime(2000, 2, 1, 0, 0), datetime.datetime(2000, 3, 1, 0, 0))
                 None (datetime.datetime(2000, 3, 1, 0, 0), datetime.datetime(2000, 4, 1, 0, 0))

lib/python/temporal/aggregation.py

@@ -17,10 +17,10 @@ for details.
 :author: Soeren Gebbert
 """
 
-from space_time_datasets import *
-from datetime_math import create_suffix_from_datetime
-from datetime_math import create_time_suffix
-from datetime_math import create_numeric_suffic
+from .space_time_datasets import *
+from .datetime_math import create_suffix_from_datetime
+from .datetime_math import create_time_suffix
+from .datetime_math import create_numeric_suffic
 import grass.script as gscript
 from grass.exceptions import CalledModuleError
 

lib/python/temporal/base.py

@@ -24,9 +24,9 @@ for details.
 
 :author: Soeren Gebbert
 """
-
+from __future__ import print_function
 from datetime import datetime
-from core import *
+from .core import *
 
 ###############################################################################
 
@@ -186,7 +186,7 @@ class DictSQLSerializer(object):
     def print_self(self):
         """Print the content of the internal dictionary to stdout
         """
-        print self.D
+        print(self.D)
 
 ###############################################################################
 
@@ -276,7 +276,7 @@ class SQLDatabaseInterface(DictSQLSerializer):
                         if None a temporary connection will be established
         """
         sql = self.get_delete_statement()
-        #print sql
+        #print(sql)
 
         if dbif:
             dbif.execute(sql,   mapset=self.mapset)
@@ -350,8 +350,8 @@ class SQLDatabaseInterface(DictSQLSerializer):
                         if None a temporary connection will be established
         """
         sql, args = self.get_select_statement()
-        #print sql
-        #print args
+        #print(sql)
+        #print(args)
 
         if dbif:
             if len(args) == 0:
@@ -408,8 +408,8 @@ class SQLDatabaseInterface(DictSQLSerializer):
                         if None a temporary connection will be established
         """
         sql, args = self.get_insert_statement()
-        #print sql
-        #print args
+        #print(sql)
+        #print(args)
 
         if dbif:
             dbif.execute(sql, args, mapset=self.mapset)
@@ -462,8 +462,8 @@ class SQLDatabaseInterface(DictSQLSerializer):
             self.msgr.fatal(_("Missing identifer"))
 
         sql, args = self.get_update_statement(ident)
-        #print sql
-        #print args
+        #print(sql)
+        #print(args)
 
         if dbif:
             dbif.execute(sql, args, mapset=self.mapset)
@@ -513,8 +513,8 @@ class SQLDatabaseInterface(DictSQLSerializer):
             self.msgr.fatal(_("Missing identifer"))
 
         sql, args = self.get_update_all_statement(ident)
-        #print sql
-        #print args
+        #print(sql)
+        #print(args)
 
         if dbif:
             dbif.execute(sql, args, mapset=self.mapset)
@@ -766,26 +766,26 @@ class DatasetBase(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " +-------------------- Basic information -------------------------------------+"
-        print " | Id: ........................ " + str(self.get_id())
-        print " | Name: ...................... " + str(self.get_name())
-        print " | Mapset: .................... " + str(self.get_mapset())
+        print( " +-------------------- Basic information -------------------------------------+")
+        print( " | Id: ........................ " + str(self.get_id()))
+        print(" | Name: ...................... " + str(self.get_name()))
+        print(" | Mapset: .................... " + str(self.get_mapset()))
         if self.get_layer():
-            print " | Layer:...................... " + str(self.get_layer())
-        print " | Creator: ................... " + str(self.get_creator())
-        print " | Temporal type: ............. " + str(self.get_ttype())
-        print " | Creation time: ............. " + str(self.get_ctime())
+            print(" | Layer:...................... " + str(self.get_layer()))
+        print(" | Creator: ................... " + str(self.get_creator()))
+        print(" | Temporal type: ............. " + str(self.get_ttype()))
+        print(" | Creation time: ............. " + str(self.get_ctime()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "id=" + str(self.get_id())
-        print "name=" + str(self.get_name())
-        print "mapset=" + str(self.get_mapset())
+        print("id=" + str(self.get_id()))
+        print("name=" + str(self.get_name()))
+        print("mapset=" + str(self.get_mapset()))
         if self.get_layer():
-            print "layer=" + str(self.get_layer())
-        print "creator=" + str(self.get_creator())
-        print "temporal_type=" + str(self.get_ttype())
-        print "creation_time=" + str(self.get_ctime())
+            print("layer=" + str(self.get_layer()))
+        print("creator=" + str(self.get_creator()))
+        print("temporal_type=" + str(self.get_ttype()))
+        print("creation_time=" + str(self.get_ctime()))
 
 ###############################################################################
 
@@ -901,7 +901,7 @@ class STDSBase(DatasetBase):
 
            :return: None if not found
         """
-        if self.D.has_key("modification_time"):
+        if "modification_time" in self.D:
             return self.D["modification_time"]
         else:
             return None
@@ -912,15 +912,15 @@ class STDSBase(DatasetBase):
         """Print information about this class in human readable style"""
         DatasetBase.print_info(self)
         #      0123456789012345678901234567890
-        print " | Modification time:.......... " + str(self.get_mtime())
-        print " | Semantic type:.............. " + str(
-            self.get_semantic_type())
+        print(" | Modification time:.......... " + str(self.get_mtime()))
+        print(" | Semantic type:.............. " + str(
+            self.get_semantic_type()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         DatasetBase.print_shell_info(self)
-        print "modification_time=" + str(self.get_mtime())
-        print "semantic_type=" + str(self.get_semantic_type())
+        print("modification_time=" + str(self.get_mtime()))
+        print("semantic_type=" + str(self.get_semantic_type()))
 
 ###############################################################################
 

lib/python/temporal/c_libraries_interface.py

@@ -18,7 +18,7 @@ import sys
 from multiprocessing import Process, Lock, Pipe
 import logging
 from ctypes import *
-from core import *
+from .core import *
 import grass.lib.gis as libgis
 import grass.lib.raster as libraster
 import grass.lib.vector as libvector
@@ -59,7 +59,7 @@ class RPCDefs(object):
 
 
 def _read_map_full_info(lock, conn, data):
-    """Read full map specific metadata from the spatial database using 
+    """Read full map specific metadata from the spatial database using
        PyGRASS functions.
 
        :param lock: A multiprocessing.Lock instance
@@ -85,21 +85,21 @@ def _read_map_full_info(lock, conn, data):
 
 def _read_raster_full_info(name, mapset):
     """Read raster info, history and cats using PyGRASS RasterRow
-       and return a dictionary. Colors should be supported in the 
+       and return a dictionary. Colors should be supported in the
        future.
     """
-    
+
     info = {}
     r = RasterRow(name=name, mapset=mapset)
     if r.exist() is True:
         r.open("r")
-        
+
         for item in r.info:
             info[item[0]] = item[1]
 
         for item in r.hist:
             info[item[0]] = item[1]
-        
+
         info["full_name"] = r.name_mapset()
         info["mtype"] = r.mtype
         if r.cats:
@@ -150,14 +150,14 @@ def _read_vector_full_info(name, mapset, layer = None):
         info["title"] = v.title
         info["thresh"] = v.thresh
         info["zone"] = v.zone
-        vtypes = ['areas', 'dblinks', 'faces', 'holes', 'islands', 
-                  'kernels', 'lines', 'nodes', 'points', 'updated_lines', 
+        vtypes = ['areas', 'dblinks', 'faces', 'holes', 'islands',
+                  'kernels', 'lines', 'nodes', 'points', 'updated_lines',
                   'updated_nodes', 'volumes']
         for vtype in vtypes:
             info[vtype] = v.number_of(vtype)
-            
+
         info.update(v.num_primitives())
-        
+
         if v.table is not None:
             info["columns"] = v.table.columns
 
@@ -293,15 +293,15 @@ def _available_mapsets(lock, conn, data):
         while mapsets[count]:
             char_list = ""
             mapset = mapsets[count]
-            
+
             permission = libgis.G_mapset_permissions(mapset)
             in_search_path = libgis.G_is_mapset_in_search_path(mapset)
-            
+
             c = 0
             while mapset[c] != "\x00":
                 char_list += mapset[c]
                 c += 1
-            
+
             if permission >= 0 and in_search_path == 1:
                 mapset_list.append(char_list)
 
@@ -1172,10 +1172,10 @@ class CLibrariesInterface(RPCServerBase):
         self.client_conn.send([RPCDefs.READ_MAP_INFO, RPCDefs.TYPE_RASTER,
                                name, mapset, None])
         return self.safe_receive("read_raster_info")
-        
+
     def read_raster_full_info(self, name, mapset):
         """Read raster info, history and cats using PyGRASS RasterRow
-           and return a dictionary. Colors should be supported in the 
+           and return a dictionary. Colors should be supported in the
            future.
 
            :param name: The name of the map
@@ -1184,7 +1184,7 @@ class CLibrariesInterface(RPCServerBase):
                      or None in case of an error
         """
         self.check_server()
-        self.client_conn.send([RPCDefs.READ_MAP_FULL_INFO, 
+        self.client_conn.send([RPCDefs.READ_MAP_FULL_INFO,
                                RPCDefs.TYPE_RASTER,
                                name, mapset, None])
         return self.safe_receive("read_raster_full_info")
@@ -1379,7 +1379,7 @@ class CLibrariesInterface(RPCServerBase):
 
     def read_vector_full_info(self, name, mapset):
         """Read vector info using PyGRASS VectorTopo
-           and return a dictionary. 
+           and return a dictionary.
 
            :param name: The name of the map
            :param mapset: The mapset of the map
@@ -1387,7 +1387,7 @@ class CLibrariesInterface(RPCServerBase):
                      or None in case of an error
         """
         self.check_server()
-        self.client_conn.send([RPCDefs.READ_MAP_FULL_INFO, 
+        self.client_conn.send([RPCDefs.READ_MAP_FULL_INFO,
                                RPCDefs.TYPE_VECTOR,
                                name, mapset, None])
         return self.safe_receive("read_vector_full_info")

lib/python/temporal/core.py

@@ -34,9 +34,15 @@ import os
 import gettext
 gettext.install('grasslibs', os.path.join(os.getenv("GISBASE"), 'locale'))
 
+try:
+    from builtins import long
+except ImportError:
+    # python3
+    long = int
+
 import grass.script as gscript
 from datetime import datetime
-from c_libraries_interface import *
+from .c_libraries_interface import *
 from grass.pygrass import messages
 # Import all supported database backends
 # Ignore import errors since they are checked later
@@ -61,16 +67,20 @@ def profile_function(func):
     do_profiling = os.getenv("GRASS_TGIS_PROFILE")
 
     if do_profiling is "True" or do_profiling is "1":
-        import cProfile, pstats, StringIO
+        import cProfile, pstats
+        try:
+            import StringIO as io
+        except ImportError:
+            import io
         pr = cProfile.Profile()
         pr.enable()
         func()
         pr.disable()
-        s = StringIO.StringIO()
+        s = io.StringIO()
         sortby = 'cumulative'
         ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
         ps.print_stats()
-        print s.getvalue()
+        print(s.getvalue())
     else:
         func()
 
@@ -560,13 +570,13 @@ def init(raise_fatal_error=False):
     database_string = ciface.get_database_name()
 
     # Set the mapset check and the timestamp write
-    if grassenv.has_key("TGIS_DISABLE_MAPSET_CHECK"):
+    if "TGIS_DISABLE_MAPSET_CHECK" in grassenv:
         if grassenv["TGIS_DISABLE_MAPSET_CHECK"] == "True" or \
            grassenv["TGIS_DISABLE_MAPSET_CHECK"] == "1":
             enable_mapset_check = False
             msgr.warning("TGIS_DISABLE_MAPSET_CHECK is True")
 
-    if grassenv.has_key("TGIS_DISABLE_TIMESTAMP_WRITE"):
+    if "TGIS_DISABLE_TIMESTAMP_WRITE" in grassenv:
         if grassenv["TGIS_DISABLE_TIMESTAMP_WRITE"] == "True" or \
            grassenv["TGIS_DISABLE_TIMESTAMP_WRITE"] == "1":
             enable_timestamp_write = False
@@ -1161,9 +1171,9 @@ class DBConnection(object):
                 if self.connected:
                     try:
                         return self.cursor.mogrify(sql, args)
-                    except:
-                        print sql, args
-                        raise
+                    except Exception as exc:
+                        print(sql, args)
+                        raise exc
                 else:
                     self.connect()
                     statement = self.cursor.mogrify(sql, args)

lib/python/temporal/datetime_math.py

@@ -9,7 +9,7 @@ for details.
 :authors: Soeren Gebbert
 """
 from datetime import datetime, timedelta
-from core import *
+from .core import *
 import copy
 
 try:
@@ -863,9 +863,9 @@ def create_suffix_from_datetime(start_time,  granularity):
 
 def create_time_suffix(mapp, end=False):
     """Create a datetime string based on a map datetime object
-    
+
        :param mapp: a temporal map dataset
-       :param end: True if you want add also end time to the suffix    
+       :param end: True if you want add also end time to the suffix
     """
     start = mapp.temporal_extent.get_start_time()
     sstring = start.isoformat().replace(':', '_').replace('-', '_')

lib/python/temporal/extract.py

@@ -10,11 +10,11 @@ for details.
 """
 
 from grass.script.utils import get_num_suffix
-from space_time_datasets import *
-from open_stds import *
-from datetime_math import create_suffix_from_datetime
-from datetime_math import create_time_suffix
-from datetime_math import create_numeric_suffic
+from .space_time_datasets import *
+from .open_stds import *
+from .datetime_math import create_suffix_from_datetime
+from .datetime_math import create_time_suffix
+from .datetime_math import create_numeric_suffic
 from multiprocessing import Process
 import grass.script as gscript
 from grass.exceptions import CalledModuleError
@@ -183,7 +183,7 @@ def extract_dataset(input, output, type, where, expression, base, time_suffix,
         msgr.percent(0, num_rows, 1)
 
         temporal_type, semantic_type, title, description = sp.get_initial_values()
-        new_sp = open_new_stds(output, type, sp.get_temporal_type(), title, 
+        new_sp = open_new_stds(output, type, sp.get_temporal_type(), title,
                                description, semantic_type, dbif,
                                gscript.overwrite())
 

lib/python/temporal/factory.py

@@ -18,7 +18,7 @@ for details.
 :authors: Soeren Gebbert
 """
 
-from space_time_datasets import *
+from .space_time_datasets import *
 
 ###############################################################################
 

lib/python/temporal/gui_support.py

@@ -10,8 +10,8 @@ for details.
 :authors: Soeren Gebbert
 """
 
-from space_time_datasets import *
-from factory import *
+from .space_time_datasets import *
+from .factory import *
 import grass.script as gscript
 
 ###############################################################################

lib/python/temporal/list_stds.py

@@ -17,10 +17,10 @@ for details.
 
 :authors: Soeren Gebbert
 """
-
-from space_time_datasets import *
-from factory import *
-from open_stds import *
+from __future__ import print_function
+from .space_time_datasets import *
+from .factory import *
+from .open_stds import *
 
 ###############################################################################
 
@@ -58,13 +58,13 @@ def get_dataset_list(type, temporal_type, columns=None, where=None,
             >>> rows =  stds_list[mapset]
             >>> for row in rows:
             ...     if row["name"] == name:
-            ...         print True
+            ...         print(True)
             True
             >>> stds_list = tgis.get_dataset_list("strds", "absolute", columns="name,mapset", where="mapset = '%s'"%(mapset))
             >>> rows =  stds_list[mapset]
             >>> for row in rows:
             ...     if row["name"] == name and row["mapset"] == mapset:
-            ...         print True
+            ...         print(True)
             True
             >>> check = sp.delete()
 
@@ -192,7 +192,7 @@ def list_maps_of_stds(type, input, columns, order, where, separator,
             if outpath:
                 outfile.write('{st}\n'.format(st=string))
             else:
-                print string
+                print(string)
 
         if maps and len(maps) > 0:
 
@@ -240,7 +240,7 @@ def list_maps_of_stds(type, input, columns, order, where, separator,
                 if outpath:
                     outfile.write('{st}\n'.format(st=string))
                 else:
-                    print string
+                    print(string)
 
     else:
         # In comma separated mode only map ids are needed
@@ -262,7 +262,7 @@ def list_maps_of_stds(type, input, columns, order, where, separator,
                 if outpath:
                     outfile.write('{st}\n'.format(st=string))
                 else:
-                    print string
+                    print(string)
 
             elif method == "cols":
                 # Print the column names if requested
@@ -281,7 +281,7 @@ def list_maps_of_stds(type, input, columns, order, where, separator,
                     if outpath:
                         outfile.write('{st}\n'.format(st=output))
                     else:
-                        print output
+                        print(output)
 
                 for row in rows:
                     output = ""
@@ -295,7 +295,7 @@ def list_maps_of_stds(type, input, columns, order, where, separator,
                     if outpath:
                         outfile.write('{st}\n'.format(st=output))
                     else:
-                        print output
+                        print(output)
     if outpath:
         outfile.close()
     if connected:

lib/python/temporal/mapcalc.py

@@ -9,8 +9,8 @@ for details.
 :authors: Soeren Gebbert
 """
 
-from space_time_datasets import *
-from open_stds import *
+from .space_time_datasets import *
+from .open_stds import *
 from multiprocessing import Process
 import grass.script as gscript
 from grass.exceptions import CalledModuleError

lib/python/temporal/metadata.py

@@ -21,7 +21,8 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from base import *
+from __future__ import print_function
+from .base import *
 
 ###############################################################################
 
@@ -234,26 +235,26 @@ class RasterMetadataBase(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " | Datatype:................... " + str(self.get_datatype())
-        print " | Number of columns:.......... " + str(self.get_cols())
-        print " | Number of rows:............. " + str(self.get_rows())
-        print " | Number of cells:............ " + str(
-            self.get_number_of_cells())
-        print " | North-South resolution:..... " + str(self.get_nsres())
-        print " | East-west resolution:....... " + str(self.get_ewres())
-        print " | Minimum value:.............. " + str(self.get_min())
-        print " | Maximum value:.............. " + str(self.get_max())
+        print(" | Datatype:................... " + str(self.get_datatype()))
+        print(" | Number of columns:.......... " + str(self.get_cols()))
+        print(" | Number of rows:............. " + str(self.get_rows()))
+        print(" | Number of cells:............ " + str(
+            self.get_number_of_cells()))
+        print(" | North-South resolution:..... " + str(self.get_nsres()))
+        print(" | East-west resolution:....... " + str(self.get_ewres()))
+        print(" | Minimum value:.............. " + str(self.get_min()))
+        print(" | Maximum value:.............. " + str(self.get_max()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "datatype=" + str(self.get_datatype())
-        print "cols=" + str(self.get_cols())
-        print "rows=" + str(self.get_rows())
-        print "number_of_cells=" + str(self.get_number_of_cells())
-        print "nsres=" + str(self.get_nsres())
-        print "ewres=" + str(self.get_ewres())
-        print "min=" + str(self.get_min())
-        print "max=" + str(self.get_max())
+        print("datatype=" + str(self.get_datatype()))
+        print("cols=" + str(self.get_cols()))
+        print("rows=" + str(self.get_rows()))
+        print("number_of_cells=" + str(self.get_number_of_cells()))
+        print("nsres=" + str(self.get_nsres()))
+        print("ewres=" + str(self.get_ewres()))
+        print("min=" + str(self.get_min()))
+        print("max=" + str(self.get_max()))
 
 ###############################################################################
 
@@ -323,7 +324,7 @@ class RasterMetadata(RasterMetadataBase):
 
     def print_info(self):
         """Print information about this class in human readable style"""
-        print " +-------------------- Metadata information ----------------------------------+"
+        print(" +-------------------- Metadata information ----------------------------------+")
         #      0123456789012345678901234567890
         RasterMetadataBase.print_info(self)
 
@@ -445,18 +446,18 @@ class Raster3DMetadata(RasterMetadataBase):
 
     def print_info(self):
         """Print information about this class in human readable style"""
-        print " +-------------------- Metadata information ----------------------------------+"
+        print(" +-------------------- Metadata information ----------------------------------+")
         #      0123456789012345678901234567890
         RasterMetadataBase.print_info(self)
         #      0123456789012345678901234567890
-        print " | Number of depths:........... " + str(self.get_depths())
-        print " | Top-Bottom resolution:...... " + str(self.get_tbres())
+        print(" | Number of depths:........... " + str(self.get_depths()))
+        print(" | Top-Bottom resolution:...... " + str(self.get_tbres()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         RasterMetadataBase.print_shell_info(self)
-        print "depths=" + str(self.get_depths())
-        print "tbres=" + str(self.get_tbres())
+        print("depths=" + str(self.get_depths()))
+        print("tbres=" + str(self.get_tbres()))
 
 ###############################################################################
 
@@ -763,36 +764,36 @@ class VectorMetadata(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " +-------------------- Metadata information ----------------------------------+"
-        print " | Is map 3d .................. " + str(self.get_3d_info())
-        print " | Number of points ........... " + str(self.get_number_of_points())
-        print " | Number of lines ............ " + str(self.get_number_of_lines())
-        print " | Number of boundaries ....... " + str(self.get_number_of_boundaries())
-        print " | Number of centroids ........ " + str(self.get_number_of_centroids())
-        print " | Number of faces ............ " + str(self.get_number_of_faces())
-        print " | Number of kernels .......... " + str(self.get_number_of_kernels())
-        print " | Number of primitives ....... " + str(self.get_number_of_primitives())
-        print " | Number of nodes ............ " + str(self.get_number_of_nodes())
-        print " | Number of areas ............ " + str(self.get_number_of_areas())
-        print " | Number of islands .......... " + str(self.get_number_of_islands())
-        print " | Number of holes ............ " + str(self.get_number_of_holes())
-        print " | Number of volumes .......... " + str(self.get_number_of_volumes())
+        print(" +-------------------- Metadata information ----------------------------------+")
+        print(" | Is map 3d .................. " + str(self.get_3d_info()))
+        print(" | Number of points ........... " + str(self.get_number_of_points()))
+        print(" | Number of lines ............ " + str(self.get_number_of_lines()))
+        print(" | Number of boundaries ....... " + str(self.get_number_of_boundaries()))
+        print(" | Number of centroids ........ " + str(self.get_number_of_centroids()))
+        print(" | Number of faces ............ " + str(self.get_number_of_faces()))
+        print(" | Number of kernels .......... " + str(self.get_number_of_kernels()))
+        print(" | Number of primitives ....... " + str(self.get_number_of_primitives()))
+        print(" | Number of nodes ............ " + str(self.get_number_of_nodes()))
+        print(" | Number of areas ............ " + str(self.get_number_of_areas()))
+        print(" | Number of islands .......... " + str(self.get_number_of_islands()))
+        print(" | Number of holes ............ " + str(self.get_number_of_holes()))
+        print(" | Number of volumes .......... " + str(self.get_number_of_volumes()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "is_3d=" + str(self.get_3d_info())
-        print "points=" + str(self.get_number_of_points())
-        print "lines=" + str(self.get_number_of_lines())
-        print "boundaries=" + str(self.get_number_of_boundaries())
-        print "centroids=" + str(self.get_number_of_centroids())
-        print "faces=" + str(self.get_number_of_faces())
-        print "kernels=" + str(self.get_number_of_kernels())
-        print "primitives=" + str(self.get_number_of_primitives())
-        print "nodes=" + str(self.get_number_of_nodes())
-        print "areas=" + str(self.get_number_of_areas())
-        print "islands=" + str(self.get_number_of_islands())
-        print "holes=" + str(self.get_number_of_holes())
-        print "volumes=" + str(self.get_number_of_volumes())
+        print("is_3d=" + str(self.get_3d_info()))
+        print("points=" + str(self.get_number_of_points()))
+        print("lines=" + str(self.get_number_of_lines()))
+        print("boundaries=" + str(self.get_number_of_boundaries()))
+        print("centroids=" + str(self.get_number_of_centroids()))
+        print("faces=" + str(self.get_number_of_faces()))
+        print("kernels=" + str(self.get_number_of_kernels()))
+        print("primitives=" + str(self.get_number_of_primitives()))
+        print("nodes=" + str(self.get_number_of_nodes()))
+        print("areas=" + str(self.get_number_of_areas()))
+        print("islands=" + str(self.get_number_of_islands()))
+        print("holes=" + str(self.get_number_of_holes()))
+        print("volumes=" + str(self.get_number_of_volumes()))
 
 ###############################################################################
 
@@ -908,29 +909,29 @@ class STDSMetadataBase(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " | Number of registered maps:.. " + str(
-            self.get_number_of_maps())
-        print " |"
-        print " | Title:"
-        print " | " + str(self.get_title())
-        print " | Description:"
-        print " | " + str(self.get_description())
-        print " | Command history:"
+        print(" | Number of registered maps:.. " + str(
+            self.get_number_of_maps()))
+        print(" |")
+        print(" | Title:")
+        print(" | " + str(self.get_title()))
+        print(" | Description:")
+        print(" | " + str(self.get_description()))
+        print(" | Command history:")
         command = self.get_command()
         if command:
             for token in command.split("\n"):
-                print " | " + str(token)
+                print(" | " + str(token))
 
     def print_history(self):
         """Print history information about this class in human readable
             shell style
         """
         #      0123456789012345678901234567890
-        print "# Title:"
-        print "# " + str(self.get_title())
-        print "# Description:"
-        print "# " + str(self.get_description())
-        print "# Command history:"
+        print("# Title:")
+        print("# " + str(self.get_title()))
+        print("# Description:")
+        print("# " + str(self.get_description()))
+        print("# Command history:")
         command = self.get_command()
 
         if command:
@@ -946,15 +947,15 @@ class STDSMetadataBase(SQLDatabaseInterface):
                 count += 1
                 if len(token) > 1:
                     if token[0] == "#":
-                        print token
+                        print(token)
                     elif count < len(print_list):
-                        print token + " \\"
+                        print(token + " \\")
                     else:
-                        print token
+                        print(token)
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "number_of_maps=" + str(self.get_number_of_maps())
+        print("number_of_maps=" + str(self.get_number_of_maps()))
 
 ###############################################################################
 
@@ -1142,29 +1143,29 @@ class STDSRasterMetadataBase(STDSMetadataBase):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " | North-South resolution min:. " + str(self.get_nsres_min())
-        print " | North-South resolution max:. " + str(self.get_nsres_max())
-        print " | East-west resolution min:... " + str(self.get_ewres_min())
-        print " | East-west resolution max:... " + str(self.get_ewres_max())
-        print " | Minimum value min:.......... " + str(self.get_min_min())
-        print " | Minimum value max:.......... " + str(self.get_min_max())
-        print " | Maximum value min:.......... " + str(self.get_max_min())
-        print " | Maximum value max:.......... " + str(self.get_max_max())
-        print " | Aggregation type:........... " + str(self.get_aggregation_type())
+        print(" | North-South resolution min:. " + str(self.get_nsres_min()))
+        print(" | North-South resolution max:. " + str(self.get_nsres_max()))
+        print(" | East-west resolution min:... " + str(self.get_ewres_min()))
+        print(" | East-west resolution max:... " + str(self.get_ewres_max()))
+        print(" | Minimum value min:.......... " + str(self.get_min_min()))
+        print(" | Minimum value max:.......... " + str(self.get_min_max()))
+        print(" | Maximum value min:.......... " + str(self.get_max_min()))
+        print(" | Maximum value max:.......... " + str(self.get_max_max()))
+        print(" | Aggregation type:........... " + str(self.get_aggregation_type()))
         STDSMetadataBase.print_info(self)
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "aggregation_type=" + str(self.get_aggregation_type())
+        print("aggregation_type=" + str(self.get_aggregation_type()))
         STDSMetadataBase.print_shell_info(self)
-        print "nsres_min=" + str(self.get_nsres_min())
-        print "nsres_max=" + str(self.get_nsres_max())
-        print "ewres_min=" + str(self.get_ewres_min())
-        print "ewres_max=" + str(self.get_ewres_max())
-        print "min_min=" + str(self.get_min_min())
-        print "min_max=" + str(self.get_min_max())
-        print "max_min=" + str(self.get_max_min())
-        print "max_max=" + str(self.get_max_max())
+        print("nsres_min=" + str(self.get_nsres_min()))
+        print("nsres_max=" + str(self.get_nsres_max()))
+        print("ewres_min=" + str(self.get_ewres_min()))
+        print("ewres_max=" + str(self.get_ewres_max()))
+        print("min_min=" + str(self.get_min_min()))
+        print("min_max=" + str(self.get_min_max()))
+        print("max_min=" + str(self.get_max_min()))
+        print("max_max=" + str(self.get_max_max()))
 
 
 ###############################################################################
@@ -1261,16 +1262,16 @@ class STRDSMetadata(STDSRasterMetadataBase):
 
     def print_info(self):
         """Print information about this class in human readable style"""
-        print " +-------------------- Metadata information ----------------------------------+"
+        print(" +-------------------- Metadata information ----------------------------------+")
         #      0123456789012345678901234567890
-        print " | Raster register table:...... " + str(
-            self.get_raster_register())
+        print(" | Raster register table:...... " + str(
+            self.get_raster_register()))
         STDSRasterMetadataBase.print_info(self)
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         STDSRasterMetadataBase.print_shell_info(self)
-        print "raster_register=" + str(self.get_raster_register())
+        print("raster_register=" + str(self.get_raster_register()))
 
 ###############################################################################
 
@@ -1397,21 +1398,21 @@ class STR3DSMetadata(STDSRasterMetadataBase):
 
     def print_info(self):
         """Print information about this class in human readable style"""
-        print " +-------------------- Metadata information ----------------------------------+"
+        print(" +-------------------- Metadata information ----------------------------------+")
         #      0123456789012345678901234567890
         #      0123456789012345678901234567890
-        print " | 3D raster register table:... " + str(
-            self.get_raster3d_register())
-        print " | Top-bottom resolution min:.. " + str(self.get_ewres_min())
-        print " | Top-bottom resolution max:.. " + str(self.get_ewres_max())
+        print(" | 3D raster register table:... " + str(
+            self.get_raster3d_register()))
+        print(" | Top-bottom resolution min:.. " + str(self.get_ewres_min()))
+        print(" | Top-bottom resolution max:.. " + str(self.get_ewres_max()))
         STDSRasterMetadataBase.print_info(self)
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         STDSRasterMetadataBase.print_shell_info(self)
-        print "tbres_min=" + str(self.get_tbres_min())
-        print "tbres_max=" + str(self.get_tbres_max())
-        print "raster3d_register=" + str(self.get_raster3d_register())
+        print("tbres_min=" + str(self.get_tbres_min()))
+        print("tbres_max=" + str(self.get_tbres_max()))
+        print("raster3d_register=" + str(self.get_raster3d_register()))
 
 ###############################################################################
 
@@ -1662,40 +1663,40 @@ class STVDSMetadata(STDSMetadataBase):
 
     def print_info(self):
         """Print information about this class in human readable style"""
-        print " +-------------------- Metadata information ----------------------------------+"
+        print(" +-------------------- Metadata information ----------------------------------+")
         #      0123456789012345678901234567890
-        print " | Vector register table:...... " + str(
-            self.get_vector_register())
-        print " | Number of points ........... " + str(self.number_of_points)
-        print " | Number of lines ............ " + str(self.number_of_lines)
-        print " | Number of boundaries ....... " + str(self.number_of_boundaries)
-        print " | Number of centroids ........ " + str(self.number_of_centroids)
-        print " | Number of faces ............ " + str(self.number_of_faces)
-        print " | Number of kernels .......... " + str(self.number_of_kernels)
-        print " | Number of primitives ....... " + str(self.number_of_primitives)
-        print " | Number of nodes ............ " + str(self.number_of_nodes)
-        print " | Number of areas ............ " + str(self.number_of_areas)
-        print " | Number of islands .......... " + str(self.number_of_islands)
-        print " | Number of holes ............ " + str(self.number_of_holes)
-        print " | Number of volumes .......... " + str(self.number_of_volumes)
+        print(" | Vector register table:...... " + str(
+            self.get_vector_register()))
+        print(" | Number of points ........... " + str(self.number_of_points))
+        print(" | Number of lines ............ " + str(self.number_of_lines))
+        print(" | Number of boundaries ....... " + str(self.number_of_boundaries))
+        print(" | Number of centroids ........ " + str(self.number_of_centroids))
+        print(" | Number of faces ............ " + str(self.number_of_faces))
+        print(" | Number of kernels .......... " + str(self.number_of_kernels))
+        print(" | Number of primitives ....... " + str(self.number_of_primitives))
+        print(" | Number of nodes ............ " + str(self.number_of_nodes))
+        print(" | Number of areas ............ " + str(self.number_of_areas))
+        print(" | Number of islands .......... " + str(self.number_of_islands))
+        print(" | Number of holes ............ " + str(self.number_of_holes))
+        print(" | Number of volumes .......... " + str(self.number_of_volumes))
         STDSMetadataBase.print_info(self)
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         STDSMetadataBase.print_shell_info(self)
-        print "vector_register=" + str(self.get_vector_register())
-        print "points=" + str(self.get_number_of_points())
-        print "lines=" + str(self.get_number_of_lines())
-        print "boundaries=" + str(self.get_number_of_boundaries())
-        print "centroids=" + str(self.get_number_of_centroids())
-        print "faces=" + str(self.get_number_of_faces())
-        print "kernels=" + str(self.get_number_of_kernels())
-        print "primitives=" + str(self.get_number_of_primitives())
-        print "nodes=" + str(self.get_number_of_nodes())
-        print "areas=" + str(self.get_number_of_areas())
-        print "islands=" + str(self.get_number_of_islands())
-        print "holes=" + str(self.get_number_of_holes())
-        print "volumes=" + str(self.get_number_of_volumes())
+        print("vector_register=" + str(self.get_vector_register()))
+        print("points=" + str(self.get_number_of_points()))
+        print("lines=" + str(self.get_number_of_lines()))
+        print("boundaries=" + str(self.get_number_of_boundaries()))
+        print("centroids=" + str(self.get_number_of_centroids()))
+        print("faces=" + str(self.get_number_of_faces()))
+        print("kernels=" + str(self.get_number_of_kernels()))
+        print("primitives=" + str(self.get_number_of_primitives()))
+        print("nodes=" + str(self.get_number_of_nodes()))
+        print("areas=" + str(self.get_number_of_areas()))
+        print("islands=" + str(self.get_number_of_islands()))
+        print("holes=" + str(self.get_number_of_holes()))
+        print("volumes=" + str(self.get_number_of_volumes()))
 
 ###############################################################################
 

lib/python/temporal/open_stds.py

@@ -18,7 +18,7 @@ for details.
 :authors: Soeren Gebbert
 """
 
-from factory import *
+from .factory import *
 
 ###############################################################################
 
@@ -37,7 +37,7 @@ def open_old_stds(name, type, dbif=None):
        :param type: The type of the space time dataset (strd, str3ds, stvds,
                     raster, vector, raster3d)
        :param dbif: The optional database interface to be used
-       
+
        :return: New stds object
 
     """

lib/python/temporal/register.py

@@ -17,7 +17,7 @@ for details.
 :authors: Soeren Gebbert
 """
 
-from open_stds import *
+from .open_stds import *
 import grass.script as gscript
 
 ###############################################################################

lib/python/temporal/sampling.py

@@ -16,8 +16,8 @@ for details.
 
 :authors: Soeren Gebbert
 """
-
-from factory import *
+from __future__ import print_function
+from .factory import *
 
 
 def sample_stds_by_stds_topology(intype, sampletype, inputs, sampler, header,
@@ -122,7 +122,7 @@ def sample_stds_by_stds_topology(intype, sampletype, inputs, sampler, header,
             string += "%s%s" % ("end_time", separator)
             string += "%s%s" % ("interval_length", separator)
             string += "%s" % ("distance_from_begin")
-            print string
+            print(string)
 
         first_time, dummy = mapmatrizes[0][0]["granule"].get_temporal_extent_as_tuple()
 
@@ -163,7 +163,7 @@ def sample_stds_by_stds_topology(intype, sampletype, inputs, sampler, header,
             string += "%s%s" % (end, separator)
             string += "%s%s" % (delta, separator)
             string += "%s" % (delta_first)
-            print string
+            print(string)
 
     dbif.close()
     if len(mapmatrizes) > 0:

lib/python/temporal/space_time_datasets.py

@@ -9,8 +9,8 @@ for details.
 :authors: Soeren Gebbert
 """
 import getpass
-from abstract_map_dataset import *
-from abstract_space_time_dataset import *
+from .abstract_map_dataset import *
+from .abstract_space_time_dataset import *
 import grass.script.array as garray
 
 ###############################################################################

lib/python/temporal/spatial_extent.py

@@ -33,7 +33,8 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from base import *
+from __future__ import print_function
+from .base import *
 
 
 class SpatialExtent(SQLDatabaseInterface):
@@ -1782,22 +1783,22 @@ class SpatialExtent(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " +-------------------- Spatial extent ----------------------------------------+"
-        print " | North:...................... " + str(self.get_north())
-        print " | South:...................... " + str(self.get_south())
-        print " | East:.. .................... " + str(self.get_east())
-        print " | West:....................... " + str(self.get_west())
-        print " | Top:........................ " + str(self.get_top())
-        print " | Bottom:..................... " + str(self.get_bottom())
+        print(" +-------------------- Spatial extent ----------------------------------------+")
+        print(" | North:...................... " + str(self.get_north()))
+        print(" | South:...................... " + str(self.get_south()))
+        print(" | East:.. .................... " + str(self.get_east()))
+        print(" | West:....................... " + str(self.get_west()))
+        print(" | Top:........................ " + str(self.get_top()))
+        print(" | Bottom:..................... " + str(self.get_bottom()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "north=" + str(self.get_north())
-        print "south=" + str(self.get_south())
-        print "east=" + str(self.get_east())
-        print "west=" + str(self.get_west())
-        print "top=" + str(self.get_top())
-        print "bottom=" + str(self.get_bottom())
+        print("north=" + str(self.get_north()))
+        print("south=" + str(self.get_south()))
+        print("east=" + str(self.get_east()))
+        print("west=" + str(self.get_west()))
+        print("top=" + str(self.get_top()))
+        print("bottom=" + str(self.get_bottom()))
 
 
 ###############################################################################

lib/python/temporal/spatial_topology_dataset_connector.py

@@ -14,6 +14,7 @@ for details.
 
 :authors: Soeren Gebbert
 """
+from __future__ import print_function
 import copy
 
 
@@ -68,7 +69,7 @@ class SpatialTopologyDatasetConnector(object):
             meet=a@P
             >>> rlist = tmr.get_spatial_relations()
             >>> if "COVER" in rlist.keys():
-            ...    print rlist["COVER"][0].get_id()
+            ...    print(rlist["COVER"][0].get_id())
             a@P
 
     """
@@ -318,54 +319,54 @@ class SpatialTopologyDatasetConnector(object):
     def print_spatial_topology_info(self):
         """Print information about this class in human readable style"""
 
-        print " +-------------------- Spatial Topology --------------------------------------+"
+        print(" +-------------------- Spatial Topology --------------------------------------+")
         #          0123456789012345678901234567890
         if self.equivalent is not None:
-            print " | Equivalent: ................ " + \
-                self._generate_map_list_string(self.equivalent)
+            print(" | Equivalent: ................ " +
+                  self._generate_map_list_string(self.equivalent))
         if self.cover is not None:
-            print " | Cover: ..................... " + \
-                self._generate_map_list_string(self.cover)
+            print(" | Cover: ..................... " +
+                  self._generate_map_list_string(self.cover))
         if self.covered is not None:
-            print " | Covered: ................... " + \
-                self._generate_map_list_string(self.covered)
+            print(" | Covered: ................... " +
+                  self._generate_map_list_string(self.covered))
         if self.overlap is not None:
-            print " | Overlap: ................... " + \
-                self._generate_map_list_string(self.overlap)
+            print(" | Overlap: ................... " +
+                  self._generate_map_list_string(self.overlap))
         if self.in_ is not None:
-            print " | In: ........................ " + \
-                self._generate_map_list_string(self.in_)
+            print(" | In: ........................ " +
+                  self._generate_map_list_string(self.in_))
         if self.contain is not None:
-            print " | Contain: ................... " + \
-                self._generate_map_list_string(self.contain)
+            print(" | Contain: ................... " +
+                  self._generate_map_list_string(self.contain))
         if self.meet is not None:
-            print " | Meet: ...................... " + \
-                self._generate_map_list_string(self.meet)
+            print(" | Meet: ...................... " +
+                  self._generate_map_list_string(self.meet))
 
     def print_spatial_topology_shell_info(self):
         """Print information about this class in shell style"""
 
         if self.equivalent is not None:
-            print "equivalent=" + self._generate_map_list_string(self.equivalent,
-                                                                 False)
+            print("equivalent=" + self._generate_map_list_string(self.equivalent,
+                                                                 False))
         if self.cover is not None:
-            print "cover=" + self._generate_map_list_string(
-                self.cover, False)
+            print("cover=" + self._generate_map_list_string(
+                  self.cover, False))
         if self.covered is not None:
-            print "covered=" + \
-                self._generate_map_list_string(self.covered, False)
+            print("covered=" +
+                  self._generate_map_list_string(self.covered, False))
         if self.overlap is not None:
-            print "overlap=" + \
-                self._generate_map_list_string(self.overlap)
+            print("overlap=" +
+                  self._generate_map_list_string(self.overlap))
         if self.in_ is not None:
-            print "in=" + \
-                self._generate_map_list_string(self.in_)
+            print("in=" +
+                  self._generate_map_list_string(self.in_))
         if self.contain is not None:
-            print "contain=" + \
-                self._generate_map_list_string(self.contain)
+            print("contain=" +
+                  self._generate_map_list_string(self.contain))
         if self.meet is not None:
-            print "meet=" + \
-                self._generate_map_list_string(self.meet)
+            print("meet=" +
+                  self._generate_map_list_string(self.meet))
 
 ###############################################################################
 

lib/python/temporal/spatio_temporal_relationships.py

@@ -17,8 +17,8 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from abstract_dataset import *
-from datetime_math import *
+from .abstract_dataset import *
+from .datetime_math import *
 import grass.lib.vector as vector
 import grass.lib.rtree as rtree
 import grass.lib.gis as gis
@@ -431,7 +431,7 @@ class SpatioTemporalTopologyBuilder(object):
         sorted_maps = sorted(
             maps, key=AbstractDatasetComparisonKeyStartTime)
 
-        for i in xrange(len(sorted_maps) - 1):
+        for i in range(len(sorted_maps) - 1):
             sorted_maps[i].set_next(sorted_maps[i + 1])
 
         for map_ in sorted_maps:
@@ -491,7 +491,7 @@ class SpatioTemporalTopologyBuilder(object):
 
         tree = rtree.RTreeCreateTree(-1, 0, dim)
 
-        for i in xrange(len(maps)):
+        for i in range(len(maps)):
 
             rect = self._map_to_rect(tree, maps[i], spatial)
             rtree.RTreeInsertRect(rect, i + 1, tree)
@@ -542,13 +542,13 @@ class SpatioTemporalTopologyBuilder(object):
 
         list_ = gis.G_new_ilist()
 
-        for j in xrange(len(mapsB)):
+        for j in range(len(mapsB)):
 
             rect = self._map_to_rect(tree, mapsB[j], spatial)
             vector.RTreeSearch2(tree, rect, list_)
             rtree.RTreeFreeRect(rect)
 
-            for k in xrange(list_.contents.n_values):
+            for k in range(list_.contents.n_values):
                 i = list_.contents.value[k] - 1
 
                 # Get the temporal relationship

lib/python/temporal/stds_export.py

@@ -30,9 +30,9 @@ import os
 import tarfile
 import tempfile
 
-from space_time_datasets import *
-from factory import *
-from open_stds import *
+from .space_time_datasets import *
+from .factory import *
+from .open_stds import *
 import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
@@ -52,7 +52,7 @@ exported_maps = {}
 ############################################################################
 
 
-def _export_raster_maps_as_gdal(rows, tar, list_file, new_cwd, fs, format_, 
+def _export_raster_maps_as_gdal(rows, tar, list_file, new_cwd, fs, format_,
                                 type_):
     for row in rows:
         name = row["name"]

lib/python/temporal/stds_import.py

@@ -33,10 +33,10 @@ import os
 import os.path
 import tarfile
 
-from space_time_datasets import *
-from register import *
-import factory
-from factory import *
+from .space_time_datasets import *
+from .register import *
+from . import factory
+from .factory import *
 import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
@@ -244,7 +244,7 @@ def import_stds(input, output, directory, title=None, descr=None, location=None,
         temp_file = open(temp_name, "w")
         proj_name = os.path.abspath(proj_file_name)
 
-        # We need to convert projection strings generated 
+        # We need to convert projection strings generated
         # from other programms than g.proj into
         # new line format so that the grass file comparison function
         # can be used to compare the projections

lib/python/temporal/temporal_algebra.py

@@ -367,7 +367,7 @@ for details.
     None || None
     A* =  if condition None  then  A  else  B
     C = A*
-    
+
     >>> p = tgis.TemporalAlgebraLexer()
     >>> p.build()
     >>> p.debug = True
@@ -390,7 +390,7 @@ for details.
     LexToken(LPAREN,'(',1,32)
     LexToken(NAME,'C',1,33)
     LexToken(RPAREN,')',1,34)
-    
+
     >>> p = tgis.TemporalAlgebraLexer()
     >>> p.build()
     >>> p.debug = True
@@ -412,7 +412,7 @@ for details.
     LexToken(COMMA,',',1,33)
     LexToken(NAME,'A',1,35)
     LexToken(RPAREN,')',1,36)
-    
+
     >>> p = tgis.TemporalAlgebraLexer()
     >>> p.build()
     >>> p.debug = True
@@ -438,6 +438,7 @@ for details.
     LexToken(RPAREN,')',1,48)
 
 """
+from __future__ import print_function
 
 try:
     import ply.lex as lex
@@ -448,17 +449,17 @@ except:
 import os
 import copy
 import grass.pygrass.modules as pymod
-from space_time_datasets import *
-from factory import *
-from open_stds import *
-from temporal_operator import *
+from .space_time_datasets import *
+from .factory import *
+from .open_stds import *
+from .temporal_operator import *
 
 ##############################################################################
 
 class TemporalAlgebraLexer(object):
     """Lexical analyzer for the GRASS GIS temporal algebra"""
 
-    # Functions that defines an if condition, temporal buffering, snapping and 
+    # Functions that defines an if condition, temporal buffering, snapping and
     # selection of maps with temporal extent.
     conditional_functions = {
         'if'    : 'IF',
@@ -471,7 +472,7 @@ class TemporalAlgebraLexer(object):
         'str3ds' : 'STR3DS',
         'stvds' : 'STVDS',
     }
-    
+
     # Variables with date and time strings
     datetime_functions = {
         'start_time'     : 'START_TIME',     # start time as HH::MM:SS
@@ -565,7 +566,7 @@ class TemporalAlgebraLexer(object):
     t_T_REL_OPERATOR     = r'\{([a-zA-Z\| ])+\}'
     t_T_SELECT           = r':'
     t_T_NOT_SELECT       = r'!:'
-    t_LPAREN             = r'\('    
+    t_LPAREN             = r'\('
     t_RPAREN             = r'\)'
     t_COMMA              = r','
     t_CEQUALS            = r'=='
@@ -664,7 +665,7 @@ class TemporalAlgebraLexer(object):
         while True:
              tok = self.lexer.token()
              if not tok: break
-             print tok
+             print(tok)
 
 ###############################################################################
 
@@ -736,7 +737,7 @@ class TemporalAlgebraParser(object):
         ('left', 'AND', 'OR', 'T_COMP_OPERATOR'), #2
         )
 
-    def __init__(self, pid=None, run = True, debug = False, spatial = False, 
+    def __init__(self, pid=None, run = True, debug = False, spatial = False,
                         null = False, register_null = False,  nprocs = 1):
         self.run = run
         self.debug = debug
@@ -761,45 +762,45 @@ class TemporalAlgebraParser(object):
     def __del__(self):
         if self.dbif.connected:
             self.dbif.close()
-            
+
     def setup_common_granularity(self,  expression,  stdstype = 'strds',  lexer = None):
         """Configure the temporal algebra to use the common granularity of all
              space time datasets in the expression to generate the map lists.
-             
+
              This function will analyze the expression to detect space time datasets
              and computes the common granularity from all granularities.
-          
+
              This granularity is then be used to generate the map lists. Hence, all
              maps from all STDS will have equidistant temporal extents. The only meaningful
              temporal relation is "equal".
-             
+
              :param expression: The algebra expression to analyze
-             
+
              :param lexer: The temporal algebra lexer (select, raster, voxel, vector) that should be used to
                                     parse the expression, default is TemporalAlgebraLexer
-             
+
              :return: True if successful, False otherwise
- 
+
         """
         l = lexer
         # Split the expression to ignore the left part
         expressions = expression.split("=")[1:]
         expression = " ".join(expressions)
-        
+
         # 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"))
             return False
-            
+
         # detect all STDS
         if l is None:
             l = TemporalAlgebraLexer()
         l.build()
         l.lexer.input(expression)
-        
+
         name_list = []
         tokens = []
-        
+
         count = 0
         while True:
             tok = l.lexer.token()
@@ -811,7 +812,7 @@ class TemporalAlgebraParser(object):
             if count > 1:
                 if tokens[count - 2] == "MAP" or tokens[count - 2] == "TMAP":
                     ignore = True
-            
+
             if tok.type == "NAME" and ignore == False:
                 name_list.append(tok.value)
             count += 1
@@ -831,23 +832,23 @@ class TemporalAlgebraParser(object):
             grans.append(stds.get_granularity())
             start_times.append(stds.get_temporal_extent_as_tuple()[0])
             ttypes[stds.get_temporal_type()] = stds.get_temporal_type()
-        
+
         # Only one temporal type is allowed
         if len(ttypes) > 1:
             self.msgr.error(_("All input space time datasets must have the same temporal type."))
             return False
-            
+
         # Compute the common granularity
         if "absolute" in ttypes.keys():
             self.granularity = compute_common_absolute_time_granularity(grans, start_times)
         else:
             self.granularity = compute_common_relative_time_granularity(grans)
-            
+
         self.use_granularity = True
-        
+
         return True
 
-    def parse(self, expression, stdstype = 'strds', maptype = 'rast',  mapclass = RasterDataset, 
+    def parse(self, expression, stdstype = 'strds', maptype = 'rast',  mapclass = RasterDataset,
                       basename = None, overwrite=False):
         self.lexer = TemporalAlgebraLexer()
         self.lexer.build()
@@ -877,7 +878,7 @@ 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
 
@@ -967,7 +968,7 @@ class TemporalAlgebraParser(object):
                 if temp_ext != None:
                     mapA.set_temporal_extent(temp_ext)
                 else:
-                    returncode = 0                   
+                    returncode = 0
             elif temp_op == 'd':
                 temp_ext = mapA.temporal_disjoint_union(mapB)
                 if temp_ext != None:
@@ -983,25 +984,25 @@ class TemporalAlgebraParser(object):
         return(returncode)
 
     def set_temporal_extent_list(self, maplist, topolist = ["EQUAL"], temporal = 'l' ):
-        """ Change temporal extent of map list based on temporal relations to 
+        """ Change temporal extent of map list based on temporal relations to
                 other map list and given temporal operator.
 
-            :param maplist: List of map objects for which relations has been build 
+            :param maplist: List of map objects for which relations has been build
                                         correctely.
             :param topolist: List of strings of temporal relations.
             :param temporal: The temporal operator specifying the temporal
-                                            extent operation (intersection, union, disjoint 
+                                            extent operation (intersection, union, disjoint
                                             union, right reference, left reference).
 
             :return: Map list with specified temporal extent.
         """
         resultdict = {}
-        
+
         for map_i in maplist:
             # Loop over temporal related maps and create overlay modules.
             tbrelations = map_i.get_temporal_relations()
             # Generate an intermediate map for the result map list.
-            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and', 
+            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and',
                                                                         copy = True,  rename = True)
             # Combine temporal and spatial extents of intermediate map with related maps.
             for topo in topolist:
@@ -1009,7 +1010,7 @@ class TemporalAlgebraParser(object):
                     for map_j in (tbrelations[topo]):
                         if temporal == 'r':
                             # Generate an intermediate map for the result map list.
-                            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and', 
+                            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and',
                                                                                         copy = True,  rename = True)
                         # Create overlayed map extent.
                         returncode = self.overlay_map_extent(map_new, map_j, 'and', \
@@ -1024,10 +1025,10 @@ class TemporalAlgebraParser(object):
                             # print(map_new.cmd_list)
                             # resultlist.append(map_new)
                             resultdict[map_new.get_id()] = map_new
-        
+
                         # Create r.mapcalc expression string for the operation.
-                        #cmdstring = self.build_command_string(s_expr_a = map_new,  
-                        #                                                                s_expr_b = map_j,  
+                        #cmdstring = self.build_command_string(s_expr_a = map_new,
+                        #                                                                s_expr_b = map_j,
                         #                                                                operator = function)
                         # Conditional append of module command.
                         #map_new.cmd_list = cmdstring
@@ -1039,24 +1040,24 @@ class TemporalAlgebraParser(object):
         # Get sorted map objects as values from result dictionoary.
         resultlist = resultdict.values()
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
-        
+
         return(resultlist)
-    
+
     ######################### Temporal functions ##############################
 
     def remove_maps(self):
         """Removes empty or intermediate maps of different type.
         """
-        
+
         map_names = {}
         map_names["raster"] = []
         map_names["raster3d"] = []
         map_names["vector"] = []
-                
+
         if self.removable_maps:
             for map in self.removable_maps.values():
                     map_names[map.get_type()].append(map.get_name())
-        
+
         for key in map_names.keys():
             if map_names[key]:
                 self.msgr.message(_("Removing un-needed or empty %s maps"%(key)))
@@ -1064,7 +1065,7 @@ class TemporalAlgebraParser(object):
 
     def _remove_maps(self,  namelist,  map_type):
         """Remove maps of specific type
-        
+
             :param namelist: List of map names to be removed
             :param map_type: The type of the maps  (raster, raster_3d or vector)
         """
@@ -1072,13 +1073,13 @@ class TemporalAlgebraParser(object):
         chunklist = [namelist[i:i + max] for i in range(0, len(namelist), max)]
         for chunk in chunklist:
             stringlist = ",".join(chunk)
-            
+
             if self.run:
                 m = copy.deepcopy(self.m_mremove)
                 m.inputs["type"].value = map_type
                 m.inputs["name"].value = stringlist
                 m.flags["f"].value = True
-                print m.get_bash()
+                print(m.get_bash())
                 m.run()
 
     def check_stds(self, input, clear = False,  stds_type = None,  check_type=True):
@@ -1087,7 +1088,7 @@ class TemporalAlgebraParser(object):
             :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 
+            :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.
@@ -1143,7 +1144,7 @@ class TemporalAlgebraParser(object):
         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):
             maplist = input
             # Create map_value as empty list item.
@@ -1158,19 +1159,19 @@ class TemporalAlgebraParser(object):
                     map_i.condition_value = []
         else:
             self.msgr.fatal(_("Wrong type of input " + str(input)))
-            
+
         # We generate a unique map id that will be used
-        # in the topology analysis, since the maplist can 
-        # contain maps with equal map ids 
+        # in the topology analysis, since the maplist can
+        # contain maps with equal map ids
         for map in maplist:
             map.uid = self.generate_map_name()
             if self.debug:
-                print map.get_name(), map.uid,  map.get_temporal_extent_as_tuple()
-        
+                print(map.get_name(), map.uid,  map.get_temporal_extent_as_tuple())
+
         return(maplist)
 
     def get_temporal_topo_list(self, maplistA, maplistB = None, topolist = ["EQUAL"],
-                               assign_val = False, count_map = False, compare_bool = False,  
+                               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.
@@ -1187,7 +1188,7 @@ class TemporalAlgebraParser(object):
                             related map list and compariosn operator.
           :param compop: Comparison operator, && or ||.
           :param aggregate: Aggregation operator for relation map list, & or |.
-          
+
           :return: List of maps from maplistA that fulfil the topological relationships
                   to maplistB specified in topolist.
 
@@ -1215,8 +1216,8 @@ class TemporalAlgebraParser(object):
               >>> for map in resultlist:
               ...     if map.get_equal():
               ...         relations = map.get_equal()
-              ...         print "Map %s has equal relation to map %s"%(map.get_name(),
-              ...               relations[0].get_name())
+              ...         print("Map %s has equal relation to map %s"%(map.get_name(),
+              ...               relations[0].get_name()))
               Map a0 has equal relation to map b0
               Map a1 has equal relation to map b1
               Map a2 has equal relation to map b2
@@ -1248,8 +1249,8 @@ class TemporalAlgebraParser(object):
               >>> for map in resultlist:
               ...     if map.get_starts():
               ...         relations = map.get_starts()
-              ...         print "Map %s has start relation to map %s"%(map.get_name(),
-              ...               relations[0].get_name())
+              ...         print("Map %s has start relation to map %s"%(map.get_name(),
+              ...               relations[0].get_name()))
               Map a0 has start relation to map b0
               Map a1 has start relation to map b1
               Map a2 has start relation to map b2
@@ -1263,8 +1264,8 @@ class TemporalAlgebraParser(object):
               >>> for map in resultlist:
               ...     if map.get_during():
               ...         relations = map.get_during()
-              ...         print "Map %s has during relation to map %s"%(map.get_name(),
-              ...               relations[0].get_name())
+              ...         print("Map %s has during relation to map %s"%(map.get_name(),
+              ...               relations[0].get_name()))
               Map a0 has during relation to map b0
               Map a1 has during relation to map b0
               Map a2 has during relation to map b1
@@ -1366,22 +1367,22 @@ class TemporalAlgebraParser(object):
                     # Use unique identifier, since map names may be equal
                     resultdict[map_i.uid] = map_i
         resultlist = resultdict.values()
-        
+
         # Sort list of maps chronological.
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
-        
+
         return(resultlist)
-    
+
     def assign_bool_value(self,  map_i, tbrelations, topolist = ["EQUAL"]):
-        """ Function to assign boolean map value based on the map_values from the 
+        """ Function to assign boolean map value based on the map_values from the
                 compared map list by topological relationships.
-                
+
           :param map_i: Map object with temporal extent.
           :param tbrelations: List of temporal relation to map_i.
           :param topolist: List of strings for given temporal relations.
-          
-          :return: Map object with conditional value that has been assigned by 
-                        relation maps that fulfil the topological relationships to 
+
+          :return: Map object with conditional value that has been assigned by
+                        relation maps that fulfil the topological relationships to
                         maplistB specified in topolist.
         """
         condition_value_list = []
@@ -1400,19 +1401,19 @@ class TemporalAlgebraParser(object):
         else:
             resultbool = False
         map_i.condition_value = [resultbool]
-        
+
         return(resultbool)
 
     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. 
-            
+        """ Function to evaluate two map lists with boolean values by boolean
+            comparison operator.
+
           :param map_i: Map object with temporal extent.
           :param tbrelations: List of temporal relation to map_i.
           :param topolist: List of strings for given temporal relations.
           :param compop: Comparison operator, && or ||.
           :param aggregate: Aggregation operator for relation map list, & or |.
-          
+
           :return: Map object with conditional value that has been evaluated by
                         comparison operators.
         """
@@ -1444,20 +1445,20 @@ class TemporalAlgebraParser(object):
             print(resultbool)
         # Add boolean value to result list.
         map_i.condition_value = [resultbool]
-        
+
         return(resultbool)
-    
+
     def eval_toperator(self, operator, optype = 'relation'):
         """This function evaluates a string containing temporal operations.
 
          :param operator: String of temporal operations, e.g. {!=,equal|during,l}.
          :param optype: String to define operator type.
-         
+
          :return :List of temporal relations (equal, during), the given function
           (!:) and the interval/instances (l).
-          
+
         .. code-block:: python
-        
+
              >>> import grass.temporal as tgis
              >>> tgis.init()
              >>> p = tgis.TemporalOperatorParser()
@@ -1470,7 +1471,7 @@ class TemporalAlgebraParser(object):
         p = TemporalOperatorParser()
         p.parse(operator, optype)
         p.relations = [rel.upper() for rel in p.relations]
-        
+
         return(p.relations, p.temporal, p.function,  p.aggregate)
 
     def perform_temporal_selection(self, maplistA, maplistB, topolist = ["EQUAL"],
@@ -1515,8 +1516,8 @@ class TemporalAlgebraParser(object):
               >>> for map in resultlist:
               ...     if map.get_equal():
               ...         relations = map.get_equal()
-              ...         print "Map %s has equal relation to map %s"%(map.get_name(),
-              ...               relations[0].get_name())
+              ...         print("Map %s has equal relation to map %s"%(map.get_name(),
+              ...               relations[0].get_name()))
               Map a5 has equal relation to map b0
               Map a6 has equal relation to map b1
               Map a7 has equal relation to map b2
@@ -1526,7 +1527,7 @@ class TemporalAlgebraParser(object):
               ...                                           True)
               >>> for map in resultlist:
               ...     if not map.get_equal():
-              ...         print "Map %s has no equal relation to mapset mapsB"%(map.get_name())
+              ...         print("Map %s has no equal relation to mapset mapsB"%(map.get_name()))
               Map a0 has no equal relation to mapset mapsB
               Map a1 has no equal relation to mapset mapsB
               Map a2 has no equal relation to mapset mapsB
@@ -1662,7 +1663,7 @@ class TemporalAlgebraParser(object):
             if unchanged == True:
                 if self.debug:
                     print('Leave temporal extend of result map: ' +  map_i.get_map_id() + ' unchanged.')
-        
+
         resultlist = resultdict.values()
         # Sort list of maps chronological.
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
@@ -1682,7 +1683,7 @@ class TemporalAlgebraParser(object):
           :return: Dictionary with temporal functions for given input map.
 
           .. code-block:: python
-          
+
               >>> import grass.temporal as tgis
               >>> import datetime
               >>> tgis.init()
@@ -1853,14 +1854,14 @@ class TemporalAlgebraParser(object):
         """ 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.
-             In this prossess sub condition map lists will be created which will include 
-             information of the underlying single conditions. Important: The temporal 
-             relations between conditions are evaluated by implicit aggregation. 
-             In the second step the aggregated condition map list will be compared with the 
+             In this prossess sub condition map lists will be created which will include
+             information of the underlying single conditions. Important: The temporal
+             relations between conditions are evaluated by implicit aggregation.
+             In the second step the aggregated condition map list will be compared with the
              map list of conclusion statements by the given temporal relation.
-             
-             The result is writen as 'condition_value' attribute to the resulting map objects. 
-             These attribute consists of boolean expressions and operators which can be 
+
+             The result is writen as 'condition_value' attribute to the resulting map objects.
+             These attribute consists of boolean expressions and operators which can be
              evaluated with the eval_condition_list function.
              [True,  '||', False, '&&', True]
 
@@ -1873,17 +1874,17 @@ class TemporalAlgebraParser(object):
 
              :param thenlist: Map list object of the conclusion statement.
                          It will be compared and evaluated by the conditions.
-          
-             :param topolist: List of temporal relations between the conditions and the 
+
+             :param topolist: List of temporal relations between the conditions and the
                          conclusions.
-                          
+
              :return: Map list with conditional values for all temporal expressions.
 
         """
-        
-        # Evaluate the temporal variable expression and compute the temporal combination 
+
+        # Evaluate the temporal variable expression and compute the temporal combination
         # of conditions.
-        
+
         # Check if the input expression is a valid single global variable.
         if isinstance(tvarexpr, GlobalTemporalVar) and tvarexpr.get_type() == "global" :
             # Use method eval_global_var to evaluate expression.
@@ -1930,14 +1931,14 @@ class TemporalAlgebraParser(object):
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
 
         return(resultlist)
-        
+
     def eval_condition_list(self, maplist, inverse = False):
         """ This function evaluates conditional values of a map list.
              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
                   - [True,  '&&', False, '&&', True]  -> False
@@ -2021,12 +2022,12 @@ class TemporalAlgebraParser(object):
             if isinstance(t[3], list):
                 num = len(t[3])
                 count = 0
-                register_list = []      
+                register_list = []
                 if num > 0:
                     process_queue = pymod.ParallelModuleQueue(int(self.nprocs))
                     for map_i in t[3]:
-                        # Test if temporal extents have been changed by temporal 
-                        # relation operators (i|r). 
+                        # Test if temporal extents have been changed by temporal
+                        # relation operators (i|r).
                         if count == 0:
                             maps_stds_type = map_i.get_new_stds_instance(None).get_type()
                             map_type = map_i.get_type()
@@ -2082,14 +2083,14 @@ class TemporalAlgebraParser(object):
 
                     # Wait for running processes
                     process_queue.wait()
-                    
+
                     # Open connection to temporal database.
-                    # Create result space time dataset based on the map stds type        
+                    # Create result space time dataset based on the map stds type
                     resultstds = open_new_stds(t[1],maps_stds_type, \
                                                              'absolute', t[1], t[1], \
                                                              'mean', self.dbif, \
-                                                             overwrite = self.overwrite)                            
-                    for map_i in register_list:                
+                                                             overwrite = self.overwrite)
+                    for map_i in register_list:
                         # Get meta data from grass database.
                         map_i.load()
                         # Check if temporal extents have changed and a new map was created
@@ -2119,7 +2120,7 @@ class TemporalAlgebraParser(object):
                     self.msgr.warning("Empty result space time dataset. "\
                                                   "No map has been registered in %s"  %(t[1] ))
                     # Open connection to temporal database.
-                    # Create result space time dataset.                        
+                    # Create result space time dataset.
                     resultstds = open_new_stds(t[1], self.stdstype, \
                                                              'absolute', t[1], t[1], \
                                                              'mean', dbif, \
@@ -2131,7 +2132,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[3]
 
         if self.debug:
-            print t[1], "=", t[3]
+            print(t[1], "=", t[3])
 
     def p_stds_1(self, t):
         # Definition of a space time dataset
@@ -2152,7 +2153,7 @@ class TemporalAlgebraParser(object):
 
     def p_expr_strds_function(self, t):
         # Explicitly specify a space time raster dataset
-        # R = A : strds(B) 
+        # R = A : strds(B)
         """
         expr : STRDS LPAREN stds RPAREN
         """
@@ -2161,11 +2162,11 @@ class TemporalAlgebraParser(object):
         else:
             t[0] = t[3]
             if self.debug:
-                print "Opening STRDS: ",  t[0]
+                print("Opening STRDS: ",  t[0])
 
     def p_expr_str3ds_function(self, t):
         # Explicitly specify a space time raster dataset
-        # R = A : str3ds(B) 
+        # R = A : str3ds(B)
         """
         expr : STR3DS LPAREN stds RPAREN
         """
@@ -2174,28 +2175,28 @@ class TemporalAlgebraParser(object):
         else:
             t[0] = t[3]
             if self.debug:
-                print "Opening STR3DS: ",  t[0]
+                print("Opening STR3DS: ",  t[0])
 
     def p_expr_stvds_function(self, t):
         # Explicitly specify a space time vector dataset
-        # R = A : stvds(B) 
+        # R = A : stvds(B)
         """
         expr : STVDS LPAREN stds RPAREN
         """
         if self.run:
-            print t[3]
+            print(t[3])
             t[0] = self.check_stds(t[3], stds_type = "stvds",  check_type=False)
         else:
             t[0] = t[3]
             if self.debug:
-                print "Opening STVDS: ",  t[0]
+                print("Opening STVDS: ",  t[0])
 
     def p_expr_tmap_function(self, t):
         # Add a single map.
-        # Only the spatial extent of the map is evaluated. 
+        # Only the spatial extent of the map is evaluated.
         # Temporal extent is not existing.
         # Examples:
-        #    R = tmap(A) 
+        #    R = tmap(A)
         """
         expr : TMAP LPAREN stds RPAREN
         """
@@ -2227,7 +2228,7 @@ class TemporalAlgebraParser(object):
             t[0] = "tmap(",  t[3] , ")"
 
         if self.debug:
-            print "tmap(", t[3] , ")"
+            print("tmap(", t[3] , ")")
 
     def p_expr_tmerge_function(self, t):
         # Merge two maplists of same STDS type into a result map list.
@@ -2244,7 +2245,7 @@ class TemporalAlgebraParser(object):
             # Check input map.
             maplistA   = self.check_stds(t[3])
             maplistB   = self.check_stds(t[5])
-            
+
             # Check empty lists.
             if len(maplistA) == 0 and len(maplistB) == 0:
                 self.msgr.warning(_("Merging empty map lists"))
@@ -2264,14 +2265,14 @@ class TemporalAlgebraParser(object):
                     grass.fatal(_("Space time datasets to merge must have the same temporal type"))
 
                 resultlist = maplistA + maplistB
-            
+
             # Return map list.
             t[0] = resultlist
         else:
             t[0] = "merge(",  t[3], ",", t[5], ")"
 
         if self.debug:
-            print "merge(", t[3], ",", t[5], ")"
+            print("merge(", t[3], ",", t[5], ")")
 
     def p_t_hash(self,t):
         """
@@ -2332,7 +2333,7 @@ class TemporalAlgebraParser(object):
             t[0] = "td(" + str(t[3]) + ")"
 
         if self.debug:
-            print "td(" + str(t[3]) + ")"
+            print("td(" + str(t[3]) + ")")
 
 
     def p_t_time_var(self, t):
@@ -2396,11 +2397,11 @@ class TemporalAlgebraParser(object):
                         map_i.condition_value = boolname
                 except:
                     self.msgr.fatal("Error: the given expression does not contain a correct time difference object.")
-            
+
             t[0] = maplist
-            
+
         if self.debug:
-            print t[1], t[2], t[3]
+            print(t[1], t[2], t[3])
 
     def p_t_var_expr_number(self, t):
         # Examples:
@@ -2409,7 +2410,7 @@ class TemporalAlgebraParser(object):
         #    start_day(B) < start_month(A)
         """
         t_var_expr : t_var LPAREN stds RPAREN comp_op number
-                | t_var LPAREN expr RPAREN comp_op number      
+                | t_var LPAREN expr RPAREN comp_op number
         """
         # TODO:  Implement comparison operator for map lists.
         #| t_var LPAREN stds RPAREN comp_op t_var LPAREN stds RPAREN
@@ -2429,7 +2430,7 @@ class TemporalAlgebraParser(object):
             t[0] = resultlist
 
         if self.debug:
-                print t[1], t[3], t[5], t[6]
+                print(t[1], t[3], t[5], t[6])
 
     def p_t_var_expr_time(self, t):
         # Examples:
@@ -2462,12 +2463,12 @@ class TemporalAlgebraParser(object):
             gvar.value  = t[6]
             # Evaluate temporal variable for given maplist.
             resultlist = self.eval_global_var(gvar, maplist)
-            
+
             t[0] = resultlist
 
 
         if self.debug:
-            print t[1], t[3],  t[5], t[6]
+            print(t[1], t[3],  t[5], t[6])
 
     def p_t_var_expr_comp(self, t):
         """
@@ -2481,18 +2482,18 @@ class TemporalAlgebraParser(object):
             relations = ["EQUAL"]
             temporal = "l"
             function = t[2] + t[3]
-            aggregate = t[2] 
-            # Build conditional values based on topological relationships.            
+            aggregate = t[2]
+            # Build conditional values based on topological relationships.
             complist = self.get_temporal_topo_list(tvarexprA, tvarexprB, topolist = relations,
                                compare_bool = True, compop = function[0], aggregate = aggregate)
             # Set temporal extent based on topological relationships.
-            resultlist = self.set_temporal_extent_list(complist, topolist = relations, 
+            resultlist = self.set_temporal_extent_list(complist, topolist = relations,
                                 temporal = temporal)
-            
+
             t[0] = resultlist
 
         if self.debug:
-            print t[1], t[2] + t[3], t[4]
+            print(t[1], t[2] + t[3], t[4])
 
     def p_t_var_expr_comp_op(self, t):
         """
@@ -2507,13 +2508,13 @@ class TemporalAlgebraParser(object):
             complist = self.get_temporal_topo_list(tvarexprA, tvarexprB, topolist = relations,
                                compare_bool = True, compop = function[0], aggregate = aggregate)
             # Set temporal extent based on topological relationships.
-            resultlist = self.set_temporal_extent_list(complist, topolist = relations, 
+            resultlist = self.set_temporal_extent_list(complist, topolist = relations,
                                 temporal = temporal)
 
             t[0] = resultlist
 
         if self.debug:
-            print t[1], t[2], t[3]
+            print(t[1], t[2], t[3])
 
     def p_expr_t_select(self, t):
         # Temporal equal selection
@@ -2540,7 +2541,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[1] , "*"
 
         if self.debug:
-            print str(t[1]),  "* = ", t[1], t[2], t[3]
+            print(str(t[1]),  "* = ", t[1], t[2], t[3])
 
     def p_expr_t_not_select(self, t):
         # Temporal equal selection
@@ -2566,7 +2567,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[1] + "*"
 
         if self.debug:
-            print t[1] + "* = ", t[1], t[2], t[3]
+            print(t[1] + "* = ", t[1], t[2], t[3])
 
 
     def p_expr_t_select_operator(self, t):
@@ -2599,7 +2600,7 @@ class TemporalAlgebraParser(object):
             # Perform selection.
             selectlist = self.perform_temporal_selection(maplistA, maplistB,
                          topolist = operators[0], inverse = negation)
-            selectlist = self.set_granularity(selectlist, maplistB, operators[1], 
+            selectlist = self.set_granularity(selectlist, maplistB, operators[1],
                 operators[0])
             # Return map list.
             t[0] = selectlist
@@ -2607,7 +2608,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[1] + "*"
 
         if self.debug:
-            print t[1] + "* = ", t[1], t[2], t[3]
+            print(t[1] + "* = ", t[1], t[2], t[3])
 
 
     def p_expr_condition_if(self, t):
@@ -2622,7 +2623,7 @@ class TemporalAlgebraParser(object):
             thenlist     = self.check_stds(t[5])
             # Get temporal conditional statement.
             tvarexpr     = t[3]
-            thencond     = self.build_condition_list(tvarexpr, thenlist)      
+            thencond     = self.build_condition_list(tvarexpr, thenlist)
             thenresult   = self.eval_condition_list(thencond)
             # Clear the map and conditional values of the map list.
             resultlist   = self.check_stds(thenresult, clear = True)
@@ -2632,7 +2633,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[5] + "*"
 
         if self.debug:
-            print str(t[5]) + "* = ", "if condition", str(t[3]), ' then ', str(t[5])
+            print(str(t[5]) + "* = ", "if condition", str(t[3]), ' then ', str(t[5]))
 
     def p_expr_condition_if_relation(self, t):
         # Examples
@@ -2647,8 +2648,8 @@ class TemporalAlgebraParser(object):
             # Get temporal conditional statement.
             tvarexpr     = t[5]
             topolist     = self.eval_toperator(t[3],  optype = 'relation')[0]
-            thencond     = self.build_condition_list(tvarexpr, thenlist, topolist)            
-            thenresult   = self.eval_condition_list(thencond)          
+            thencond     = self.build_condition_list(tvarexpr, thenlist, topolist)
+            thenresult   = self.eval_condition_list(thencond)
             # Clear the map and conditional values of the map list.
             resultlist   = self.check_stds(thenresult, clear = True)
             # Return resulting map list.
@@ -2657,7 +2658,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[7] + "*"
 
         if self.debug:
-            print "result* = ", "if ", str(t[3]),  "condition", str(t[5]), " then ", str(t[7])
+            print("result* = ", "if ", str(t[3]),  "condition", str(t[5]), " then ", str(t[7]))
 
     def p_expr_condition_elif(self, t):
         # Examples
@@ -2690,7 +2691,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[5] + "*"
 
         if self.debug:
-            print str(t[5]) + "* = ", "if condition", str(t[3]), " then ", str(t[5]), ' else ', str(t[7])
+            print(str(t[5]) + "* = ", "if condition", str(t[3]), " then ", str(t[5]), ' else ', str(t[7]))
 
     def p_expr_condition_elif_relation(self, t):
         # Examples
@@ -2730,9 +2731,9 @@ class TemporalAlgebraParser(object):
 
         if self.debug:
             if t[5]:
-                print str(t[7]), "* = ", "if condition", str(t[5]), " then ", str(t[7]), ' else ', str(t[9])
+                print(str(t[7]), "* = ", "if condition", str(t[5]), " then ", str(t[7]), ' else ', str(t[9]))
             else:
-                print str(t[9]), "* = ", "if condition", str(t[5]), " then ", str(t[7]), ' else ', str(t[9])
+                print(str(t[9]), "* = ", "if condition", str(t[5]), " then ", str(t[7]), ' else ', str(t[9]))
 
     def p_expr_t_buff(self, t):
         # Examples
@@ -2761,9 +2762,9 @@ 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]), ")"
+                print(str(t[3]) + "* = buff_t(", str(t[3]), ",", str(t[5]), ")")
 
     def p_expr_t_snap(self, t):
         # Examples
@@ -2782,7 +2783,7 @@ class TemporalAlgebraParser(object):
             t[0] = t[3] + "*"
 
         if self.debug:
-            print str(t[3]) + "* = tsnap(", str(t[3]), ")"
+            print(str(t[3]) + "* = tsnap(", str(t[3]), ")")
 
     def p_expr_t_shift(self, t):
         # Examples
@@ -2810,9 +2811,9 @@ class TemporalAlgebraParser(object):
 
         if self.debug:
             if len(t) == 10:
-                print str(t[3]) + "* = tshift(", str(t[3]), "," , '"', str(t[6]), str(t[7]), '"', ")"
+                print(str(t[3]) + "* = tshift(", str(t[3]), "," , '"', str(t[6]), str(t[7]), '"', ")")
             elif len(t) == 7:
-                print str(t[3]) + "* = tshift(", str(t[3]), ",", str(t[5]), ")"
+                print(str(t[3]) + "* = tshift(", str(t[3]), ",", str(t[5]), ")")
 
     # Handle errors.
     def p_error(self, t):

lib/python/temporal/temporal_extent.py

@@ -19,7 +19,8 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from base import *
+from __future__ import print_function
+from .base import *
 
 ###############################################################################
 
@@ -156,13 +157,13 @@ class TemporalExtent(SQLDatabaseInterface):
                >>> A = TemporalExtent(start_time=5, end_time=8 )
                >>> B = TemporalExtent(start_time=3, end_time=4 )
                >>> inter = A.intersect(B)
-               >>> print inter
+               >>> print(inter)
                None
 
                >>> A = TemporalExtent(start_time=5, end_time=8 )
                >>> B = TemporalExtent(start_time=3, end_time=None )
                >>> inter = A.intersect(B)
-               >>> print inter
+               >>> print(inter)
                None
 
         """
@@ -396,13 +397,13 @@ class TemporalExtent(SQLDatabaseInterface):
                >>> A = TemporalExtent(start_time=5, end_time=8 )
                >>> B = TemporalExtent(start_time=3, end_time=4 )
                >>> inter = A.intersect(B)
-               >>> print inter
+               >>> print(inter)
                None
 
                >>> A = TemporalExtent(start_time=5, end_time=8 )
                >>> B = TemporalExtent(start_time=3, end_time=None )
                >>> inter = A.intersect(B)
-               >>> print inter
+               >>> print(inter)
                None
 
         """
@@ -1028,13 +1029,13 @@ class TemporalExtent(SQLDatabaseInterface):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " | Start time:................. " + str(self.get_start_time())
-        print " | End time:................... " + str(self.get_end_time())
+        print(" | Start time:................. " + str(self.get_start_time()))
+        print(" | End time:................... " + str(self.get_end_time()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
-        print "start_time=" + str(self.get_start_time())
-        print "end_time=" + str(self.get_end_time())
+        print("start_time=" + str(self.get_start_time()))
+        print("end_time=" + str(self.get_end_time()))
 
 ###############################################################################
 
@@ -1052,7 +1053,7 @@ class AbsoluteTemporalExtent(TemporalExtent):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " +-------------------- Absolute time -----------------------------------------+"
+        print(" +-------------------- Absolute time -----------------------------------------+")
         TemporalExtent.print_info(self)
 
     def print_shell_info(self):
@@ -1177,14 +1178,14 @@ class STDSAbsoluteTime(AbsoluteTemporalExtent):
         """Print information about this class in human readable style"""
         AbsoluteTemporalExtent.print_info(self)
         #      0123456789012345678901234567890
-        print " | Granularity:................ " + str(self.get_granularity())
-        print " | Temporal type of maps:...... " + str(self.get_map_time())
+        print(" | Granularity:................ " + str(self.get_granularity()))
+        print(" | Temporal type of maps:...... " + str(self.get_map_time()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         AbsoluteTemporalExtent.print_shell_info(self)
-        print "granularity=" + str(self.get_granularity())
-        print "map_time=" + str(self.get_map_time())
+        print("granularity=" + str(self.get_granularity()))
+        print("map_time=" + str(self.get_map_time()))
 
 ###############################################################################
 
@@ -1294,14 +1295,14 @@ class RelativeTemporalExtent(TemporalExtent):
     def print_info(self):
         """Print information about this class in human readable style"""
         #      0123456789012345678901234567890
-        print " +-------------------- Relative time -----------------------------------------+"
+        print(" +-------------------- Relative time -----------------------------------------+")
         TemporalExtent.print_info(self)
-        print " | Relative time unit:......... " + str(self.get_unit())
+        print(" | Relative time unit:......... " + str(self.get_unit()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         TemporalExtent.print_shell_info(self)
-        print "unit=" + str(self.get_unit())
+        print("unit=" + str(self.get_unit()))
 
 ###############################################################################
 
@@ -1426,14 +1427,14 @@ class STDSRelativeTime(RelativeTemporalExtent):
         """Print information about this class in human readable style"""
         RelativeTemporalExtent.print_info(self)
         #      0123456789012345678901234567890
-        print " | Granularity:................ " + str(self.get_granularity())
-        print " | Temporal type of maps:...... " + str(self.get_map_time())
+        print(" | Granularity:................ " + str(self.get_granularity()))
+        print(" | Temporal type of maps:...... " + str(self.get_map_time()))
 
     def print_shell_info(self):
         """Print information about this class in shell style"""
         RelativeTemporalExtent.print_shell_info(self)
-        print "granularity=" + str(self.get_granularity())
-        print "map_time=" + str(self.get_map_time())
+        print("granularity=" + str(self.get_granularity()))
+        print("map_time=" + str(self.get_map_time()))
 
 ###############################################################################
 

lib/python/temporal/temporal_granularity.py

@@ -17,8 +17,9 @@ for details.
 
 :authors: Soeren Gebbert
 """
-from abstract_dataset import *
-from datetime_math import *
+from .abstract_dataset import *
+from .datetime_math import *
+from functools import reduce
 
 ###############################################################################
 
@@ -497,7 +498,7 @@ def compute_absolute_time_granularity(maps):
 
 def compute_common_relative_time_granularity(gran_list):
 	"""Compute the greatest common granule from a list of relative time granules
-    
+
         .. code-block:: python
 
             >>> import grass.temporal as tgis
@@ -505,7 +506,7 @@ def compute_common_relative_time_granularity(gran_list):
             >>> grans = [1,2,30]
             >>> tgis.compute_common_relative_time_granularity(grans)
             1
-            
+
             >>> import grass.temporal as tgis
             >>> tgis.init()
             >>> grans = [10,20,30]
@@ -756,23 +757,23 @@ def compute_common_absolute_time_granularity_simple(gran_list):
             >>> grans = ["1 second", "2 seconds", "30 seconds"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '1 second'
-            
+
             >>> grans = ["3 second", "6 seconds", "30 seconds"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '3 seconds'
-            
+
             >>> grans = ["12 second", "18 seconds", "30 seconds", "10 minutes"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '6 seconds'
-            
+
             >>> grans = ["20 second", "10 minutes", "2 hours"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '20 seconds'
-            
+
             >>> grans = ["7200 second", "240 minutes", "1 year"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '7200 seconds'
-            
+
             >>> grans = ["7200 second", "89 minutes", "1 year"]
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '60 seconds'
@@ -821,37 +822,37 @@ def compute_common_absolute_time_granularity_simple(gran_list):
             >>> tgis.compute_common_absolute_time_granularity(grans)
             '1 year'
     """
-    
+
     has_seconds = False # 0
     has_minutes = False # 1
     has_hours = False     # 2
     has_days = False      # 3
     has_months = False  # 4
     has_years = False     # 5
-    
+
     seconds = []
     minutes = []
     hours = []
     days = []
     months = []
     years = []
-    
+
     min_gran = 6
     max_gran = -1
-    
+
     for entry in gran_list:
         if not check_granularity_string(entry, "absolute"):
             return False
 
         num,  gran = entry.split()
-        
+
         if gran in ["seconds",  "second"]:
             has_seconds = True
             if min_gran > 0:
                 min_gran = 0
             if max_gran < 0:
                 max_gran = 0
-                
+
             seconds.append(int(num))
 
         if gran in ["minutes",  "minute"]:
@@ -860,7 +861,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
                 min_gran = 1
             if max_gran < 1:
                 max_gran = 1
-                
+
             minutes.append(int(num))
 
         if gran in ["hours",  "hour"]:
@@ -869,7 +870,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
                 min_gran = 2
             if max_gran < 2:
                 max_gran = 2
-                
+
             hours.append(int(num))
 
         if gran in ["days",  "day"]:
@@ -878,7 +879,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
                 min_gran = 3
             if max_gran < 3:
                 max_gran = 3
-                
+
             days.append(int(num))
 
         if gran in ["months",  "month"]:
@@ -887,7 +888,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
                 min_gran = 4
             if max_gran < 4:
                 max_gran = 4
-                
+
             months.append(int(num))
 
         if gran in ["years",  "year"]:
@@ -896,9 +897,9 @@ def compute_common_absolute_time_granularity_simple(gran_list):
                 min_gran = 5
             if max_gran < 5:
                 max_gran = 5
-                
+
             years.append(int(num))
-            
+
     if has_seconds:
         if has_minutes:
             minutes.sort()
@@ -925,7 +926,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
         if num > 1:
             gran += "s"
         return "%i %s"%(num,  gran)
-        
+
     elif has_minutes:
         if has_hours:
             hours.sort()
@@ -948,7 +949,7 @@ def compute_common_absolute_time_granularity_simple(gran_list):
         if num > 1:
             gran += "s"
         return "%i %s"%(num,  gran)
-        
+
     elif has_hours:
         if has_days:
             days.sort()
@@ -995,14 +996,14 @@ def compute_common_absolute_time_granularity_simple(gran_list):
         if num > 1:
             gran += "s"
         return "%i %s"%(num,  gran)
-        
+
     elif has_years:
         num = gcd_list(years)
         gran = "year"
         if num > 1:
             gran += "s"
         return "%i %s"%(num,  gran)
-        
+
 
 ###############################################################################
 # http://akiscode.com/articles/gcd_of_a_list.shtml

lib/python/temporal/temporal_operator.py

@@ -14,95 +14,96 @@ for details.
     >>> p = TemporalOperatorParser()
     >>> expression =  "{equal| during}"
     >>> p.parse(expression, optype = 'relation')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal', 'during'], None, None)
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{contains | starts}"
     >>> p.parse(expression)
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['contains', 'starts'], None, None)
-    >>> p = TemporalOperatorParser()    
+    >>> 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()    
+    >>> 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()    
+    >>> 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()    
+    >>> 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()    
+    >>> 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()    
+    >>> 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()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{:, during, r}"
     >>> p.parse(expression, optype = 'select')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['during'], 'r', ':')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{!:, equal | contains, d}"
     >>> p.parse(expression, optype = 'select')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal', 'contains'], 'd', '!:')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{#, during, r}"
     >>> p.parse(expression, optype = 'hash')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['during'], 'r', '#')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{#, equal | contains}"
     >>> p.parse(expression, optype = 'hash')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal', 'contains'], 'l', '#')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{+, during, r}"
     >>> p.parse(expression, optype = 'raster')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['during'], 'r', '+')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{/, equal | contains}"
     >>> p.parse(expression, optype = 'raster')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal', 'contains'], 'l', '/')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{+, equal | contains,intersect}"
     >>> p.parse(expression, optype = 'raster')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal', 'contains'], 'i', '+')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{*, contains,disjoint}"
     >>> p.parse(expression, optype = 'raster')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['contains'], 'd', '*')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{~, equal,left}"
     >>> p.parse(expression, optype = 'overlay')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['equal'], 'l', '~')
-    >>> p = TemporalOperatorParser()    
+    >>> p = TemporalOperatorParser()
     >>> expression =  "{^, over,right}"
     >>> p.parse(expression, optype = 'overlay')
-    >>> print(p.relations, p.temporal, p.function)
+    >>> print((p.relations, p.temporal, p.function))
     (['overlaps', 'overlapped'], 'r', '^')
 
 """
+from __future__ import print_function
 
 try:
     import ply.lex as lex
@@ -134,7 +135,7 @@ class TemporalOperatorLexer(object):
         'COMMA',
         'LEFTREF',
         'RIGHTREF',
-        'UNION', 
+        'UNION',
         'DISJOINT',
         'INTERSECT',
         'HASH',
@@ -142,11 +143,11 @@ class TemporalOperatorLexer(object):
         'AND',
         'DISOR',
         'XOR',
-        'NOT',        
+        'NOT',
         'MOD',
         'DIV',
         'MULT',
-        'ADD',      
+        'ADD',
         'SUB',
         'T_SELECT',
         'T_NOT_SELECT',
@@ -171,7 +172,7 @@ class TemporalOperatorLexer(object):
     t_AND                        = r'[&]'
     t_DISOR                     = r'\+'
     t_XOR                         = r'\^'
-    t_NOT                         = r'\~'    
+    t_NOT                         = r'\~'
     t_MOD                       = r'[\%]'
     t_DIV                         = r'[\/]'
     t_MULT                      = r'[\*]'
@@ -234,7 +235,7 @@ class TemporalOperatorLexer(object):
         while True:
              tok = self.lexer.token()
              if not tok: break
-             print tok
+             print(tok)
 
 ###############################################################################
 
@@ -251,19 +252,19 @@ class TemporalOperatorParser(object):
         self.aggregate = None
 
     def parse(self, expression,  optype = 'relation'):
-        self.optype = optype        
+        self.optype = optype
         self.parser.parse(expression)
-        # The parameter optype can be of type: select {:, during, r}, boolean{&&, contains, |}, 
+        # The parameter optype can be of type: select {:, during, r}, boolean{&&, contains, |},
         #                                                            raster{*, equal, |}, vector {|, starts, &},
         #                                                            hash{#, during, l} or relation {during}.
-    
+
     # Error rule for syntax errors.
     def p_error(self, t):
         raise SyntaxError("Unexpected syntax error")
 
     # Get the tokens from the lexer class
     tokens = TemporalOperatorLexer.tokens
- 
+
     def p_relation_operator(self, t):
         # The expression should always return a list of maps.
         """
@@ -294,7 +295,7 @@ class TemporalOperatorParser(object):
         """
         if not self.optype == 'boolean':
             raise SyntaxError("invalid syntax")
-        else:        
+        else:
             # Set three operator components.
             if isinstance(t[5], list):
                 self.relations = t[5]
@@ -303,7 +304,7 @@ class TemporalOperatorParser(object):
             self.temporal  = "l"
             self.function  = t[2] + t[3]
             self.aggregate = t[2]
-            
+
             t[0] = t[2]
 
     def p_relation_bool_combi_operator(self, t):
@@ -320,7 +321,7 @@ class TemporalOperatorParser(object):
         """
         if not self.optype == 'boolean':
             raise SyntaxError("invalid syntax")
-        else:        
+        else:
             # Set three operator components.
             if isinstance(t[5], list):
                 self.relations = t[5]
@@ -329,7 +330,7 @@ class TemporalOperatorParser(object):
             self.temporal  = "l"
             self.function  = t[2] + t[3]
             self.aggregate = t[7]
-            
+
             t[0] = t[2]
 
     def p_relation_bool_combi_operator2(self, t):
@@ -342,7 +343,7 @@ class TemporalOperatorParser(object):
         """
         if not self.optype == 'boolean':
             raise SyntaxError("invalid syntax")
-        else:        
+        else:
             # Set three operator components.
             if isinstance(t[5], list):
                 self.relations = t[5]
@@ -351,9 +352,9 @@ class TemporalOperatorParser(object):
             self.temporal  = t[7]
             self.function  = t[2] + t[3]
             self.aggregate = t[2]
-            
+
             t[0] = t[2]
-    
+
     def p_relation_bool_combi_operator3(self, t):
         # The expression should always return a list of maps.
         """
@@ -368,7 +369,7 @@ class TemporalOperatorParser(object):
         """
         if not self.optype == 'boolean':
             raise SyntaxError("invalid syntax")
-        else:        
+        else:
             # Set three operator components.
             if isinstance(t[5], list):
                 self.relations = t[5]
@@ -377,9 +378,9 @@ class TemporalOperatorParser(object):
             self.temporal  = t[9]
             self.function  = t[2] + t[3]
             self.aggregate = t[7]
-            
+
             t[0] = t[2]
-    
+
     def p_select_relation_operator(self, t):
         # The expression should always return a list of maps.
         """
@@ -612,4 +613,3 @@ class TemporalOperatorParser(object):
 if __name__ == "__main__":
     import doctest
     doctest.testmod()
-

lib/python/temporal/temporal_raster3d_algebra.py

@@ -10,9 +10,7 @@ for details.
 :authors: Thomas Leppelt and Soeren Gebbert
 
 """
-
-import grass.pygrass.modules as pygrass
-from temporal_raster_base_algebra import *
+from .temporal_raster_base_algebra import *
 
 ###############################################################################
 
@@ -34,7 +32,7 @@ class TemporalRaster3DAlgebraParser(TemporalRasterBaseAlgebraParser):
         while True:
             tok = l.lexer.token()
             if not tok: break
-            
+
             if tok.type == "STVDS" or tok.type == "STRDS" or tok.type == "STR3DS":
                 raise SyntaxError("Syntax error near '%s'" %(tok.type))
 

lib/python/temporal/temporal_raster_algebra.py

@@ -52,7 +52,7 @@ for details.
 
 """
 
-from temporal_raster_base_algebra import *
+from .temporal_raster_base_algebra import *
 
 ###############################################################################
 
@@ -74,10 +74,10 @@ class TemporalRasterAlgebraParser(TemporalRasterBaseAlgebraParser):
         while True:
             tok = l.lexer.token()
             if not tok: break
-            
+
             if tok.type == "STVDS" or tok.type == "STRDS" or tok.type == "STR3DS":
                 raise SyntaxError("Syntax error near '%s'" %(tok.type))
-        
+
         self.lexer = TemporalRasterAlgebraLexer()
         self.lexer.build()
         self.parser = yacc.yacc(module=self, debug=self.debug)

lib/python/temporal/temporal_topology_dataset_connector.py

@@ -16,6 +16,7 @@ for details.
 
 :authors: Soeren Gebbert
 """
+from __future__ import print_function
 import copy
 
 
@@ -104,7 +105,7 @@ class TemporalTopologyDatasetConnector(object):
             finished=a@P
             >>> rlist = tmr.get_temporal_relations()
             >>> if "FINISHED" in rlist.keys():
-            ...    print rlist["FINISHED"][0].get_id()
+            ...    print(rlist["FINISHED"][0].get_id())
             a@P
 
     """
@@ -503,85 +504,85 @@ class TemporalTopologyDatasetConnector(object):
     def print_temporal_topology_info(self):
         """Print information about this class in human readable style"""
 
-        print " +-------------------- Temporal Topology -------------------------------------+"
+        print(" +-------------------- Temporal Topology -------------------------------------+")
         #          0123456789012345678901234567890
         if self.next() is not None:
-            print " | Next: ...................... " + str(self.next().get_id())
+            print(" | Next: ...................... " + str(self.next().get_id()))
         if self.prev() is not None:
-            print " | Previous: .................. " + str(self.prev().get_id())
+            print(" | Previous: .................. " + str(self.prev().get_id()))
         if self.equal is not None:
-            print " | Equal:...................... " + \
-                self._generate_map_list_string(self.equal)
+            print(" | Equal:...................... " +
+                  self._generate_map_list_string(self.equal))
         if self.follows is not None:
-            print " | Follows: ................... " + \
-                self._generate_map_list_string(self.follows)
+            print(" | Follows: ................... " +
+                  self._generate_map_list_string(self.follows))
         if self.precedes is not None:
-            print " | Precedes: .................. " + \
-                self._generate_map_list_string(self.precedes)
+            print(" | Precedes: .................. " +
+                  self._generate_map_list_string(self.precedes))
         if self.overlaps is not None:
-            print " | Overlaps: .................. " + \
-                self._generate_map_list_string(self.overlaps)
+            print(" | Overlaps: .................. " +
+                  self._generate_map_list_string(self.overlaps))
         if self.overlapped is not None:
-            print " | Overlapped: ................ " + \
-                self._generate_map_list_string(self.overlapped)
+            print(" | Overlapped: ................ " +
+                  self._generate_map_list_string(self.overlapped))
         if self.during is not None:
-            print " | During: .................... " + \
-                self._generate_map_list_string(self.during)
+            print(" | During: .................... " +
+                  self._generate_map_list_string(self.during))
         if self.contains is not None:
-            print " | Contains: .................. " + \
-                self._generate_map_list_string(self.contains)
+            print(" | Contains: .................. " +
+                  self._generate_map_list_string(self.contains))
         if self.starts is not None:
-            print " | Starts:.. .................. " + \
-                self._generate_map_list_string(self.starts)
+            print(" | Starts:.. .................. " +
+                  self._generate_map_list_string(self.starts))
         if self.started is not None:
-            print " | Started:. .................. " + \
-                self._generate_map_list_string(self.started)
+            print(" | Started:. .................. " +
+                  self._generate_map_list_string(self.started))
         if self.finishes is not None:
-            print " | Finishes:................... " + \
-                self._generate_map_list_string(self.finishes)
+            print(" | Finishes:................... " +
+                  self._generate_map_list_string(self.finishes))
         if self.finished is not None:
-            print " | Finished:................... " + \
-                self._generate_map_list_string(self.finished)
+            print(" | Finished:................... " +
+                  self._generate_map_list_string(self.finished))
 
     def print_temporal_topology_shell_info(self):
         """Print information about this class in shell style"""
 
         if self.next() is not None:
-            print "next=" + self.next().get_id()
+            print("next=" + self.next().get_id())
         if self.prev() is not None:
-            print "prev=" + self.prev().get_id()
+            print("prev=" + self.prev().get_id())
         if self.equal is not None:
-            print "equal=" + self._generate_map_list_string(self.equal, False)
+            print("equal=" + self._generate_map_list_string(self.equal, False))
         if self.follows is not None:
-            print "follows=" + self._generate_map_list_string(self.follows,
-                                                              False)
+            print("follows=" + self._generate_map_list_string(self.follows,
+                                                              False))
         if self.precedes is not None:
-            print "precedes=" + self._generate_map_list_string(
-                self.precedes, False)
+            print("precedes=" + self._generate_map_list_string(
+                  self.precedes, False))
         if self.overlaps is not None:
-            print "overlaps=" + self._generate_map_list_string(
-                self.overlaps, False)
+            print("overlaps=" + self._generate_map_list_string(
+                  self.overlaps, False))
         if self.overlapped is not None:
-            print "overlapped=" + \
-                self._generate_map_list_string(self.overlapped, False)
+            print("overlapped=" +
+                  self._generate_map_list_string(self.overlapped, False))
         if self.during is not None:
-            print "during=" + self._generate_map_list_string(self.during,
-                                                             False)
+            print("during=" + self._generate_map_list_string(self.during,
+                                                             False))
         if self.contains is not None:
-            print "contains=" + self._generate_map_list_string(
-                self.contains, False)
+            print("contains=" + self._generate_map_list_string(
+                  self.contains, False))
         if self.starts is not None:
-            print "starts=" + \
-                self._generate_map_list_string(self.starts)
+            print("starts=" +
+                  self._generate_map_list_string(self.starts))
         if self.started is not None:
-            print "started=" + \
-                self._generate_map_list_string(self.started)
+            print("started=" +
+                  self._generate_map_list_string(self.started))
         if self.finishes is not None:
-            print "finishes=" + \
-                self._generate_map_list_string(self.finishes)
+            print("finishes=" +
+                  self._generate_map_list_string(self.finishes))
         if self.finished is not None:
-            print "finished=" + \
-                self._generate_map_list_string(self.finished)
+            print("finished=" +
+                  self._generate_map_list_string(self.finished))
 
 ###############################################################################
 

lib/python/temporal/temporal_vector_algebra.py

@@ -41,10 +41,10 @@ for details.
     LexToken(RPAREN,')',1,16)
 
 """
-
+from __future__ import print_function
 import grass.pygrass.modules as pygrass
-from temporal_operator import *
-from temporal_algebra import *
+from .temporal_operator import *
+from .temporal_algebra import *
 
 ##############################################################################
 
@@ -129,7 +129,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
         while True:
             tok = l.lexer.token()
             if not tok: break
-            
+
             if tok.type == "STVDS" or tok.type == "STRDS" or tok.type == "STR3DS":
                 raise SyntaxError("Syntax error near '%s'" %(tok.type))
 
@@ -149,12 +149,12 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
     ######################### Temporal functions ##############################
 
     def get_temporal_topo_list(self, maplistA, maplistB = None, topolist = ["EQUAL"],
-                               assign_val = False, count_map = False, compare_bool = False,  
-                               compare_cmd = False,  compop = None, aggregate = None,  
+                               assign_val = False, count_map = False, compare_bool = False,
+                               compare_cmd = False,  compop = None, aggregate = None,
                                new = False,  convert = False,  overlay_cmd = False):
         """Build temporal topology for two space time data sets, copy map objects
           for given relation into map list.
-          
+
           :param maplistA: List of maps.
           :param maplistB: List of maps.
           :param topolist: List of strings of temporal relations.
@@ -170,11 +170,11 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
           :param compop: Comparison operator, && or ||.
           :param aggregate: Aggregation operator for relation map list, & or |.
           :param new: Boolean if new temporary maps should be created.
-          :param convert: Boolean if conditional values should be converted to 
+          :param convert: Boolean if conditional values should be converted to
                         r.mapcalc command strings.
-          :param overlay_cmd: Boolean for aggregate overlay operators implicitly 
+          :param overlay_cmd: Boolean for aggregate overlay operators implicitly
                         in command list values based on related map lists.
-                    
+
           :return: List of maps from maplistA that fulfil the topological relationships
                   to maplistB specified in topolist.
         """
@@ -215,7 +215,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                 self.compare_cmd_value(map_i,  tbrelations, compop, aggregate, topolist, convert)
             elif overlay_cmd:
                 self.overlay_cmd_value(map_i,  tbrelations, compop, topolist)
-                
+
             for topo in topolist:
                 if topo.upper() in tbrelations.keys():
                     if count_map:
@@ -229,21 +229,21 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                     # Use unique identifier, since map names may be equal
                     resultdict[map_i.uid] = map_i
         resultlist = resultdict.values()
-        
+
         # Sort list of maps chronological.
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
-        
+
         return(resultlist)
 
     def overlay_cmd_value(self,  map_i, tbrelations, function, topolist = ["EQUAL"]):
         """ Function to evaluate two map lists by given overlay operator.
-        
+
           :param map_i: Map object with temporal extent.
           :param tbrelations: List of temporal relation to map_i.
           :param topolist: List of strings for given temporal relations.
           :param function: Overlay operator, &|+^~.
-          
-          :return: Map object with command list with  operators that has been 
+
+          :return: Map object with command list with  operators that has been
                         evaluated by implicit aggregration.
         """
         # Build comandlist list with elements from related maps and given relation operator.
@@ -292,30 +292,30 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                     mapainput = name
         # Add command list to result map.
         map_i.cmd_list = resultlist
-        
+
         return(resultlist)
 
     def set_temporal_extent_list(self, maplist, topolist = ["EQUAL"], temporal = 'l' ):
-        """ Change temporal extent of map list based on temporal relations to 
+        """ Change temporal extent of map list based on temporal relations to
                 other map list and given temporal operator.
 
-            :param maplist: List of map objects for which relations has been build 
+            :param maplist: List of map objects for which relations has been build
                                         correctely.
             :param topolist: List of strings of temporal relations.
             :param temporal: The temporal operator specifying the temporal
-                                            extent operation (intersection, union, disjoint 
+                                            extent operation (intersection, union, disjoint
                                             union, right reference, left reference).
 
             :return: Map list with specified temporal extent.
         """
         resultdict = {}
-        
+
         for map_i in maplist:
             # Loop over temporal related maps and create overlay modules.
             tbrelations = map_i.get_temporal_relations()
             # Generate an intermediate map for the result map list.
-            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and', 
-                                                                        copy = True,  rename = False,  
+            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and',
+                                                                        copy = True,  rename = False,
                                                                         remove = True)
             # Combine temporal and spatial extents of intermediate map with related maps.
             for topo in topolist:
@@ -323,8 +323,8 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                     for map_j in (tbrelations[topo]):
                         if temporal == 'r':
                             # Generate an intermediate map for the result map list.
-                            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and', 
-                                                                                        copy = True,  rename = False,  
+                            map_new = self.generate_new_map(base_map=map_i, bool_op = 'and',
+                                                                                        copy = True,  rename = False,
                                                                                         remove = True)
                         # Create overlayed map extent.
                         returncode = self.overlay_map_extent(map_new, map_j, 'and', \
@@ -344,9 +344,9 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
         # Get sorted map objects as values from result dictionoary.
         resultlist = resultdict.values()
         resultlist = sorted(resultlist, key = AbstractDatasetComparisonKeyStartTime)
-        
+
         return(resultlist)
-    
+
     ###########################################################################
 
     def p_statement_assign(self, t):
@@ -414,7 +414,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                                 break
                         if returncode == 0:
                             # We remove the invalid vector name from the remove list.
-                            if self.removable_maps.has_key(map_i.get_name()):
+                            if map_i.get_name() in self.removable_maps:
                                 self.removable_maps.pop(map_i.get_name())
                             mapset = map_i.get_mapset()
                             # Change map name to given basename.
@@ -427,7 +427,7 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                             count += 1
                             register_list.append(map_i)
                     else:
-                        # Test if temporal extents have been changed by temporal 
+                        # Test if temporal extents have been changed by temporal
                         # relation operators (i|r). This is a code copy from temporal_algebra.py
                         map_i_extent = map_i.get_temporal_extent_as_tuple()
                         map_test = map_i.get_new_instance(map_i.get_id())
@@ -483,11 +483,11 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
                             # Map is original from an input STVDS
                             map_i.load()
                         # Register map in result space time dataset.
-                        print map_i.get_temporal_extent_as_tuple()
+                        print(map_i.get_temporal_extent_as_tuple())
                         success = resultstds.register_map(map_i, dbif=dbif)
                     resultstds.update_from_registered_maps(dbif)
-                
-            # Remove intermediate maps    
+
+            # Remove intermediate maps
             self.remove_maps()
             if connected:
                 dbif.close()
@@ -521,13 +521,13 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
             maplistA = self.check_stds(t[1])
             maplistB = self.check_stds(t[3])
             relations = ["EQUAL"]
-            temporal = 'l' 
-            function = t[2] 
+            temporal = 'l'
+            function = t[2]
             # Build commmand list for related maps.
             complist = self.get_temporal_topo_list(maplistA, maplistB, topolist = relations,
                                                                     compop = function, overlay_cmd = True)
             # Set temporal extent based on topological relationships.
-            resultlist = self.set_temporal_extent_list(complist, topolist = relations, 
+            resultlist = self.set_temporal_extent_list(complist, topolist = relations,
                                 temporal = temporal)
 
             t[0] = resultlist
@@ -550,9 +550,9 @@ class TemporalVectorAlgebraParser(TemporalAlgebraParser):
             complist = self.get_temporal_topo_list(maplistA, maplistB, topolist = relations,
                                                                     compop = function, overlay_cmd = True)
             # Set temporal extent based on topological relationships.
-            resultlist = self.set_temporal_extent_list(complist, topolist = relations, 
+            resultlist = self.set_temporal_extent_list(complist, topolist = relations,
                                 temporal = temporal)
-          
+
             t[0] = resultlist
         if self.debug:
             str(t[1]) + t[2] + str(t[3])

lib/python/temporal/univar_statistics.py

@@ -18,8 +18,9 @@ for details.
 
 :authors: Soeren Gebbert
 """
+from __future__ import print_function
 
-from open_stds import *
+from .open_stds import *
 import grass.script as gscript
 
 ###############################################################################
@@ -71,7 +72,7 @@ def print_gridded_dataset_univar_statistics(type, input, output, where, extended
             string += "third_quartile" + fs + "percentile_90"
 
         if output is None:
-            print string
+            print(string)
         else:
             out_file.write(string + "\n")
 
@@ -113,7 +114,7 @@ def print_gridded_dataset_univar_statistics(type, input, output, where, extended
             string += fs + str(stats["third_quartile"]) + fs + str(stats["percentile_90"])
 
         if output is None:
-            print string
+            print(string)
         else:
             out_file.write(string + "\n")
 
@@ -191,7 +192,7 @@ def print_vector_dataset_univar_statistics(input, output, twhere, layer, type, c
                     "third_quartile" + fs + "percentile_90"
 
         if output is None:
-            print string
+            print(string)
         else:
             out_file.write(string + "\n")
 
@@ -254,7 +255,7 @@ def print_vector_dataset_univar_statistics(input, output, twhere, layer, type, c
                     string += fs + fs + fs + fs
 
         if output is None:
-            print string
+            print(string)
         else:
             out_file.write(string + "\n")
 

scripts/d.correlate/d.correlate.py

@@ -29,21 +29,23 @@
 import sys
 import os
 from grass.script.utils import try_remove
-from grass.script import core as grass
+from grass.script import core as gcore
+
 
 def main():
     layers = options['map'].split(',')
 
     if len(layers) < 2:
-	grass.error(_("At least 2 maps are required"))
+        gcore.error(_("At least 2 maps are required"))
 
-    tmpfile = grass.tempfile()
+    tmpfile = gcore.tempfile()
 
     for map in layers:
-	if not grass.find_file(map, element = 'cell')['file']:
-	    grass.fatal(_("Raster map <%s> not found") % map)
+        if not gcore.find_file(map, element='cell')['file']:
+            gcore.fatal(_("Raster map <%s> not found") % map)
 
-    grass.write_command('d.text', color = 'black', size = 4, line = 1, stdin = "CORRELATION")
+    gcore.write_command('d.text', color='black', size=4, line=1,
+                        stdin="CORRELATION")
 
     os.environ['GRASS_RENDER_FILE_READ'] = 'TRUE'
 
@@ -52,53 +54,60 @@ def main():
     iloop = 0
     jloop = 0
     for iloop, i in enumerate(layers):
-	for jloop, j in enumerate(layers):
-	    if i != j and iloop <= jloop:
-		color = colors[0]
-		colors = colors[1:]
-		colors.append(color)
-		grass.write_command('d.text', color = color, size = 4, line = line, stdin = "%s %s" % (i, j))
-		line += 1
-
-		ofile = file(tmpfile, 'w')
-		grass.run_command('r.stats', flags = 'cnA', input = (i, j), stdout = ofile)
-		ofile.close()
-
-		ifile = file(tmpfile, 'r')
-		first = True
-		for l in ifile:
-		    f = l.rstrip('\r\n').split(' ')
-		    x = float(f[0])
-		    y = float(f[1])
-		    if first:
-			minx = maxx = x
-			miny = maxy = y
-			first = False
-		    if minx > x: minx = x
-		    if maxx < x: maxx = x
-		    if miny > y: miny = y
-		    if maxy < y: maxy = y
-		ifile.close()
-
-		kx = 100.0/(maxx-minx+1)
-		ky = 100.0/(maxy-miny+1)
-
-		p = grass.feed_command('d.graph', color = color)
-		ofile = p.stdin
-
-		ifile = file(tmpfile, 'r')
-		for l in ifile:
-		    f = l.rstrip('\r\n').split(' ')
-		    x = float(f[0])
-		    y = float(f[1])
-		    ofile.write("icon + 0.1 %f %f\n" % ((x-minx+1) * kx, (y-miny+1) * ky))
-		ifile.close()
-
-		ofile.close()
-		p.wait()
+        for jloop, j in enumerate(layers):
+            if i != j and iloop <= jloop:
+                color = colors[0]
+                colors = colors[1:]
+                colors.append(color)
+                gcore.write_command('d.text', color=color, size=4, line=line,
+                                    stdin="%s %s" % (i, j))
+                line += 1
+
+                ofile = file(tmpfile, 'w')
+                gcore.run_command('r.stats', flags='cnA', input=(i, j),
+                                  stdout=ofile)
+                ofile.close()
+
+                ifile = file(tmpfile, 'r')
+                first = True
+                for l in ifile:
+                    f = l.rstrip('\r\n').split(' ')
+                    x = float(f[0])
+                    y = float(f[1])
+                    if first:
+                        minx = maxx = x
+                        miny = maxy = y
+                        first = False
+                    if minx > x:
+                        minx = x
+                    if maxx < x:
+                        maxx = x
+                    if miny > y:
+                        miny = y
+                    if maxy < y:
+                        maxy = y
+                ifile.close()
+
+                kx = 100.0 / (maxx - minx + 1)
+                ky = 100.0 / (maxy - miny + 1)
+
+                p = gcore.feed_command('d.graph', color=color)
+                ofile = p.stdin
+
+                ifile = file(tmpfile, 'r')
+                for l in ifile:
+                    f = l.rstrip('\r\n').split(' ')
+                    x = float(f[0])
+                    y = float(f[1])
+                    ofile.write("icon + 0.1 %f %f\n" % ((x - minx + 1) * kx,
+                                                        (y - miny + 1) * ky))
+                ifile.close()
+
+                ofile.close()
+                p.wait()
 
     try_remove(tmpfile)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     main()

scripts/d.frame/d.frame.py

@@ -71,11 +71,15 @@ import sys
 from grass.script.core import parser, read_command, fatal, debug, run_command, gisenv, warning, parse_command
 
 # check if monitor is running
+
+
 def check_monitor():
     return read_command('d.mon', flags='p', quiet=True).strip()
 
 # read monitor file and return list of lines
 # TODO: replace by d.info (see #2577)
+
+
 def read_monitor_file(monitor, ftype='env'):
     mfile = check_monitor_file(monitor, ftype)
     try:
@@ -88,18 +92,22 @@ def read_monitor_file(monitor, ftype='env'):
         lines.append(line)
 
     fd.close()
-    
+
     return lines
 
 # check if monitor file exists
+
+
 def check_monitor_file(monitor, ftype='env'):
     mfile = parse_command('d.mon', flags='g').get(ftype, None)
     if mfile is None or not os.path.isfile(mfile):
         fatal(_("Unable to get monitor info (no %s found)") % var)
-    
+
     return mfile
 
 # write new monitor file
+
+
 def write_monitor_file(monitor, lines, ftype='env'):
     mfile = check_monitor_file(monitor, ftype)
 
@@ -112,19 +120,23 @@ def write_monitor_file(monitor, lines, ftype='env'):
     fd.close()
 
 # remove all frames and erase screen
+
+
 def erase(monitor):
     # remove frames
     lines = []
     for line in read_monitor_file(monitor):
         if 'FRAME' not in line:
             lines.append(line)
-            
+
     write_monitor_file(monitor, lines)
-    
+
     # erase screen
     run_command('d.erase')
 
 # find frame for given monitor
+
+
 def find_frame(monitor, frame):
     for line in read_monitor_file(monitor):
         if 'FRAME' in line:
@@ -134,6 +146,8 @@ def find_frame(monitor, frame):
     return False
 
 # print frames name(s) to stdout
+
+
 def print_frames(monitor, current_only=False, full=False):
     for line in read_monitor_file(monitor):
         if 'FRAME' not in line:
@@ -146,10 +160,14 @@ def print_frames(monitor, current_only=False, full=False):
         sys.stdout.write('\n')
 
 # get frame name from line
+
+
 def get_frame_name(line):
     return line.rstrip('\n').rsplit('#', 1)[1].strip(' ')
 
 # calculate position of the frame in percent
+
+
 def calculate_frame(frame, at, width, height):
     try:
         b, t, l, r = list(map(float, at.split(',')))
@@ -160,11 +178,13 @@ def calculate_frame(frame, at, width, height):
     bottom = height - (b / 100. * height)
     left = l / 100. * width
     right = r / 100. * width
-    
+
     return 'GRASS_RENDER_FRAME=%d,%d,%d,%d # %s%s' % \
         (top, bottom, left, right, frame, '\n')
-    
+
 # create new frame
+
+
 def create_frame(monitor, frame, at, overwrite=False):
     lines = read_monitor_file(monitor)
     # get width and height of the monitor
@@ -180,7 +200,7 @@ def create_frame(monitor, frame, at, overwrite=False):
 
     if width < 0 or height < 0:
         fatal(_("Invalid monitor size: %dx%d") % (width, height))
-    
+
     if not overwrite:
         lines.append(calculate_frame(frame, at, width, height))
     else:
@@ -190,10 +210,12 @@ def create_frame(monitor, frame, at, overwrite=False):
                 continue
             if get_frame_name(line) == frame:
                 lines[idx] = calculate_frame(frame, at, width, height)
-    
+
     write_monitor_file(monitor, lines)
 
 # select existing frame
+
+
 def select_frame(monitor, frame):
     lines = read_monitor_file(monitor)
     for idx in range(len(lines)):
@@ -202,28 +224,29 @@ def select_frame(monitor, frame):
             continue
         if get_frame_name(line) == frame:
             if line.startswith('#'):
-                lines[idx] = line.lstrip('# ') # un-comment line
+                lines[idx] = line.lstrip('# ')  # un-comment line
         elif not line.startswith('#'):
-            lines[idx] = '# ' + line # comment-line
-    
+            lines[idx] = '# ' + line  # comment-line
+
     write_monitor_file(monitor, lines)
-    
+
+
 def main():
     # get currently selected monitor
     monitor = check_monitor()
     if not monitor:
         fatal(_("No graphics device selected. Use d.mon to select graphics device."))
-    
+
     if flags['e']:
         # remove frames and erase monitor and exit
         erase(monitor)
         return
-    
+
     if flags['p']:
         # print current frame and exit
         print_frames(monitor, current_only=True)
         return
-        
+
     if flags['a']:
         # print all frames including their position and exit
         print_frames(monitor, current_only=False, full=True)
@@ -245,12 +268,13 @@ def main():
             create_frame(monitor, options['frame'], options['at'], overwrite=True)
         else:
             if options['at']:
-                warning(_("Frame <%s> already found. An existing frame can be overwritten by '%s' flag.") % \
-                        (options['frame'], "--overwrite"))
-    
-    # select givenframe 
+                warning(
+                    _("Frame <%s> already found. An existing frame can be overwritten by '%s' flag.") %
+                    (options['frame'], "--overwrite"))
+
+    # select givenframe
     select_frame(monitor, options['frame'])
-            
+
 if __name__ == "__main__":
     options, flags = parser()
     sys.exit(main())

scripts/d.polar/d.polar.py

@@ -42,7 +42,6 @@
 #% description: Plot using Xgraph
 #%end
 
-import sys
 import os
 import string
 import types
@@ -51,16 +50,18 @@ import atexit
 import glob
 import shutil
 from grass.script.utils import try_remove, basename
-from grass.script import core as grass
+from grass.script import core as gcore
+
 
 def cleanup():
     try_remove(tmp)
     for f in glob.glob(tmp + '_*'):
-	try_remove(f)
+        try_remove(f)
+
 
 def plot_xgraph():
     newline = ['\n']
-    p = grass.Popen(['xgraph'], stdin = grass.PIPE)
+    p = gcore.Popen(['xgraph'], stdin=gcore.PIPE)
     for point in sine_cosine_replic + newline + outercircle + newline + vector:
         if isinstance(point, tuple):
             p.stdin.write("%f %f\n" % point)
@@ -69,16 +70,18 @@ def plot_xgraph():
     p.stdin.close()
     p.wait()
 
+
 def plot_dgraph():
-    # use d.info and d.frame to create a square frame in the center of the window.
-    s = grass.read_command('d.info', flags = 'd')
+    # use d.info and d.frame to create a square frame in the center of the
+    # window.
+    s = gcore.read_command('d.info', flags='d')
     f = s.split()
     frame_width = float(f[1])
     frame_height = float(f[2])
 
     # take shorter side as length of frame side
     min_side = min(frame_width, frame_height)
-    dx = (frame_width  - min_side) / 2
+    dx = (frame_width - min_side) / 2
     dy = (frame_height - min_side) / 2
 
     fl = dx
@@ -99,26 +102,27 @@ def plot_dgraph():
         for p in sine_cosine_replic if isinstance(p, tuple)]
 
     # create circle
-    circle = [(50*(1 + ring * math.sin(math.radians(i))),
-	       50*(1 + ring * math.cos(math.radians(i))))
-	      for i in range(0, 361)]
+    circle = [(50 * (1 + ring * math.sin(math.radians(i))),
+               50 * (1 + ring * math.cos(math.radians(i))))
+              for i in range(0, 361)]
 
     # trend vector
-    vect = [((scaleval * p[0]/maxradius + 1)*50,
-	     (scaleval * p[1]/maxradius + 1)*50)
-	    for p in vector[1:]]
+    vect = [((scaleval * p[0] / maxradius + 1) * 50,
+             (scaleval * p[1] / maxradius + 1) * 50)
+            for p in vector[1:]]
 
     # Possible TODOs:
     # To fill data area with color, use BOTH d.graph's polyline and polygon commands.
-    #  Using polygon alone gives a jagged boundary due to sampling technique (not a bug).
+    # Using polygon alone gives a jagged boundary due to sampling technique
+    # (not a bug).
 
     # plot it!
     lines = [
-	# draw circle
-	#   mandatory when drawing proportional to non-square frame
-	"color 180:255:180",
-	"polyline"] + circle + [
-	# draw axes
+        # draw circle
+        #   mandatory when drawing proportional to non-square frame
+        "color 180:255:180",
+        "polyline"] + circle + [
+        # draw axes
         "color 180:180:180",
         "width 0",
         "move 0 50",
@@ -126,16 +130,16 @@ def plot_dgraph():
         "move 50 0",
         "draw 50 100",
 
-	# draw the goods
+        # draw the goods
         "color red",
         "width 0",
         "polyline"] + sine_cosine_replic_normalized + [
-	# draw vector
+        # draw vector
         "color blue",
         "width 3",
         "polyline"] + vect + [
 
-	# draw compass text
+        # draw compass text
         "color black",
         "width 2",
         "size 10 10",
@@ -148,7 +152,7 @@ def plot_dgraph():
         "move 97 51",
         "text E",
 
-	# draw legend text
+        # draw legend text
         "width 0",
         "size 10",
         "color 0:180:0",
@@ -160,9 +164,9 @@ def plot_dgraph():
         "color blue",
         "move 0.5 90.5",
         "text Avg. direction"
-	]
+    ]
 
-    p = grass.feed_command('d.graph', env = tenv)
+    p = gcore.feed_command('d.graph', env=tenv)
     for point in lines:
         if isinstance(point, tuple):
             p.stdin.write("%f %f\n" % point)
@@ -171,9 +175,10 @@ def plot_dgraph():
     p.stdin.close()
     p.wait()
 
+
 def plot_eps(psout):
     # EPS output (by M.Neteler and Bruno Caprile, ITC-irst)
-    grass.message(_("Generating %s ...") % psout)
+    gcore.message(_("Generating %s ...") % psout)
 
     outerradius = maxradius
     epsscale = 0.1
@@ -188,10 +193,10 @@ def plot_eps(psout):
     diagramfontsize = halfframe / 20
     halfframe_2 = halfframe * 2
 
-    averagedirectioncolor = 1 #(blue)
-    diagramcolor = 4 #(red)
-    circlecolor = 2 #(green)
-    axescolor = 0 #(black)
+    averagedirectioncolor = 1  # (blue)
+    diagramcolor = 4  # (red)
+    circlecolor = 2  # (green)
+    axescolor = 0  # (black)
 
     northjustification = 2
     eastjustification = 6
@@ -200,12 +205,12 @@ def plot_eps(psout):
 
     northxshift = 1.02 * halfframe
     northyshift = 1.98 * halfframe
-    eastxshift  = 1.98 * halfframe
-    eastyshift  = 1.02 * halfframe
+    eastxshift = 1.98 * halfframe
+    eastyshift = 1.02 * halfframe
     southxshift = 1.02 * halfframe
     southyshift = 0.02 * halfframe
-    westxshift  = 0.01 * halfframe
-    westyshift  = 1.02 * halfframe
+    westxshift = 0.01 * halfframe
+    westyshift = 1.02 * halfframe
 
     alldatastring = "all data (null included)"
     realdatastring = "real data angles"
@@ -219,7 +224,11 @@ def plot_eps(psout):
     ##########
     outf = file(psout, 'w')
 
-    prolog = os.path.join(os.environ['GISBASE'], 'etc', 'd.polar', 'ps_defs.eps')
+    prolog = os.path.join(
+        os.environ['GISBASE'],
+        'etc',
+        'd.polar',
+        'ps_defs.eps')
     inf = file(prolog)
     shutil.copyfileobj(inf, outf)
     inf.close()
@@ -253,20 +262,24 @@ newpath
                                         %% first point moveto, then lineto
 """)
     s = t.substitute(
-	AXESLINEWIDTH = axeslinewidth,
-	DIAGRAMFONTSIZE = diagramfontsize,
-	DIAGRAMLINEWIDTH = diagramlinewidth,
-	EPSSCALE = epsscale,
-	HALFFRAME = halfframe,
-	HALFFRAME_2 = halfframe_2
-	)
+        AXESLINEWIDTH=axeslinewidth,
+        DIAGRAMFONTSIZE=diagramfontsize,
+        DIAGRAMLINEWIDTH=diagramlinewidth,
+        EPSSCALE=epsscale,
+        HALFFRAME=halfframe,
+        HALFFRAME_2=halfframe_2
+    )
     outf.write(s)
 
     sublength = len(outercircle) - 2
     (x, y) = outercircle[1]
-    outf.write("%.2f %.2f moveto\n" % (x * scale + halfframe, y * scale + halfframe))
+    outf.write(
+        "%.2f %.2f moveto\n" %
+        (x * scale + halfframe, y * scale + halfframe))
     for x, y in outercircle[2:]:
-        outf.write("%.2f %.2f lineto\n" % (x * scale + halfframe, y * scale + halfframe))
+        outf.write(
+            "%.2f %.2f lineto\n" %
+            (x * scale + halfframe, y * scale + halfframe))
 
     t = string.Template("""
 stroke
@@ -296,29 +309,33 @@ newpath
                                         %% first point moveto, then lineto
 """)
     s = t.substitute(
-	AXESFONTSIZE = axesfontsize,
-	DIAGRAMFONTSIZE = diagramfontsize,
-	DIAGRAMLINEWIDTH = diagramlinewidth,
-	EASTJUSTIFICATION = eastjustification,
-	EASTXSHIFT = eastxshift,
-	EASTYSHIFT = eastyshift,
-	NORTHJUSTIFICATION = northjustification,
-	NORTHXSHIFT = northxshift,
-	NORTHYSHIFT = northyshift,
-	SOUTHJUSTIFICATION = southjustification,
-	SOUTHXSHIFT = southxshift,
-	SOUTHYSHIFT = southyshift,
-	WESTJUSTIFICATION = westjustification,
-	WESTXSHIFT = westxshift,
-	WESTYSHIFT = westyshift
-	)
+        AXESFONTSIZE=axesfontsize,
+        DIAGRAMFONTSIZE=diagramfontsize,
+        DIAGRAMLINEWIDTH=diagramlinewidth,
+        EASTJUSTIFICATION=eastjustification,
+        EASTXSHIFT=eastxshift,
+        EASTYSHIFT=eastyshift,
+        NORTHJUSTIFICATION=northjustification,
+        NORTHXSHIFT=northxshift,
+        NORTHYSHIFT=northyshift,
+        SOUTHJUSTIFICATION=southjustification,
+        SOUTHXSHIFT=southxshift,
+        SOUTHYSHIFT=southyshift,
+        WESTJUSTIFICATION=westjustification,
+        WESTXSHIFT=westxshift,
+        WESTYSHIFT=westyshift
+    )
     outf.write(s)
 
     sublength = len(sine_cosine_replic) - 2
     (x, y) = sine_cosine_replic[1]
-    outf.write("%.2f %.2f moveto\n" % (x * scale + halfframe, y * scale + halfframe))
+    outf.write(
+        "%.2f %.2f moveto\n" %
+        (x * scale + halfframe, y * scale + halfframe))
     for x, y in sine_cosine_replic[2:]:
-        outf.write("%.2f %.2f lineto\n" % (x * scale + halfframe, y * scale + halfframe))
+        outf.write(
+            "%.2f %.2f lineto\n" %
+            (x * scale + halfframe, y * scale + halfframe))
 
     t = string.Template("""
 stroke
@@ -333,14 +350,18 @@ newpath
                                         %% coordinates of rescaled, translated average direction follow
                                         %% first point moveto, second lineto
 """)
-    s = t.substitute(DIAGRAMLINEWIDTH = diagramlinewidth)
+    s = t.substitute(DIAGRAMLINEWIDTH=diagramlinewidth)
     outf.write(s)
 
     sublength = len(vector) - 2
     (x, y) = vector[1]
-    outf.write("%.2f %.2f moveto\n" % (x * scale + halfframe, y * scale + halfframe))
+    outf.write(
+        "%.2f %.2f moveto\n" %
+        (x * scale + halfframe, y * scale + halfframe))
     for x, y in vector[2:]:
-        outf.write("%.2f %.2f lineto\n" % (x * scale + halfframe, y * scale + halfframe))
+        outf.write(
+            "%.2f %.2f lineto\n" %
+            (x * scale + halfframe, y * scale + halfframe))
 
     t = string.Template("""
 stroke
@@ -362,19 +383,20 @@ col1                                    %% colAVERAGE-DIRECTION-COLOR
 ($AVERAGEDIRECTIONSTRING) $LEGENDSX $AVERAGEDIRECTIONLEGENDY 4 just-string
 """)
     s = t.substitute(
-	ALLDATALEGENDY = alldatalegendy,
-	ALLDATASTRING = alldatastring,
-	AVERAGEDIRECTIONLEGENDY = averagedirectionlegendy,
-	AVERAGEDIRECTIONSTRING = averagedirectionstring,
-	LEGENDSX = legendsx,
-	REALDATALEGENDY = realdatalegendy,
-	REALDATASTRING = realdatastring
-	)
+        ALLDATALEGENDY=alldatalegendy,
+        ALLDATASTRING=alldatastring,
+        AVERAGEDIRECTIONLEGENDY=averagedirectionlegendy,
+        AVERAGEDIRECTIONSTRING=averagedirectionstring,
+        LEGENDSX=legendsx,
+        REALDATALEGENDY=realdatalegendy,
+        REALDATASTRING=realdatastring
+    )
     outf.write(s)
 
     outf.close()
 
-    grass.message(_("Done."))
+    gcore.message(_("Done."))
+
 
 def main():
     global tmp
@@ -386,31 +408,33 @@ def main():
     eps = options['output']
     xgraph = flags['x']
 
-    tmp = grass.tempfile()
+    tmp = gcore.tempfile()
 
     if eps and xgraph:
-	grass.fatal(_("Please select only one output method"))
+        gcore.fatal(_("Please select only one output method"))
 
-    #### check if we have xgraph (if no EPS output requested)
-    if xgraph and not grass.find_program('xgraph'):
-	grass.fatal(_("xgraph required, please install first (www.xgraph.org)"))
+    # check if we have xgraph (if no EPS output requested)
+    if xgraph and not gcore.find_program('xgraph'):
+        gcore.fatal(
+            _("xgraph required, please install first (www.xgraph.org)"))
 
     #################################
     # this file contains everthing:
     rawfile = tmp + "_raw"
     rawf = file(rawfile, 'w')
-    grass.run_command('r.stats', flags = '1', input = map, stdout = rawf)
+    gcore.run_command('r.stats', flags='1', input=map, stdout=rawf)
     rawf.close()
 
     rawf = file(rawfile)
     totalnumber = 0
     for line in rawf:
-	totalnumber += 1
+        totalnumber += 1
     rawf.close()
 
-    grass.message(_("Calculating statistics for polar diagram... (be patient)"))
+    gcore.message(
+        _("Calculating statistics for polar diagram... (be patient)"))
 
-    #wipe out NULL data and undef data if defined by user
+    # wipe out NULL data and undef data if defined by user
     # - generate degree binned to integer, eliminate NO DATA (NULL):
     # change 360 to 0 to close polar diagram:
     rawf = file(rawfile)
@@ -419,26 +443,26 @@ def main():
     sumsin = 0
     freq = {}
     for line in rawf:
-	line = line.rstrip('\r\n')
-	if line in ['*', undef]:
-	    continue
-	nvals += 1
-	x = float(line)
-	rx = math.radians(x)
-	sumcos += math.cos(rx)
-	sumsin += math.sin(rx)
-	ix = round(x)
-	if ix == 360:
-	    ix = 0
-	if ix in freq:
-	    freq[ix] += 1
-	else:
-	    freq[ix] = 1
+        line = line.rstrip('\r\n')
+        if line in ['*', undef]:
+            continue
+        nvals += 1
+        x = float(line)
+        rx = math.radians(x)
+        sumcos += math.cos(rx)
+        sumsin += math.sin(rx)
+        ix = round(x)
+        if ix == 360:
+            ix = 0
+        if ix in freq:
+            freq[ix] += 1
+        else:
+            freq[ix] = 1
     rawf.close()
 
     totalvalidnumber = nvals
     if totalvalidnumber == 0:
-	grass.fatal(_("No data pixel found"))
+        gcore.fatal(_("No data pixel found"))
 
     #################################
     # unit vector on raw data converted to radians without no data:
@@ -447,9 +471,7 @@ def main():
 
     #################################
     # how many are there?:
-
-    occurrences = [(math.radians(x), freq[x]) for x in freq]
-    occurrences.sort()
+    occurrences = sorted([(math.radians(x), freq[x]) for x in freq])
 
     # find the maximum value
     maxradius = max([f for a, f in occurrences])
@@ -460,14 +482,14 @@ def main():
     sine_cosine_replic = ['"Real data angles'] + sine_cosine + sine_cosine[0:1]
 
     if eps or xgraph:
-	outercircle = []
-	outercircle.append('"All Data incl. NULLs')
-	scale = 1.0 * totalnumber / totalvalidnumber * maxradius
-	for i in range(0, 361):
-	    a = math.radians(i)
-	    x = math.cos(a) * scale
-	    y = math.sin(a) * scale
-	    outercircle.append((x, y))
+        outercircle = []
+        outercircle.append('"All Data incl. NULLs')
+        scale = 1.0 * totalnumber / totalvalidnumber * maxradius
+        for i in range(0, 361):
+            a = math.radians(i)
+            x = math.cos(a) * scale
+            y = math.sin(a) * scale
+            outercircle.append((x, y))
 
     # fix vector length to become visible (x? of $MAXRADIUS):
     vector = []
@@ -480,19 +502,28 @@ def main():
     # Now output:
 
     if eps:
-	psout = basename(eps, 'eps') + '.eps'
-	plot_eps(psout)
+        psout = basename(eps, 'eps') + '.eps'
+        plot_eps(psout)
     elif xgraph:
-	plot_xgraph()
+        plot_xgraph()
     else:
-	plot_dgraph()
-
-    grass.message(_("Average vector:"))
-    grass.message(_("direction: %.1f degrees CCW from East") % math.degrees(math.atan2(unitvector[1], unitvector[0])))
-    grass.message(_("magnitude: %.1f percent of fullscale") % (100 * math.hypot(unitvector[0], unitvector[1])))
+        plot_dgraph()
+
+    gcore.message(_("Average vector:"))
+    gcore.message(
+        _("direction: %.1f degrees CCW from East") %
+        math.degrees(
+            math.atan2(
+                unitvector[1],
+                unitvector[0])))
+    gcore.message(
+        _("magnitude: %.1f percent of fullscale") %
+        (100 *
+         math.hypot(
+             unitvector[0],
+             unitvector[1])))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     atexit.register(cleanup)
     main()
-

scripts/d.rast.leg/d.rast.leg.py

@@ -125,8 +125,10 @@ def main():
     ncats = len(cats.strip().split('\n'))
 
     # Only need to adjust legend size if number of categories is between 1 and 10
-    if ncats < 2: ncats = 2
-    if ncats > 10: ncats = 10
+    if ncats < 2:
+        ncats = 2
+    if ncats > 10:
+        ncats = 10
 
     VSpacing = (100 - (ncats * 10) + 10)
 

scripts/d.redraw/d.redraw.py

@@ -26,6 +26,7 @@ import sys
 from grass.script import core as grass
 from grass.script.utils import split
 
+
 def main():
     mon = grass.gisenv().get('MONITOR', None)
     if not mon:
@@ -38,25 +39,25 @@ def main():
     try:
         fd = open(monCmd, 'r')
         cmdList = fd.readlines()
-        
+
         grass.run_command('d.erase')
-        
+
         for cmd in cmdList:
             grass.call(split(cmd))
     except IOError as e:
-        grass.fatal(_("Unable to open file '%s' for reading. Details: %s") % \
-                        (monCmd, e))
-    
+        grass.fatal(_("Unable to open file '%s' for reading. Details: %s") %
+                    (monCmd, e))
+
     fd.close()
-    
+
     # restore cmd file
     try:
         fd = open(monCmd, "w")
         fd.writelines(cmdList)
     except IOError as e:
-        grass.fatal(_("Unable to open file '%s' for writing. Details: %s") % \
-                        (monCmd, e))
-    
+        grass.fatal(_("Unable to open file '%s' for writing. Details: %s") %
+                    (monCmd, e))
+
     return 0
 
 if __name__ == "__main__":

scripts/db.dropcolumn/db.dropcolumn.py

@@ -5,7 +5,7 @@
 # MODULE:       db.dropcolumn
 # AUTHOR(S):   	Markus Neteler
 #               Converted to Python by Glynn Clements
-# PURPOSE:      Interface to db.execute to drop a column from an 
+# PURPOSE:      Interface to db.execute to drop a column from an
 #               attribute table
 #               - with special trick for SQLite
 # COPYRIGHT:    (C) 2007, 2012 by Markus Neteler and the GRASS Development Team
@@ -36,10 +36,10 @@
 #%end
 
 import sys
-import os
 import string
-import grass.script as grass
+
 from grass.exceptions import CalledModuleError
+import grass.script as gscript
 
 
 def main():
@@ -48,66 +48,67 @@ def main():
     force = flags['f']
 
     # check if DB parameters are set, and if not set them.
-    grass.run_command('db.connect', flags = 'c')
+    gscript.run_command('db.connect', flags='c')
 
-    kv = grass.db_connection()
+    kv = gscript.db_connection()
     database = kv['database']
     driver = kv['driver']
     # schema needed for PG?
 
     if force:
-	grass.message(_("Forcing ..."))
+        gscript.message(_("Forcing ..."))
 
     if column == "cat":
-	grass.warning(_("Deleting <%s> column which may be needed to keep table connected to a vector map") % column)
+        gscript.warning(_("Deleting <%s> column which may be needed to keep "
+                          "table connected to a vector map") % column)
 
-    cols = [f[0] for f in grass.db_describe(table)['cols']]
+    cols = [f[0] for f in gscript.db_describe(table)['cols']]
     if column not in cols:
-	grass.fatal(_("Column <%s> not found in table") % column)
+        gscript.fatal(_("Column <%s> not found in table") % column)
 
     if not force:
-	grass.message(_("Column <%s> would be deleted.") % column)
-	grass.message("")
-	grass.message(_("You must use the force flag (-f) to actually remove it. Exiting."))
-	return 0
+        gscript.message(_("Column <%s> would be deleted.") % column)
+        gscript.message("")
+        gscript.message(_("You must use the force flag (-f) to actually "
+                          "remove it. Exiting."))
+        return 0
 
     if driver == "sqlite":
-	#echo "Using special trick for SQLite"
-	# http://www.sqlite.org/faq.html#q13
-	colnames = []
-	coltypes = []
-	for f in grass.db_describe(table)['cols']:
-	    if f[0] == column:
-		continue
-	    colnames.append(f[0])
-	    coltypes.append("%s %s" % (f[0], f[1]))
-
-	colnames = ", ".join(colnames)
-	coltypes = ", ".join(coltypes)
-
-	cmds = [
-	    "BEGIN TRANSACTION",
-	    "CREATE TEMPORARY TABLE ${table}_backup(${coldef})",
-	    "INSERT INTO ${table}_backup SELECT ${colnames} FROM ${table}",
-	    "DROP TABLE ${table}",
-	    "CREATE TABLE ${table}(${coldef})",
-	    "INSERT INTO ${table} SELECT ${colnames} FROM ${table}_backup",
-	    "DROP TABLE ${table}_backup",
-	    "COMMIT"
-	    ]
-	tmpl = string.Template(';\n'.join(cmds))
-	sql = tmpl.substitute(table = table, coldef = coltypes, colnames = colnames)
+        # echo "Using special trick for SQLite"
+        # http://www.sqlite.org/faq.html#q13
+        colnames = []
+        coltypes = []
+        for f in gscript.db_describe(table)['cols']:
+            if f[0] != column:
+                colnames.append(f[0])
+                coltypes.append("%s %s" % (f[0], f[1]))
+
+        colnames = ", ".join(colnames)
+        coltypes = ", ".join(coltypes)
+
+        cmds = [
+            "BEGIN TRANSACTION",
+            "CREATE TEMPORARY TABLE ${table}_backup(${coldef})",
+            "INSERT INTO ${table}_backup SELECT ${colnames} FROM ${table}",
+            "DROP TABLE ${table}",
+            "CREATE TABLE ${table}(${coldef})",
+            "INSERT INTO ${table} SELECT ${colnames} FROM ${table}_backup",
+            "DROP TABLE ${table}_backup",
+            "COMMIT"
+        ]
+        tmpl = string.Template(';\n'.join(cmds))
+        sql = tmpl.substitute(table=table, coldef=coltypes, colnames=colnames)
     else:
-	sql = "ALTER TABLE %s DROP COLUMN %s" % (table, column)
+        sql = "ALTER TABLE %s DROP COLUMN %s" % (table, column)
 
     try:
-        grass.write_command('db.execute', input = '-', database = database,
-                               driver = driver, stdin = sql)
+        gscript.write_command('db.execute', input='-', database=database,
+                              driver=driver, stdin=sql)
     except CalledModuleError:
-        grass.fatal(_("Cannot continue (problem deleting column)"))
+        gscript.fatal(_("Cannot continue (problem deleting column)"))
 
     return 0
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     sys.exit(main())

scripts/db.in.ogr/db.in.ogr.py

@@ -72,74 +72,76 @@ def main():
     mapset = grass.gisenv()['MAPSET']
 
     if db_table:
-	input = db_table
+        input = db_table
 
     if not output:
-	tmpname = input.replace('.', '_')
-	output = grass.basename(tmpname)
+        tmpname = input.replace('.', '_')
+        output = grass.basename(tmpname)
 
     # check if table exists
     try:
         nuldev = file(os.devnull, 'w+')
-        s = grass.read_command('db.tables', flags = 'p', quiet=True, stderr=nuldev)
+        s = grass.read_command('db.tables', flags='p', quiet=True, stderr=nuldev)
         nuldev.close()
     except CalledModuleError:
         # check connection parameters, set if uninitialized
         grass.read_command('db.connect', flags='c')
-        s = grass.read_command('db.tables', flags = 'p', quiet=True)
-    
+        s = grass.read_command('db.tables', flags='p', quiet=True)
+
     for l in s.splitlines():
         if l == output:
             if grass.overwrite():
-                grass.warning(_("Table <%s> already exists and will be overwritten") % output)
-                grass.write_command('db.execute', input = '-', stdin = "DROP TABLE %s" % output)
+                grass.warning(_("Table <%s> already exists and will be "
+                                "overwritten") % output)
+                grass.write_command('db.execute', input='-',
+                                    stdin="DROP TABLE %s" % output)
                 break
             else:
                 grass.fatal(_("Table <%s> already exists") % output)
-                
+
     # treat DB as real vector map...
-    if db_table:
-	layer = db_table
-    else:
-	layer = None
+    layer = db_table if db_table else None
 
     vopts = {}
     if options['encoding']:
         vopts['encoding'] = options['encoding']
-    
+
     try:
         grass.run_command('v.in.ogr', flags='o', input=input, output=output,
                           layer=layer, quiet=True, **vopts)
     except CalledModuleError:
         if db_table:
-            grass.fatal(_("Input table <%s> not found or not readable") % input)
+            grass.fatal(
+                _("Input table <%s> not found or not readable") %
+                input)
         else:
             grass.fatal(_("Input DSN <%s> not found or not readable") % input)
 
     # rename ID col if requested from cat to new name
     if key:
-	grass.write_command('db.execute', quiet = True,
-                          input = '-', 
-			  stdin = "ALTER TABLE %s ADD COLUMN %s integer" % (output, key) )
-	grass.write_command('db.execute', quiet = True,
-                          input = '-', 
-			  stdin = "UPDATE %s SET %s=cat" % (output, key) )
+        grass.write_command('db.execute', quiet=True, input='-',
+                            stdin="ALTER TABLE %s ADD COLUMN %s integer" %
+                                  (output, key))
+        grass.write_command('db.execute', quiet=True, input='-',
+                            stdin="UPDATE %s SET %s=cat" % (output, key))
 
     # ... and immediately drop the empty geometry
-    vectfile = grass.find_file(output, element = 'vector', mapset = mapset)['file']
+    vectfile = grass.find_file(output, element='vector', mapset=mapset)['file']
     if not vectfile:
-	grass.fatal(_("Something went wrong. Should not happen"))
+        grass.fatal(_("Something went wrong. Should not happen"))
     else:
-	# remove the vector part
-	grass.run_command('v.db.connect', quiet = True, map = output, layer = '1', flags = 'd')
-	grass.run_command('g.remove', flags = 'f', quiet = True, type = 'vector', name = output)
+        # remove the vector part
+        grass.run_command('v.db.connect', quiet=True, map=output, layer='1',
+                          flags='d')
+        grass.run_command('g.remove', flags='f', quiet=True, type='vector',
+                          name=output)
 
     # get rid of superfluous auto-added cat column (and cat_ if present)
     nuldev = file(os.devnull, 'w+')
-    grass.run_command('db.dropcolumn', quiet = True, flags = 'f', table = output,
-		      column = 'cat', stdout = nuldev, stderr = nuldev)
+    grass.run_command('db.dropcolumn', quiet=True, flags='f', table=output,
+                      column='cat', stdout=nuldev, stderr=nuldev)
     nuldev.close()
-    
+
     records = grass.db_describe(output)['nrows']
     grass.message(_("Imported table <%s> with %d rows") % (output, records))
 

scripts/db.out.ogr/db.out.ogr.py

@@ -54,10 +54,10 @@
 #% required: no
 #%end
 
-import sys
 import os
+
 from grass.script.utils import try_remove, basename
-from grass.script import core as grass
+from grass.script import core as gcore
 from grass.exceptions import CalledModuleError
 
 
@@ -69,54 +69,52 @@ def main():
     table = options['table']
 
     if format.lower() == 'dbf':
-	format = "ESRI_Shapefile"
+        format = "ESRI_Shapefile"
 
     if format.lower() == 'csv':
-	olayer = basename(output, 'csv')
+        olayer = basename(output, 'csv')
     else:
-	olayer = None
+        olayer = None
 
-    #is there a simpler way of testing for --overwrite?
+    # is there a simpler way of testing for --overwrite?
     dbffile = input + '.dbf'
-    if os.path.exists(dbffile) and not grass.overwrite():
-	grass.fatal(_("File <%s> already exists") % dbffile)
+    if os.path.exists(dbffile) and not gcore.overwrite():
+        gcore.fatal(_("File <%s> already exists") % dbffile)
 
     if olayer:
         try:
-            grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer,
-                              output=output,
-                              format=format, type='point,line,area',
-                              olayer=olayer)
+            gcore.run_command('v.out.ogr', quiet=True, input=input,
+                              layer=layer, output=output, format=format,
+                              type='point,line,area', olayer=olayer)
         except CalledModuleError:
-            grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
+            gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
 
     else:
         try:
-            grass.run_command('v.out.ogr', quiet=True, input=input,
+            gcore.run_command('v.out.ogr', quiet=True, input=input,
                               layer=layer, output=output,
                               format=format, type='point,line,area')
         except CalledModuleError:
-            grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
+            gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
 
     if format == "ESRI_Shapefile":
-	exts = ['shp', 'shx', 'prj']
-	if output.endswith('.dbf'):
-	    outname = basename(output, 'dbf')
-	    for ext in exts:
-		try_remove("%s.%s" % (outname, ext))
-	    outname += '.dbf'
-	else:
-	    for ext in exts:
-		try_remove(os.path.join(output, "%s.%s" % (input, ext)))
-	    outname = os.path.join(output, input + ".dbf")
+        exts = ['shp', 'shx', 'prj']
+        if output.endswith('.dbf'):
+            outname = basename(output, 'dbf')
+            for ext in exts:
+                try_remove("%s.%s" % (outname, ext))
+            outname += '.dbf'
+        else:
+            for ext in exts:
+                try_remove(os.path.join(output, "%s.%s" % (input, ext)))
+            outname = os.path.join(output, input + ".dbf")
     elif format.lower() == 'csv':
-	outname = output + '.csv'
+        outname = output + '.csv'
     else:
-	outname = input
+        outname = input
 
-    grass.message(_("Exported table <%s>") % outname)
+    gcore.message(_("Exported table <%s>") % outname)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     main()
-

scripts/db.test/db.test.py

@@ -28,61 +28,62 @@
 
 import sys
 import os
-from grass.script import core as grass
+
+from grass.script import core as gcore
 from grass.script import db as grassdb
 from grass.exceptions import CalledModuleError
 
+
 def main():
     test_file = options['test']
 
-    expected = grass.tempfile()
-    result = grass.tempfile()
+    expected = gcore.tempfile()
+    result = gcore.tempfile()
 
     dbconn = grassdb.db_connection()
-    grass.message(_("Using DB driver: %s") % dbconn['driver'])
+    gcore.message(_("Using DB driver: %s") % dbconn['driver'])
 
     infile = os.path.join(os.environ['GISBASE'], 'etc', 'db.test', test_file)
     inf = file(infile)
 
     while True:
-	type = inf.readline()
-	if not type:
-	    break
-	type = type.rstrip('\r\n')
-
-	sql = inf.readline().rstrip('\r\n')
-	sys.stdout.write(sql + '\n')
+        type = inf.readline()
+        if not type:
+            break
+        type = type.rstrip('\r\n')
 
-	# Copy expected result to temp file
+        sql = inf.readline().rstrip('\r\n')
+        sys.stdout.write(sql + '\n')
 
+        # Copy expected result to temp file
         try:
             if type == 'X':
-                grass.write_command('db.execute', input = '-', stdin = sql + '\n')
+                gcore.write_command('db.execute', input='-', stdin=sql + '\n')
             else:
                 resf = file(result, 'w')
-                grass.write_command('db.select', input = '-', flags = 'c', stdin = sql + '\n', stdout = resf)
+                gcore.write_command('db.select', input='-', flags='c',
+                                    stdin=sql + '\n', stdout=resf)
                 resf.close()
 
         except CalledModuleError:
-            grass.error("EXECUTE: ******** ERROR ********")
+            gcore.error("EXECUTE: ******** ERROR ********")
         else:
-            grass.message(_("EXECUTE: OK"))
+            gcore.message(_("EXECUTE: OK"))
 
-	expf = file(expected, 'w')
-	while True:
-	    res = inf.readline().rstrip('\r\n')
-	    if not res:
-		break
-	    expf.write(res + '\n')
-	expf.close()
+        expf = file(expected, 'w')
+        while True:
+            res = inf.readline().rstrip('\r\n')
+            if not res:
+                break
+            expf.write(res + '\n')
+        expf.close()
 
-	if type == 'S':
-	    if grass.call(['diff', result, expected]) != 0:
-		grass.error("RESULT: ******** ERROR ********")
-	    else:
-		grass.message(_("RESULT: OK"))
+        if type == 'S':
+            if gcore.call(['diff', result, expected]) != 0:
+                gcore.error("RESULT: ******** ERROR ********")
+            else:
+                gcore.message(_("RESULT: OK"))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     main()
-

scripts/db.univar/db.univar.py

@@ -56,25 +56,26 @@
 #%end
 
 import sys
-import os
 import atexit
 import math
 
-import grass.script as grass 
+import grass.script as gscript
+
 
 def cleanup():
     for ext in ['', '.sort']:
-        grass.try_remove(tmp + ext)
+        gscript.try_remove(tmp + ext)
+
 
 def sortfile(infile, outfile):
     inf = file(infile, 'r')
     outf = file(outfile, 'w')
 
-    if grass.find_program('sort', '--help'):
-        grass.run_command('sort', flags = 'n', stdin = inf, stdout = outf)
+    if gscript.find_program('sort', '--help'):
+        gscript.run_command('sort', flags='n', stdin=inf, stdout=outf)
     else:
         # FIXME: we need a large-file sorting function
-        grass.warning(_("'sort' not found: sorting in memory"))
+        gscript.warning(_("'sort' not found: sorting in memory"))
         lines = inf.readlines()
         for i in range(len(lines)):
             lines[i] = float(lines[i].rstrip('\r\n'))
@@ -85,9 +86,10 @@ def sortfile(infile, outfile):
     inf.close()
     outf.close()
 
+
 def main():
     global tmp
-    tmp = grass.tempfile()
+    tmp = gscript.tempfile()
 
     extend = flags['e']
     shellstyle = flags['g']
@@ -100,21 +102,22 @@ def main():
 
     perc = [float(p) for p in perc.split(',')]
 
-    desc_table = grass.db_describe(table, database=database, driver=driver)
+    desc_table = gscript.db_describe(table, database=database, driver=driver)
     if not desc_table:
-        grass.fatal(_("Unable to describe table <%s>") % table)
+        gscript.fatal(_("Unable to describe table <%s>") % table)
     found = False
     for cname, ctype, cwidth in desc_table['cols']:
         if cname == column:
             found = True
             if ctype not in ('INTEGER', 'DOUBLE PRECISION'):
-                grass.fatal(_("Column <%s> is not numeric") % cname)
+                gscript.fatal(_("Column <%s> is not numeric") % cname)
     if not found:
-        grass.fatal(_("Column <%s> not found in table <%s>") % (column, table))
+        gscript.fatal(_("Column <%s> not found in table <%s>") % (column, table))
 
     if not shellstyle:
-        grass.verbose(_("Calculation for column <%s> of table <%s>...") % (column, table))
-        grass.message(_("Reading column values..."))
+        gscript.verbose(_("Calculation for column <%s> of table <%s>..."
+                          ) % (column, table))
+        gscript.message(_("Reading column values..."))
 
     sql = "SELECT %s FROM %s" % (column, table)
     if where:
@@ -127,20 +130,20 @@ def main():
         driver = None
 
     tmpf = file(tmp, 'w')
-    grass.run_command('db.select', flags = 'c', table = table,
-        database = database, driver = driver, sql = sql,
-        stdout = tmpf)
+    gscript.run_command('db.select', flags='c', table=table,
+                        database=database, driver=driver, sql=sql,
+                        stdout=tmpf)
     tmpf.close()
 
     # check if result is empty
     tmpf = file(tmp)
     if tmpf.read(1) == '':
-        grass.fatal(_("Table <%s> contains no data.") % table)
+        gscript.fatal(_("Table <%s> contains no data.") % table)
         tmpf.close()
 
     # calculate statistics
     if not shellstyle:
-        grass.verbose(_("Calculating statistics..."))
+        gscript.verbose(_("Calculating statistics..."))
 
     N = 0
     sum = 0.0
@@ -151,8 +154,8 @@ def main():
 
     tmpf = file(tmp)
     for line in tmpf:
-	if len(line.rstrip('\r\n')) == 0:
-	    continue
+        if len(line.rstrip('\r\n')) == 0:
+            continue
         x = float(line.rstrip('\r\n'))
         N += 1
         sum += x
@@ -163,30 +166,43 @@ def main():
     tmpf.close()
 
     if N <= 0:
-        grass.fatal(_("No non-null values found"))
+        gscript.fatal(_("No non-null values found"))
 
     if not shellstyle:
-        sys.stdout.write("Number of values: %d\n"% N)
-        sys.stdout.write("Minimum: %.15g\n"% minv)
-        sys.stdout.write("Maximum: %.15g\n"% maxv)
-        sys.stdout.write("Range: %.15g\n"% (maxv - minv))
-        sys.stdout.write("Mean: %.15g\n"% (sum/N))
-        sys.stdout.write("Arithmetic mean of absolute values: %.15g\n"% (sum3/N))
-        sys.stdout.write("Variance: %.15g\n"% ((sum2 - sum*sum/N)/N))
-        sys.stdout.write("Standard deviation: %.15g\n"% (math.sqrt((sum2 - sum*sum/N)/N)))
-        sys.stdout.write("Coefficient of variation: %.15g\n"% ((math.sqrt((sum2 - sum*sum/N)/N))/(math.sqrt(sum*sum)/N)))
-        sys.stdout.write("Sum: %.15g\n"% sum)
+        sys.stdout.write("Number of values: %d\n" % N)
+        sys.stdout.write("Minimum: %.15g\n" % minv)
+        sys.stdout.write("Maximum: %.15g\n" % maxv)
+        sys.stdout.write("Range: %.15g\n" % (maxv - minv))
+        sys.stdout.write("Mean: %.15g\n" % (sum / N))
+        sys.stdout.write(
+            "Arithmetic mean of absolute values: %.15g\n" %
+            (sum3 / N))
+        sys.stdout.write("Variance: %.15g\n" % ((sum2 - sum * sum / N) / N))
+        sys.stdout.write(
+            "Standard deviation: %.15g\n" %
+            (math.sqrt((sum2 - sum * sum / N) / N)))
+        sys.stdout.write(
+            "Coefficient of variation: %.15g\n" %
+            ((math.sqrt((sum2 - sum * sum / N) / N)) /
+             (math.sqrt(sum * sum) / N)))
+        sys.stdout.write("Sum: %.15g\n" % sum)
     else:
-        sys.stdout.write("n=%d\n"% N)
-        sys.stdout.write("min=%.15g\n"% minv)
-        sys.stdout.write("max=%.15g\n"% maxv)
-        sys.stdout.write("range=%.15g\n"% (maxv - minv))
-        sys.stdout.write("mean=%.15g\n"% (sum/N))
-        sys.stdout.write("mean_abs=%.15g\n"% (sum3/N))
-        sys.stdout.write("variance=%.15g\n"% ((sum2 - sum*sum/N)/N))
-        sys.stdout.write("stddev=%.15g\n"% (math.sqrt((sum2 - sum*sum/N)/N)))
-        sys.stdout.write("coeff_var=%.15g\n"% ((math.sqrt((sum2 - sum*sum/N)/N))/(math.sqrt(sum*sum)/N)))
-        sys.stdout.write("sum=%.15g\n"% sum)
+        sys.stdout.write("n=%d\n" % N)
+        sys.stdout.write("min=%.15g\n" % minv)
+        sys.stdout.write("max=%.15g\n" % maxv)
+        sys.stdout.write("range=%.15g\n" % (maxv - minv))
+        sys.stdout.write("mean=%.15g\n" % (sum / N))
+        sys.stdout.write("mean_abs=%.15g\n" % (sum3 / N))
+        sys.stdout.write("variance=%.15g\n" % ((sum2 - sum * sum / N) / N))
+        sys.stdout.write(
+            "stddev=%.15g\n" %
+            (math.sqrt(
+                (sum2 - sum * sum / N) / N)))
+        sys.stdout.write(
+            "coeff_var=%.15g\n" %
+            ((math.sqrt((sum2 - sum * sum / N) / N)) /
+             (math.sqrt(sum * sum) / N)))
+        sys.stdout.write("sum=%.15g\n" % sum)
 
     if not extend:
         return
@@ -194,27 +210,26 @@ def main():
     # preparations:
     sortfile(tmp, tmp + ".sort")
 
-    number = N
     odd = N % 2
-    eostr = ['even','odd'][odd]
+    eostr = ['even', 'odd'][odd]
 
     q25pos = round(N * 0.25)
     if q25pos == 0:
-	q25pos = 1
+        q25pos = 1
     q50apos = round(N * 0.50)
     if q50apos == 0:
-	q50apos = 1
+        q50apos = 1
     q50bpos = q50apos + (1 - odd)
     q75pos = round(N * 0.75)
     if q75pos == 0:
-	q75pos = 1
+        q75pos = 1
 
     ppos = {}
     pval = {}
     for i in range(len(perc)):
         ppos[i] = round(N * perc[i] / 100)
-	if ppos[i] == 0:
-	    ppos[i] = 1
+        if ppos[i] == 0:
+            ppos[i] = 1
         pval[i] = 0
 
     inf = file(tmp + ".sort")
@@ -240,27 +255,45 @@ def main():
         sys.stdout.write("Median (%s N): %.15g\n" % (eostr, q50))
         sys.stdout.write("3rd Quartile: %.15g\n" % q75)
         for i in range(len(perc)):
-            if perc[i] == int(perc[i]): # integer
+            if perc[i] == int(perc[i]):  # integer
                 if int(perc[i]) % 10 == 1 and int(perc[i]) != 11:
-                    sys.stdout.write("%dst Percentile: %.15g\n"% (int(perc[i]), pval[i]))
+                    sys.stdout.write(
+                        "%dst Percentile: %.15g\n" %
+                        (int(
+                            perc[i]),
+                            pval[i]))
                 elif int(perc[i]) % 10 == 2 and int(perc[i]) != 12:
-                    sys.stdout.write("%dnd Percentile: %.15g\n"% (int(perc[i]), pval[i]))
+                    sys.stdout.write(
+                        "%dnd Percentile: %.15g\n" %
+                        (int(
+                            perc[i]),
+                            pval[i]))
                 elif int(perc[i]) % 10 == 3 and int(perc[i]) != 13:
-                    sys.stdout.write("%drd Percentile: %.15g\n"% (int(perc[i]), pval[i]))
+                    sys.stdout.write(
+                        "%drd Percentile: %.15g\n" %
+                        (int(
+                            perc[i]),
+                            pval[i]))
                 else:
-                    sys.stdout.write("%dth Percentile: %.15g\n"% (int(perc[i]), pval[i]))
+                    sys.stdout.write(
+                        "%dth Percentile: %.15g\n" %
+                        (int(
+                            perc[i]),
+                            pval[i]))
             else:
-                sys.stdout.write("%.15g Percentile: %.15g\n"% (perc[i], pval[i]))
+                sys.stdout.write(
+                    "%.15g Percentile: %.15g\n" %
+                    (perc[i], pval[i]))
     else:
-        sys.stdout.write("first_quartile=%.15g\n"% q25)
-        sys.stdout.write("median=%.15g\n"% q50)
-        sys.stdout.write("third_quartile=%.15g\n"% q75)
+        sys.stdout.write("first_quartile=%.15g\n" % q25)
+        sys.stdout.write("median=%.15g\n" % q50)
+        sys.stdout.write("third_quartile=%.15g\n" % q75)
         for i in range(len(perc)):
             percstr = "%.15g" % perc[i]
-            percstr = percstr.replace('.','_')
-            sys.stdout.write("percentile_%s=%.15g\n"% (percstr, pval[i]))
+            percstr = percstr.replace('.', '_')
+            sys.stdout.write("percentile_%s=%.15g\n" % (percstr, pval[i]))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     atexit.register(cleanup)
     main()

scripts/g.extension.all/g.extension.all.py

@@ -6,7 +6,7 @@
 #
 # AUTHOR(S):    Martin Landa <landa.martin gmail.com>
 #
-# PURPOSE:      Rebuilds or removes locally installed GRASS Addons extensions 
+# PURPOSE:      Rebuilds or removes locally installed GRASS Addons extensions
 #
 # COPYRIGHT:    (C) 2011-2013 by Martin Landa, and the GRASS Development Team
 #
@@ -35,23 +35,23 @@
 #% key: f
 #% label: Force operation (required for removal)
 #% end
-
+from __future__ import print_function
 import os
 import sys
 
 try:
     import xml.etree.ElementTree as etree
 except ImportError:
-    import elementtree.ElementTree as etree # Python <= 2.4
+    import elementtree.ElementTree as etree  # Python <= 2.4
 
-import grass.script as grass
+import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
 
 def get_extensions():
     addon_base = os.getenv('GRASS_ADDON_BASE')
     if not addon_base:
-        grass.fatal(_("%s not defined") % "GRASS_ADDON_BASE")
+        gscript.fatal(_("%s not defined") % "GRASS_ADDON_BASE")
     fXML = os.path.join(addon_base, 'modules.xml')
     if not os.path.exists(fXML):
         return []
@@ -60,51 +60,56 @@ def get_extensions():
     fo = open(fXML, 'r')
     try:
         tree = etree.fromstring(fo.read())
-    except StandardError as e:
-        grass.error(_("Unable to parse metadata file: %s") % e)
+    except Exception as e:
+        gscript.error(_("Unable to parse metadata file: %s") % e)
         fo.close()
         return []
-    
+
     fo.close()
-    
-    libgis_rev = grass.version()['libgis_revision']
+
+    libgis_rev = gscript.version()['libgis_revision']
     ret = list()
     for tnode in tree.findall('task'):
         gnode = tnode.find('libgis')
         if gnode is not None and \
                 gnode.get('revision', '') != libgis_rev:
             ret.append(tnode.get('name'))
-    
+
     return ret
 
+
 def main():
     remove = options['operation'] == 'remove'
     if remove or flags['f']:
-        extensions = grass.read_command('g.extension',
-                                        quiet = True, flags = 'a').splitlines()
+        extensions = gscript.read_command(
+            'g.extension',
+            quiet=True,
+            flags='a').splitlines()
     else:
         extensions = get_extensions()
-    
+
     if not extensions:
         if remove:
-            grass.info(_("No extension found. Nothing to remove."))
+            gscript.info(_("No extension found. Nothing to remove."))
         else:
-            grass.info(_("Nothing to rebuild. Rebuilding process can be forced with -f flag."))
+            gscript.info(
+                _("Nothing to rebuild. Rebuilding process can be forced with -f flag."))
         return 0
-    
+
     if remove and not flags['f']:
-        grass.message(_("List of extensions to be removed:"))
-        print os.linesep.join(extensions)
-        grass.message(_("You must use the force flag (-f) to actually remove them. Exiting."))
+        gscript.message(_("List of extensions to be removed:"))
+        print(os.linesep.join(extensions))
+        gscript.message(
+            _("You must use the force flag (-f) to actually remove them. Exiting."))
         return 0
-    
+
     for ext in extensions:
-        grass.message('-' * 60)
+        gscript.message('-' * 60)
         if remove:
-            grass.message(_("Removing extension <%s>...") % ext)
+            gscript.message(_("Removing extension <%s>...") % ext)
         else:
-            grass.message(_("Reinstalling extension <%s>...") % ext)
-        grass.message('-' * 60)
+            gscript.message(_("Reinstalling extension <%s>...") % ext)
+        gscript.message('-' * 60)
         if remove:
             operation = 'remove'
             operation_flags = 'f'
@@ -112,13 +117,13 @@ def main():
             operation = 'add'
             operation_flags = ''
         try:
-            grass.run_command('g.extension', flags=operation_flags,
-                              extension=ext, operation=operation)
+            gscript.run_command('g.extension', flags=operation_flags,
+                                extension=ext, operation=operation)
         except CalledModuleError:
-            grass.error(_("Unable to process extension:%s") % ext)
+            gscript.error(_("Unable to process extension:%s") % ext)
 
     return 0
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     sys.exit(main())

scripts/g.extension/g.extension.py

@@ -314,7 +314,7 @@ def get_installed_modules(force=False):
             ))
         else:
             ret.append(tnode.get('name').strip())
-    
+
     return ret
 
 # list extensions (read XML file from grass.osgeo.org/addons)
@@ -391,6 +391,7 @@ def get_toolbox_modules(url, name):
 
     return tlist
 
+
 def get_module_files(mnode):
     """Return list of module files
 
@@ -403,6 +404,7 @@ def get_module_files(mnode):
 
     return flist
 
+
 def get_module_executables(mnode):
     """Return list of module executables
 
@@ -411,15 +413,16 @@ def get_module_executables(mnode):
     flist = []
     for filepath in get_module_files(mnode):
         if filepath.startswith(options['prefix'] + os.path.sep + 'bin') or \
-           (sys.platform != 'win32' and \
-            filepath.startswith(options['prefix'] + os.path.sep + 'scripts')):
+           (sys.platform != 'win32' and
+                filepath.startswith(options['prefix'] + os.path.sep + 'scripts')):
             filename = os.path.basename(filepath)
             if sys.platform == 'win32':
                 filename = os.path.splitext(filename)[0]
             flist.append(filename)
-    
+
     return flist
 
+
 def get_optional_params(mnode):
     """Return description and keywords as a tuple
 
@@ -920,7 +923,7 @@ def install_extension_win(name):
     """Install extension on MS Windows"""
     grass.message(_("Downloading precompiled GRASS Addons <%s>...") %
                   options['extension'])
-    
+
     # build base URL
     if build_platform == 'x86_64':
         platform = build_platform
@@ -929,29 +932,29 @@ def install_extension_win(name):
     base_url = "http://wingrass.fsv.cvut.cz/" \
                "grass%(major)s%(minor)s/%(platform)s/addons/" \
                "grass-%(major)s.%(minor)s.%(patch)s" % \
-               {'platform' : platform,
+               {'platform': platform,
                 'major': version[0], 'minor': version[1],
                 'patch': version[2]}
 
     # resolve ZIP URL
     source, url = resolve_source_code(url='{}/{}.zip'.format(base_url, name))
-    
+
     # to hide non-error messages from subprocesses
     if grass.verbosity() <= 2:
         outdev = open(os.devnull, 'w')
     else:
         outdev = sys.stdout
-    
+
     # download Addons ZIP file
     os.chdir(TMPDIR)  # this is just to not leave something behind
     srcdir = os.path.join(TMPDIR, name)
     download_source_code(source=source, url=url, name=name,
-                        outdev=outdev, directory=srcdir, tmpdir=TMPDIR)
-    
+                         outdev=outdev, directory=srcdir, tmpdir=TMPDIR)
+
     # copy Addons copy tree to destination directory
     move_extracted_files(extract_dir=srcdir, target_dir=options['prefix'],
                          files=os.listdir(srcdir))
-    
+
     return 0
 
 
@@ -1090,7 +1093,7 @@ def download_source_code(source, url, name, outdev,
         f, h = urlretrieve(url, zip_name)
         if h.get('content-type', '') != 'application/zip':
             grass.fatal(_("Extension <%s> not found") % name)
-            
+
         extract_zip(name=zip_name, directory=directory, tmpdir=tmpdir)
         fix_newlines(directory)
     elif source.startswith('remote_') and \
@@ -1718,9 +1721,9 @@ if __name__ == "__main__":
     global TMPDIR
     TMPDIR = tempfile.mkdtemp()
     atexit.register(cleanup)
-    
+
     grass_version = grass.version()
     version = grass_version['version'].split('.')
     build_platform = grass_version['build_platform'].split('-', 1)[0]
-    
+
     sys.exit(main())

scripts/g.extension/testsuite/test_addons_modules.py

@@ -99,7 +99,7 @@ class TestModulesFromDifferentSources(TestCase):
         """Test installing extension from local .tar.gz"""
         self.assertModule('g.extension', extension='r.plus.example',
                           url=os.path.join(self.path,
-                                              'r.plus.example.tar.gz'),
+                                           'r.plus.example.tar.gz'),
                           prefix=self.install_prefix)
         for file in self.files:
             self.assertFileExists(file)

scripts/g.manual/g.manual.py

@@ -60,6 +60,7 @@ import webbrowser
 from grass.script.utils import basename
 from grass.script import core as grass
 
+
 def start_browser(entry):
     if browser and \
        browser not in ('xdg-open', 'start') and \
@@ -86,7 +87,7 @@ def start_browser(entry):
         webbrowser.register(browser_name, None)
 
     grass.verbose(_("Starting browser '%(browser)s' for manual"
-                    " entry '%(entry)s'...") % \
+                    " entry '%(entry)s'...") %
                   dict(browser=browser_name, entry=entry))
 
     try:
@@ -95,6 +96,7 @@ def start_browser(entry):
         grass.fatal(_("Error starting browser '%(browser)s' for HTML file"
                       " '%(path)s'") % dict(browser=browser, path=path))
 
+
 def start_man(entry):
     path = os.path.join(gisbase, 'docs', 'man', 'man1', entry + '.1')
     if not os.path.exists(path) and os.getenv('GRASS_ADDON_BASE'):
@@ -106,6 +108,7 @@ def start_man(entry):
             grass.fatal(_("Error starting 'man' for '%s'") % path)
     grass.fatal(_("No manual page entry for '%s'") % entry)
 
+
 def main():
     global gisbase, browser, browser_name
 
@@ -115,7 +118,7 @@ def main():
     special = None
     if flags['i']:
         special = 'index'
-    elif flags ['t']:
+    elif flags['t']:
         special = 'topics'
 
     if flags['m']:
@@ -123,7 +126,7 @@ def main():
     else:
         start = start_browser
 
-    entry  = options['entry']
+    entry = options['entry']
     gisbase = os.environ['GISBASE']
     browser = os.getenv('GRASS_HTML_BROWSER', '')
 

scripts/g.search.modules/g.search.modules.py

@@ -50,7 +50,7 @@
 #% description: JSON format
 #% guisection: Output
 #%end
-
+from __future__ import print_function
 import os
 import sys
 
@@ -58,11 +58,12 @@ from grass.script.utils import diff_files, try_rmdir
 from grass.script import core as grass
 
 try:
-    import xml.etree.ElementTree   as etree
+    import xml.etree.ElementTree as etree
 except ImportError:
-    import elementtree.ElementTree as etree # Python <= 2.4
+    import elementtree.ElementTree as etree  # Python <= 2.4
+
+COLORIZE = False
 
-COLORIZE=False
 
 def main():
     global COLORIZE
@@ -79,7 +80,8 @@ def main():
 
     modules = _search_module(keywords, AND, manpages)
 
-    print_results(modules, out_format) 
+    print_results(modules, out_format)
+
 
 def print_results(data, out_format=None):
     """
@@ -107,30 +109,34 @@ def print_results(data, out_format=None):
     elif out_format == 'json':
         _print_results_json(data)
 
+
 def _print_results_shell(data):
     """Print just the name attribute"""
 
     for item in data:
-        print item['name']
+        print(item['name'])
+
 
 def _print_results_json(data):
     """Print JSON output"""
 
     import json
-    print json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))
+    print(json.dumps(data, sort_keys=True, indent=4, separators=(',', ': ')))
+
 
 def _print_results(data):
 
     import textwrap
 
     for item in data:
-        print '\n{}'.format(colorize(item['name'], attrs=['bold']))
+        print('\n{}'.format(colorize(item['name'], attrs=['bold'])))
         for attr in item['attributes']:
             out = '{}: {}'.format(attr, item['attributes'][attr])
-            out = textwrap.wrap(out, width=79, initial_indent=4*' ',
-                    subsequent_indent=4*' '+len(attr)*' '+'  ')
+            out = textwrap.wrap(out, width=79, initial_indent=4 * ' ',
+                                subsequent_indent=4 * ' ' + len(attr) * ' ' + '  ')
             for line in out:
-                print line
+                print(line)
+
 
 def colorize(text, attrs=None, pattern=None):
     """Colorize given text input
@@ -140,7 +146,6 @@ def colorize(text, attrs=None, pattern=None):
     :param string pattern: text to be highlighted in input text
     :return: colored string
     """
-    
 
     if COLORIZE:
         try:
@@ -156,6 +161,7 @@ def colorize(text, attrs=None, pattern=None):
     else:
         return colored(text, attrs=attrs)
 
+
 def _search_module(keywords, logical_and=False, manpages=False):
     """Search modules by given keywords
 
@@ -200,11 +206,11 @@ def _search_module(keywords, logical_and=False, manpages=False):
                     found = [True]
 
                 description = colorize(description,
-                                        attrs=['underline'],
-                                        pattern=keyword)
+                                       attrs=['underline'],
+                                       pattern=keyword)
                 module_keywords = colorize(module_keywords,
-                                            attrs=['underline'],
-                                            pattern=keyword)
+                                           attrs=['underline'],
+                                           pattern=keyword)
 
         if False not in found:
             found_modules.append({
@@ -217,8 +223,9 @@ def _search_module(keywords, logical_and=False, manpages=False):
 
     return found_modules
 
+
 def _basic_search(pattern, name, description, module_keywords):
-    
+
     if name.lower().find(pattern) > -1 or\
        description.lower().find(pattern) > -1 or\
        module_keywords.lower().find(pattern) > -1:
@@ -227,6 +234,7 @@ def _basic_search(pattern, name, description, module_keywords):
     else:
         return False
 
+
 def _manpage_search(pattern, name):
 
     manpage = grass.read_command('g.manual', flags='m', entry=name)

scripts/g.search.modules/testsuite/test_g_search_modules.py

@@ -52,7 +52,7 @@ class TestSearchModule(TestCase):
         stdout = module.outputs.stdout.split()
         self.assertEqual(stdout[0],
                          termcolor.colored('r.watershed',
-                         attrs=['bold']))
+                                           attrs=['bold']))
 
     def test_manual_pages(self):
         module = SimpleModule('g.search.modules', keyword="kapri", flags="gm")

scripts/i.colors.enhance/i.colors.enhance.py

@@ -8,7 +8,7 @@
 #		Hamish Bowman, scripting enhancements
 #               Converted to Python by Glynn Clements
 #
-# PURPOSE:      create pretty RGBs: the trick is to remove outliers 
+# PURPOSE:      create pretty RGBs: the trick is to remove outliers
 #               using percentiles (area under the histogram curve)
 #
 # COPYRIGHT:	(C) 2006, 2008, 2012-2014 by the GRASS Development Team
@@ -68,9 +68,9 @@
 #%end
 
 import sys
-import os
-import string
-import grass.script as grass
+
+import grass.script as gscript
+
 try:
     # new for python 2.6, in 2.5 it may be easy_install'd.
     import multiprocessing as mp
@@ -85,14 +85,16 @@ def get_percentile(map, percentiles):
     val2 = percentiles[1]
     values = '%s,%s' % (val1, val2)
 
-    s = grass.read_command('r.quantile', input = map, 
-                           percentiles = values, quiet = True)
+    s = gscript.read_command('r.quantile', input=map,
+                             percentiles=values, quiet=True)
 
     val_str1 = s.splitlines()[0].split(':')[2]
     val_str2 = s.splitlines()[1].split(':')[2]
     return (float(val_str1), float(val_str2))
 
 # wrapper to handle multiprocesses communications back to the parent
+
+
 def get_percentile_mp(map, percentiles, conn):
     # Process() doesn't like storing connection parts in
     #  separate dictionaries, only wants to pass through tuples,
@@ -101,19 +103,16 @@ def get_percentile_mp(map, percentiles, conn):
     output_pipe, input_pipe = conn
     input_pipe.close()
     result = get_percentile(map, percentiles)
-    grass.debug('child (%s) (%.1f, %.1f)' % (map, result[0], result[1]))
+    gscript.debug('child (%s) (%.1f, %.1f)' % (map, result[0], result[1]))
     output_pipe.send(result)
     output_pipe.close()
 
+
 def set_colors(map, v0, v1):
-    rules = [
-	"0% black\n",
-	"%f black\n" % v0,
-	"%f white\n" % v1,
-	"100% white\n"
-	]
-    rules = ''.join(rules)
-    grass.write_command('r.colors', map = map, rules = '-', stdin = rules, quiet = True)
+    rules = ''.join(["0% black\n", "%f black\n" % v0,
+                     "%f white\n" % v1, "100% white\n"])
+    gscript.write_command('r.colors', map=map, rules='-', stdin=rules,
+                          quiet=True)
 
 
 def main():
@@ -124,7 +123,7 @@ def main():
     full = flags['f']
     preserve = flags['p']
     reset = flags['r']
-    
+
     global do_mp
 
     if flags['s']:
@@ -135,92 +134,90 @@ def main():
     # must be more than "2" ?
 
     if full:
-	for i in [red, green, blue]:
-	    grass.run_command('r.colors', map = i, color = 'grey', quiet = True)
-	sys.exit(0)
+        for i in [red, green, blue]:
+            gscript.run_command('r.colors', map=i, color='grey', quiet=True)
+        sys.exit(0)
 
     if reset:
-	for i in [red, green, blue]:
-	    grass.run_command('r.colors', map = i, color = 'grey255', quiet = True)
-	sys.exit(0)
-
+        for i in [red, green, blue]:
+            gscript.run_command('r.colors', map=i, color='grey255', quiet=True)
+        sys.exit(0)
 
     if not preserve:
         if do_mp:
-            grass.message(_("Processing..."))
-	    # set up jobs and launch them
-	    proc = {}
-	    conn = {}
-	    for i in [red, green, blue]:
-	        conn[i] = mp.Pipe()
-	        proc[i] = mp.Process(target = get_percentile_mp,
-				     args = (i, ['2', brightness],
-				     conn[i],))
-		proc[i].start()
-            grass.percent(1, 2, 1)
-            
-	    # collect results and wait for jobs to finish
-	    for i in [red, green, blue]:
-		output_pipe, input_pipe = conn[i]
-		(v0, v1) = input_pipe.recv()
-		grass.debug('parent (%s) (%.1f, %.1f)' % (i, v0, v1))
-		input_pipe.close()
-		proc[i].join()
-		set_colors(i, v0, v1)
-            grass.percent(1, 1, 1)
-	else:
-	    for i in [red, green, blue]:
-	        grass.message(_("Processing..."))
-	        (v0, v1) = get_percentile(i, ['2', brightness])
-	        grass.debug("<%s>:  min=%f   max=%f" % (i, v0, v1))
-	        set_colors(i, v0, v1)
+            gscript.message(_("Processing..."))
+            # set up jobs and launch them
+            proc = {}
+            conn = {}
+            for i in [red, green, blue]:
+                conn[i] = mp.Pipe()
+                proc[i] = mp.Process(target=get_percentile_mp,
+                                     args=(i, ['2', brightness],
+                                           conn[i],))
+                proc[i].start()
+            gscript.percent(1, 2, 1)
+
+            # collect results and wait for jobs to finish
+            for i in [red, green, blue]:
+                output_pipe, input_pipe = conn[i]
+                (v0, v1) = input_pipe.recv()
+                gscript.debug('parent (%s) (%.1f, %.1f)' % (i, v0, v1))
+                input_pipe.close()
+                proc[i].join()
+                set_colors(i, v0, v1)
+            gscript.percent(1, 1, 1)
+        else:
+            for i in [red, green, blue]:
+                gscript.message(_("Processing..."))
+                (v0, v1) = get_percentile(i, ['2', brightness])
+                gscript.debug("<%s>:  min=%f   max=%f" % (i, v0, v1))
+                set_colors(i, v0, v1)
 
     else:
-	all_max = 0
-	all_min = 999999
-
-	if do_mp:
-	    grass.message(_("Processing..."))
-	    # set up jobs and launch jobs
-	    proc = {}
-	    conn = {}
-	    for i in [red, green, blue]:
-		conn[i] = mp.Pipe()
-		proc[i] = mp.Process(target = get_percentile_mp,
-				     args = (i, ['2', brightness],
-				     conn[i],))
-		proc[i].start()
-            grass.percent(1, 2, 1)
-            
-	    # collect results and wait for jobs to finish
-	    for i in [red, green, blue]:
-		output_pipe, input_pipe = conn[i]
-		(v0, v1) = input_pipe.recv()
-		grass.debug('parent (%s) (%.1f, %.1f)' % (i, v0, v1))
-		input_pipe.close()
-		proc[i].join()
-		all_min = min(all_min, v0)
-		all_max = max(all_max, v1)
-            grass.percent(1, 1, 1)
-	else:
-	    for i in [red, green, blue]:
-		grass.message(_("Processing..."))
-		(v0, v1) = get_percentile(i, ['2', brightness])
-		grass.debug("<%s>:  min=%f   max=%f" % (i, v0, v1))
-		all_min = min(all_min, v0)
-		all_max = max(all_max, v1)
-
-	grass.debug("all_min=%f   all_max=%f" % (all_min, all_max))
-	for i in [red, green, blue]:
-	    set_colors(i, all_min, all_max)
+        all_max = 0
+        all_min = 999999
 
+        if do_mp:
+            gscript.message(_("Processing..."))
+            # set up jobs and launch jobs
+            proc = {}
+            conn = {}
+            for i in [red, green, blue]:
+                conn[i] = mp.Pipe()
+                proc[i] = mp.Process(target=get_percentile_mp,
+                                     args=(i, ['2', brightness],
+                                           conn[i],))
+                proc[i].start()
+            gscript.percent(1, 2, 1)
+
+            # collect results and wait for jobs to finish
+            for i in [red, green, blue]:
+                output_pipe, input_pipe = conn[i]
+                (v0, v1) = input_pipe.recv()
+                gscript.debug('parent (%s) (%.1f, %.1f)' % (i, v0, v1))
+                input_pipe.close()
+                proc[i].join()
+                all_min = min(all_min, v0)
+                all_max = max(all_max, v1)
+            gscript.percent(1, 1, 1)
+        else:
+            for i in [red, green, blue]:
+                gscript.message(_("Processing..."))
+                (v0, v1) = get_percentile(i, ['2', brightness])
+                gscript.debug("<%s>:  min=%f   max=%f" % (i, v0, v1))
+                all_min = min(all_min, v0)
+                all_max = max(all_max, v1)
+
+        gscript.debug("all_min=%f   all_max=%f" % (all_min, all_max))
+        for i in [red, green, blue]:
+            set_colors(i, all_min, all_max)
 
     # write cmd history:
-    mapset = grass.gisenv()['MAPSET']
+    mapset = gscript.gisenv()['MAPSET']
     for i in [red, green, blue]:
-        if grass.find_file(i)['mapset'] == mapset:
-            grass.raster_history(i)
+        if gscript.find_file(i)['mapset'] == mapset:
+            gscript.raster_history(i)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/i.image.mosaic/i.image.mosaic.py

@@ -32,67 +32,70 @@
 #%end
 #%option G_OPT_R_OUTPUT
 #%end
+from __future__ import print_function
+
+import grass.script as gscript
 
-import sys
-import os
-import grass.script as grass
 
 def copy_colors(fh, map, offset):
-    p = grass.pipe_command('r.colors.out', map = map)
+    p = gscript.pipe_command('r.colors.out', map=map)
     for line in p.stdout:
-	f = line.rstrip('\r\n').split(' ')
-	if offset:
-	    if f[0] in ['nv', 'default']:
-		continue
-	    f[0] = str(float(f[0]) + offset)
-	fh.write(' '.join(f) + '\n')
+        f = line.rstrip('\r\n').split(' ')
+        if offset:
+            if f[0] in ['nv', 'default']:
+                continue
+            f[0] = str(float(f[0]) + offset)
+        fh.write(' '.join(f) + '\n')
     p.wait()
 
+
 def get_limit(map):
-    return grass.raster_info(map)['max']
+    return gscript.raster_info(map)['max']
+
 
 def make_expression(i, count):
     if i > count:
-	return "null()"
+        return "null()"
     else:
-	e = make_expression(i + 1, count)
-	return "if(isnull($image%d),%s,$image%d+$offset%d)" % (i, e, i, i)
+        e = make_expression(i + 1, count)
+        return "if(isnull($image%d),%s,$image%d+$offset%d)" % (i, e, i, i)
+
 
 def main():
     images = options['input'].split(',')
     output = options['output']
 
     count = len(images)
-
-    grass.warning(_('Do not forget to set region properly to cover all images.'))
+    msg = _('Do not forget to set region properly to cover all images.')
+    gscript.warning(msg)
 
     offset = 0
     offsets = []
     parms = {}
     for n, img in enumerate(images):
-	offsets.append(offset)
-	parms['image%d' % (n + 1)] = img
-	parms['offset%d' % (n + 1)] = offset
-	offset += get_limit(img) + 1
+        offsets.append(offset)
+        parms['image%d' % (n + 1)] = img
+        parms['offset%d' % (n + 1)] = offset
+        offset += get_limit(img) + 1
 
-    grass.message(_("Mosaicing %d images...") % count)
+    gscript.message(_("Mosaicing %d images...") % count)
 
-    grass.mapcalc("$output = " + make_expression(1, count),
-		  output = output, **parms)
+    gscript.mapcalc("$output = " + make_expression(1, count),
+                    output=output, **parms)
 
-    #modify the color table:
-    p = grass.feed_command('r.colors', map = output, rules='-')
+    # modify the color table:
+    p = gscript.feed_command('r.colors', map=output, rules='-')
     for img, offset in zip(images, offsets):
-	print img, offset
-	copy_colors(p.stdin, img, offset)
+        print(img, offset)
+        copy_colors(p.stdin, img, offset)
     p.stdin.close()
     p.wait()
 
-    grass.message(_("Done. Raster map <%s> created.") % output)
+    gscript.message(_("Done. Raster map <%s> created.") % output)
 
     # write cmd history:
-    grass.raster_history(output)
+    gscript.raster_history(output)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/i.in.spotvgt/i.in.spotvgt.py

@@ -23,7 +23,7 @@
 #      -  gdal: http://www.gdal.org
 #
 # Notes:
-# * According to the faq (http://www.vgt.vito.be/faq/faq.html), SPOT vegetation 
+# * According to the faq (http://www.vgt.vito.be/faq/faq.html), SPOT vegetation
 #   coordinates refer to the center of a pixel.
 # * GDAL coordinates refer to the corner of a pixel
 #   -> correction of 0001/0001_LOG.TXT coordinates by 0.5 pixel
@@ -48,7 +48,7 @@
 import os
 import atexit
 import string
-import grass.script as grass
+import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
 
@@ -67,103 +67,109 @@ vrt = """<VRTDataset rasterXSize="$XSIZE" rasterYSize="$YSIZE">
  </VRTRasterBand>
 </VRTDataset>"""
 
-#### a function for writing VRT files
+# a function for writing VRT files
+
+
 def create_VRT_file(projfile, vrtfile, infile):
     fh = file(projfile)
     kv = {}
     for l in fh:
-	f = l.rstrip('\r\n').split()
-	if f < 2:
-	    continue
-	kv[f[0]] = f[1]
+        f = l.rstrip('\r\n').split()
+        if f < 2:
+            continue
+        kv[f[0]] = f[1]
     fh.close()
 
     north_center = kv['CARTO_UPPER_LEFT_Y']
-    south_center = kv['CARTO_LOWER_LEFT_Y']
-    east_center  = kv['CARTO_UPPER_RIGHT_X']
-    west_center  = kv['CARTO_UPPER_LEFT_X']
+    # south_center = kv['CARTO_LOWER_LEFT_Y']
+    # east_center = kv['CARTO_UPPER_RIGHT_X']
+    west_center = kv['CARTO_UPPER_LEFT_X']
     map_proj_res = kv['MAP_PROJ_RESOLUTION']
-    xsize        = kv['IMAGE_UPPER_RIGHT_COL']
-    ysize        = kv['IMAGE_LOWER_RIGHT_ROW']
+    xsize = kv['IMAGE_UPPER_RIGHT_COL']
+    ysize = kv['IMAGE_LOWER_RIGHT_ROW']
 
-    resolution   = float(map_proj_res)
+    resolution = float(map_proj_res)
     north_corner = float(north_center) + resolution / 2
-    south_corner = float(south_center) - resolution / 2
-    east_corner  = float(east_center ) + resolution / 2
-    west_corner  = float(west_center ) - resolution / 2
+    # south_corner = float(south_center) - resolution / 2
+    # east_corner = float(east_center) + resolution / 2
+    west_corner = float(west_center) - resolution / 2
 
     t = string.Template(vrt)
-    s = t.substitute(NORTHCORNER = north_corner, WESTCORNER = west_corner,
-		     XSIZE = xsize, YSIZE = ysize, RESOLUTION = map_proj_res,
-		     FILENAME = infile)
+    s = t.substitute(NORTHCORNER=north_corner, WESTCORNER=west_corner,
+                     XSIZE=xsize, YSIZE=ysize, RESOLUTION=map_proj_res,
+                     FILENAME=infile)
     outf = file(vrtfile, 'w')
     outf.write(s)
     outf.close()
 
+
 def cleanup():
-   #### clean up the mess
-   grass.try_remove(vrtfile)
-   grass.try_remove(tmpfile)
+    # clean up the mess
+    gscript.try_remove(vrtfile)
+    gscript.try_remove(tmpfile)
+
 
 def main():
     global vrtfile, tmpfile
 
-    infile  = options['input']
+    infile = options['input']
     rast = options['output']
     also = flags['a']
 
-    #### check for gdalinfo (just to check if installation is complete)
-    if not grass.find_program('gdalinfo', '--help'):
-	grass.fatal(_("'gdalinfo' not found, install GDAL tools first (http://www.gdal.org)"))
+    # check for gdalinfo (just to check if installation is complete)
+    if not gscript.find_program('gdalinfo', '--help'):
+        gscript.fatal(_("'gdalinfo' not found, install GDAL tools first "
+                        "(http://www.gdal.org)"))
 
     pid = str(os.getpid())
-    tmpfile = grass.tempfile()
+    tmpfile = gscript.tempfile()
 
-    ################### let's go
+    # let's go
 
     spotdir = os.path.dirname(infile)
-    spotname = grass.basename(infile, 'hdf')
+    spotname = gscript.basename(infile, 'hdf')
 
     if rast:
-	name = rast
+        name = rast
     else:
-	name = spotname
+        name = spotname
 
-    if not grass.overwrite() and grass.find_file(name)['file']:
-	grass.fatal(_("<%s> already exists. Aborting.") % name)
+    if not gscript.overwrite() and gscript.find_file(name)['file']:
+        gscript.fatal(_("<%s> already exists. Aborting.") % name)
 
-    # still a ZIP file?  (is this portable?? see the r.in.srtm script for ideas)
+    # still a ZIP file?  (is this portable?? see the r.in.srtm script for
+    # ideas)
     if infile.lower().endswith('.zip'):
-	grass.fatal(_("Please extract %s before import.") % infile)
+        gscript.fatal(_("Please extract %s before import.") % infile)
 
     try:
-	p = grass.Popen(['file', '-ib', infile], stdout = grass.PIPE)
-	s = p.communicate()[0]
-	if s == "application/x-zip":
-	    grass.fatal(_("Please extract %s before import.") % infile)
+        p = gscript.Popen(['file', '-ib', infile], stdout=gscript.PIPE)
+        s = p.communicate()[0]
+        if s == "application/x-zip":
+            gscript.fatal(_("Please extract %s before import.") % infile)
     except:
-	pass
+        pass
 
-    ### create VRT header for NDVI
+    # create VRT header for NDVI
 
     projfile = os.path.join(spotdir, "0001_LOG.TXT")
     vrtfile = tmpfile + '.vrt'
 
     # first process the NDVI:
-    grass.try_remove(vrtfile)
+    gscript.try_remove(vrtfile)
     create_VRT_file(projfile, vrtfile, infile)
 
-    ## let's import the NDVI map...
-    grass.message(_("Importing SPOT VGT NDVI map..."))
+    # let's import the NDVI map...
+    gscript.message(_("Importing SPOT VGT NDVI map..."))
     try:
-        grass.run_command('r.in.gdal', input=vrtfile, output=name)
+        gscript.run_command('r.in.gdal', input=vrtfile, output=name)
     except CalledModuleError:
-        grass.fatal(_("An error occurred. Stop."))
+        gscript.fatal(_("An error occurred. Stop."))
 
-    grass.message(_("Imported SPOT VEGETATION NDVI map <%s>.") % name)
+    gscript.message(_("Imported SPOT VEGETATION NDVI map <%s>.") % name)
 
     #################
-    ## http://www.vgt.vito.be/faq/FAQS/faq19.html
+    # http://www.vgt.vito.be/faq/FAQS/faq19.html
     # What is the relation between the digital number and the real NDVI ?
     # Real NDVI =coefficient a * Digital Number + coefficient b
     #           = a * DN +b
@@ -173,28 +179,29 @@ def main():
 
     # clone current region
     # switch to a temporary region
-    grass.use_temp_region()
+    gscript.use_temp_region()
 
-    grass.run_command('g.region', raster = name, quiet = True)
+    gscript.run_command('g.region', raster=name, quiet=True)
 
-    grass.message(_("Remapping digital numbers to NDVI..."))
+    gscript.message(_("Remapping digital numbers to NDVI..."))
     tmpname = "%s_%s" % (name, pid)
-    grass.mapcalc("$tmpname = 0.004 * $name - 0.1", tmpname = tmpname, name = name)
-    grass.run_command('g.remove', type = 'raster', name = name, quiet = True, flags = 'f')
-    grass.run_command('g.rename', raster = (tmpname, name), quiet = True)
+    gscript.mapcalc("$tmpname = 0.004 * $name - 0.1", tmpname=tmpname, name=name)
+    gscript.run_command('g.remove', type='raster', name=name, quiet=True,
+                        flags='f')
+    gscript.run_command('g.rename', raster=(tmpname, name), quiet=True)
 
     # write cmd history:
-    grass.raster_history(name)
+    gscript.raster_history(name)
 
-    #apply color table:
-    grass.run_command('r.colors', map = name, color = 'ndvi', quiet = True)
+    # apply color table:
+    gscript.run_command('r.colors', map=name, color='ndvi', quiet=True)
 
     ##########################
     # second, optionally process the SM quality map:
-    
-    #SM Status Map
+
+    # SM Status Map
     # http://nieuw.vgt.vito.be/faq/FAQS/faq22.html
-    #Data about
+    # Data about
     # Bit NR 7: Radiometric quality for B0 coded as 0 if bad and 1 if good
     # Bit NR 6: Radiometric quality for B2 coded as 0 if bad and 1 if good
     # Bit NR 5: Radiometric quality for B3 coded as 0 if bad and 1 if good
@@ -205,7 +212,7 @@ def main():
     # Bit NR 0:	0	1	0		1
     # 		clear	shadow	uncertain	cloud
     #
-    #Note:
+    # Note:
     # pos 7     6    5    4    3    2   1   0 (bit position)
     #   128    64   32   16    8    4   2   1 (values for 8 bit)
     #
@@ -218,54 +225,55 @@ def main():
     # A good map threshold: >= 248
 
     if also:
-	grass.message(_("Importing SPOT VGT NDVI quality map..."))
-	grass.try_remove(vrtfile)
-	qname = spotname.replace('NDV','SM')
-	qfile = os.path.join(spotdir, qname)
-	create_VRT_file(projfile, vrtfile, qfile)
-
-	## let's import the SM quality map...
-	smfile = name + '.sm'
+        gscript.message(_("Importing SPOT VGT NDVI quality map..."))
+        gscript.try_remove(vrtfile)
+        qname = spotname.replace('NDV', 'SM')
+        qfile = os.path.join(spotdir, qname)
+        create_VRT_file(projfile, vrtfile, qfile)
+
+        # let's import the SM quality map...
+        smfile = name + '.sm'
         try:
-            grass.run_command('r.in.gdal', input=vrtfile, output=smfile)
+            gscript.run_command('r.in.gdal', input=vrtfile, output=smfile)
         except CalledModuleError:
-            grass.fatal(_("An error occurred. Stop."))
-
-	# some of the possible values:
-	rules = [r + '\n' for r in [
-	    '8 50 50 50',
-	    '11 70 70 70',
-	    '12 90 90 90',
-	    '60 grey',
-	    '155 blue',
-	    '232 violet',
-	    '235 red',
-	    '236 brown',
-	    '248 orange',
-	    '251 yellow',
-	    '252 green'
-	    ]]
-	grass.write_command('r.colors', map = smfile, rules = '-', stdin = rules)
-
-	grass.message(_("Imported SPOT VEGETATION SM quality map <%s>.") % smfile)
-	grass.message(_("Note: A snow map can be extracted by category 252 (d.rast %s cat=252)") % smfile)
-	grass.message("")
-	grass.message(_("Filtering NDVI map by Status Map quality layer..."))
-
-	filtfile = "%s_filt" % name
-	grass.mapcalc("$filtfile = if($smfile % 4 == 3 || ($smfile / 16) % 16 == 0, null(), $name)",
-		      filtfile = filtfile, smfile = smfile, name = name)
-	grass.run_command('r.colors', map = filtfile, color = 'ndvi', quiet = True)
-	grass.message(_("Filtered SPOT VEGETATION NDVI map <%s>.") % filtfile)
-
-	# write cmd history:
-	grass.raster_history(smfile)
-	grass.raster_history(filtfile)
-
-    grass.message(_("Done."))
+            gscript.fatal(_("An error occurred. Stop."))
+
+        # some of the possible values:
+        rules = [r + '\n' for r in ['8 50 50 50',
+                                    '11 70 70 70',
+                                    '12 90 90 90',
+                                    '60 grey',
+                                    '155 blue',
+                                    '232 violet',
+                                    '235 red',
+                                    '236 brown',
+                                    '248 orange',
+                                    '251 yellow',
+                                    '252 green']]
+        gscript.write_command('r.colors', map=smfile, rules='-', stdin=rules)
+
+        gscript.message(_("Imported SPOT VEGETATION SM quality map <%s>.") %
+                        smfile)
+        gscript.message(_("Note: A snow map can be extracted by category "
+                          "252 (d.rast %s cat=252)") % smfile)
+        gscript.message("")
+        gscript.message(_("Filtering NDVI map by Status Map quality layer..."))
+
+        filtfile = "%s_filt" % name
+        gscript.mapcalc("$filtfile = if($smfile % 4 == 3 || "
+                        "($smfile / 16) % 16 == 0, null(), $name)",
+                        filtfile=filtfile, smfile=smfile, name=name)
+        gscript.run_command('r.colors', map=filtfile, color='ndvi', quiet=True)
+        gscript.message(_("Filtered SPOT VEGETATION NDVI map <%s>.") %
+                        filtfile)
+
+        # write cmd history:
+        gscript.raster_history(smfile)
+        gscript.raster_history(filtfile)
+
+    gscript.message(_("Done."))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     atexit.register(cleanup)
     main()
-

scripts/i.oif/i.oif.py

@@ -121,7 +121,6 @@ def main():
             kv = parse_key_val(pout[band])
             stddev[band] = float(kv['stddev'])
 
-
     grass.message(_("Calculating Correlation Matrix..."))
     correlation = {}
     s = grass.read_command('r.covar', flags='r', map=[band for band in bands],
@@ -141,7 +140,7 @@ def main():
         oif.append((oifcalc(stddev, correlation, *p), p))
     oif.sort(reverse=True)
 
-    grass.verbose(_("The Optimum Index Factor analysis result " \
+    grass.verbose(_("The Optimum Index Factor analysis result "
                     "(best combination shown first):"))
 
     if shell:

scripts/i.spectral/i.spectral.py

@@ -20,7 +20,7 @@
 #
 # written by Markus Neteler 18. August 1998
 #            neteler geog.uni-hannover.de
-# 
+#
 # bugfix: 25. Nov.98/20. Jan. 1999
 # 3 March 2006: Added multiple images and group support by Francesco Pirotti - CIRGEO
 #
@@ -77,20 +77,22 @@
 import os
 import atexit
 from grass.script.utils import try_rmdir
-from grass.script import core as grass
+from grass.script import core as gcore
 
 
 def cleanup():
     try_rmdir(tmp_dir)
 
+
 def write2textf(what, output):
     outf = open(output, 'w')
-    i=0
+    i = 0
     for row in enumerate(what):
-        i=i+1
-        outf.write("%d, %s\n" % (i,row))
+        i = i + 1
+        outf.write("%d, %s\n" % (i, row))
     outf.close()
 
+
 def draw_gnuplot(what, xlabels, output, img_format, coord_legend):
     xrange = 0
 
@@ -107,12 +109,12 @@ def draw_gnuplot(what, xlabels, output, img_format, coord_legend):
     if output:
         if img_format == 'png':
             term_opts = "png truecolor large size 825,550"
-	elif img_format == 'eps':
+        elif img_format == 'eps':
             term_opts = "postscript eps color solid size 6,4"
-	elif img_format == 'svg':
+        elif img_format == 'svg':
             term_opts = "svg size 825,550 dynamic solid"
         else:
-            grass.fatal(_("Programmer error (%s)") % img_format)
+            gcore.fatal(_("Programmer error (%s)") % img_format)
 
         lines += [
             "set term " + term_opts,
@@ -152,9 +154,9 @@ def draw_gnuplot(what, xlabels, output, img_format, coord_legend):
     plotf.close()
 
     if output:
-        grass.call(['gnuplot', plotfile])
+        gcore.call(['gnuplot', plotfile])
     else:
-        grass.call(['gnuplot', '-persist', plotfile])
+        gcore.call(['gnuplot', '-persist', plotfile])
 
 
 def draw_linegraph(what):
@@ -175,7 +177,7 @@ def draw_linegraph(what):
         yf.close()
         yfiles.append(yfile)
 
-    sienna = '#%02x%02x%02x' % (160,  82, 45)
+    sienna = '#%02x%02x%02x' % (160, 82, 45)
     coral = '#%02x%02x%02x' % (255, 127, 80)
     gp_colors = ['red', 'green', 'blue', 'magenta', 'cyan', sienna, 'orange',
                  coral]
@@ -185,7 +187,7 @@ def draw_linegraph(what):
         colors += gp_colors
     colors = colors[0:len(what)]
 
-    grass.run_command('d.linegraph', x_file=xfile, y_file=yfiles,
+    gcore.run_command('d.linegraph', x_file=xfile, y_file=yfiles,
                       y_color=colors, title='Spectral signatures',
                       x_title='Bands', y_title='DN Value')
 
@@ -201,26 +203,26 @@ def main():
     textfile = flags['t']
 
     global tmp_dir
-    tmp_dir = grass.tempdir()
-    
+    tmp_dir = gcore.tempdir()
+
     if not group and not raster:
-        grass.fatal(_("Either group= or raster= is required"))
+        gcore.fatal(_("Either group= or raster= is required"))
 
     if group and raster:
-        grass.fatal(_("group= and raster= are mutually exclusive"))
+        gcore.fatal(_("group= and raster= are mutually exclusive"))
 
     # -t needs an output filename
     if textfile and not output:
-        grass.fatal(_("Writing to text file requires output=filename"))
+        gcore.fatal(_("Writing to text file requires output=filename"))
 
     # check if gnuplot is present
-    if gnuplot and not grass.find_program('gnuplot', '-V'):
-        grass.fatal(_("gnuplot required, please install first"))
+    if gnuplot and not gcore.find_program('gnuplot', '-V'):
+        gcore.fatal(_("gnuplot required, please install first"))
 
     # get data from group listing and set the x-axis labels
     if group:
         # Parse the group list output
-        s = grass.read_command('i.group', flags='g', group=group, quiet=True)
+        s = gcore.read_command('i.group', flags='g', group=group, quiet=True)
         rastermaps = s.splitlines()
     else:
         # get data from list of files and set the x-axis labels
@@ -231,10 +233,10 @@ def main():
 
     # get y-data for gnuplot-data file
     what = []
-    s = grass.read_command('r.what', map=rastermaps, coordinates=coords,
+    s = gcore.read_command('r.what', map=rastermaps, coordinates=coords,
                            null='0', quiet=True)
     if len(s) == 0:
-        grass.fatal(_('No data returned from query'))
+        gcore.fatal(_('No data returned from query'))
 
     for l in s.splitlines():
         f = l.split('|')
@@ -254,6 +256,6 @@ def main():
         draw_linegraph(what)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     atexit.register(cleanup)
     main()

scripts/i.tasscap/i.tasscap.py

@@ -75,24 +75,24 @@ import grass.script as grass
 
 # weights for 6 Landsat bands: TM4, TM5, TM7, OLI
 # MODIS: Red, NIR1, Blue, Green, NIR2, SWIR1, SWIR2
-parms = [[(0.3037,  0.2793,  0.4743,  0.5585,  0.5082,  0.1863),  # Landsat TM4
-         (-0.2848, -0.2435, -0.5435,  0.7243,  0.0840, -0.1800),
-          (0.1509,  0.1973,  0.3279,  0.3406, -0.7112, -0.4572)],
-         [(0.2909,  0.2493,  0.4806,  0.5568,  0.4438,  0.1706, 10.3695),  # Landsat TM5
-         (-0.2728, -0.2174, -0.5508,  0.7221,  0.0733, -0.1648, -0.7310),
-          (0.1446,  0.1761,  0.3322,  0.3396, -0.6210, -0.4186, -3.3828),
-          (0.8461, -0.0731, -0.4640, -0.0032, -0.0492, -0.0119,  0.7879)],
-         [(0.3561,  0.3972,  0.3904,  0.6966,  0.2286,  0.1596),  # Landsat TM7
-         (-0.3344, -0.3544, -0.4556,  0.6966, -0.0242, -0.2630),
-          (0.2626,  0.2141,  0.0926,  0.0656, -0.7629, -0.5388),
-          (0.0805, -0.0498,  0.1950, -0.1327,  0.5752, -0.7775)],
-         [(0.3029,  0.2786,  0.4733,  0.5599,  0.5080,  0.1872),  # Landsat OLI
-         (-0.2941, -0.2430, -0.5424,  0.7276,  0.0713, -0.1608),
-          (0.1511,  0.1973,  0.3283,  0.3407, -0.7117, -0.4559),
-         (-0.8239,  0.0849,  0.4396, -0.0580,  0.2013, -0.2773)],
-         [(0.4395,  0.5945,  0.2460,  0.3918,  0.3506,  0.2136,  0.2678),  # MODIS
-         (-0.4064,  0.5129, -0.2744, -0.2893,  0.4882, -0.0036, -0.4169),
-          (0.1147,  0.2489,  0.2408,  0.3132, -0.3122, -0.6416, -0.5087)]]
+parms = [[(0.3037, 0.2793, 0.4743, 0.5585, 0.5082, 0.1863),  # Landsat TM4
+          (-0.2848, -0.2435, -0.5435, 0.7243, 0.0840, -0.1800),
+          (0.1509, 0.1973, 0.3279, 0.3406, -0.7112, -0.4572)],
+         [(0.2909, 0.2493, 0.4806, 0.5568, 0.4438, 0.1706, 10.3695),  # Landsat TM5
+          (-0.2728, -0.2174, -0.5508, 0.7221, 0.0733, -0.1648, -0.7310),
+          (0.1446, 0.1761, 0.3322, 0.3396, -0.6210, -0.4186, -3.3828),
+          (0.8461, -0.0731, -0.4640, -0.0032, -0.0492, -0.0119, 0.7879)],
+         [(0.3561, 0.3972, 0.3904, 0.6966, 0.2286, 0.1596),  # Landsat TM7
+          (-0.3344, -0.3544, -0.4556, 0.6966, -0.0242, -0.2630),
+          (0.2626, 0.2141, 0.0926, 0.0656, -0.7629, -0.5388),
+          (0.0805, -0.0498, 0.1950, -0.1327, 0.5752, -0.7775)],
+         [(0.3029, 0.2786, 0.4733, 0.5599, 0.5080, 0.1872),  # Landsat OLI
+          (-0.2941, -0.2430, -0.5424, 0.7276, 0.0713, -0.1608),
+          (0.1511, 0.1973, 0.3283, 0.3407, -0.7117, -0.4559),
+          (-0.8239, 0.0849, 0.4396, -0.0580, 0.2013, -0.2773)],
+         [(0.4395, 0.5945, 0.2460, 0.3918, 0.3506, 0.2136, 0.2678),  # MODIS
+          (-0.4064, 0.5129, -0.2744, -0.2893, 0.4882, -0.0036, -0.4169),
+          (0.1147, 0.2489, 0.2408, 0.3132, -0.3122, -0.6416, -0.5087)]]
 
 
 # satellite information
@@ -167,8 +167,8 @@ def main():
 
     # assign "Data Description" field in all four component maps
     for i, comp in enumerate(names):
-        grass.run_command('r.support', map="%s.%d" % (output_basename, i+1),
-                          description="Tasseled Cap %d: %s" % (i+1, comp))
+        grass.run_command('r.support', map="%s.%d" % (output_basename, i + 1),
+                          description="Tasseled Cap %d: %s" % (i + 1, comp))
 
     grass.message(_("Tasseled Cap components calculated"))
 

scripts/m.proj/m.proj.py

@@ -95,10 +95,11 @@ import sys
 import os
 import threading
 from grass.script.utils import separator, parse_key_val
-from grass.script import core as grass
+from grass.script import core as gcore
 
 
 class TrThread(threading.Thread):
+
     def __init__(self, ifs, inf, outf):
         threading.Thread.__init__(self)
         self.ifs = ifs
@@ -131,28 +132,28 @@ def main():
     include_header = flags['c']
 
     # check for cs2cs
-    if not grass.find_program('cs2cs'):
-        grass.fatal(_(
+    if not gcore.find_program('cs2cs'):
+        gcore.fatal(_(
             "cs2cs program not found, install PROJ.4 first: \
             http://proj.maptools.org"))
 
     # check for overenthusiasm
     if proj_in and ll_in:
-        grass.fatal(_("Choose only one input parameter method"))
+        gcore.fatal(_("Choose only one input parameter method"))
 
     if proj_out and ll_out:
-        grass.fatal(_("Choose only one output parameter method"))
+        gcore.fatal(_("Choose only one output parameter method"))
 
     if ll_in and ll_out:
-        grass.fatal(_("Choise only one auto-projection parameter method"))
+        gcore.fatal(_("Choise only one auto-projection parameter method"))
 
-    if output and not grass.overwrite() and os.path.exists(output):
-        grass.fatal(_("Output file already exists"))
+    if output and not gcore.overwrite() and os.path.exists(output):
+        gcore.fatal(_("Output file already exists"))
 
     if not coords and not input:
-        grass.fatal(_("One of <coordinates> and <input> must be given"))
+        gcore.fatal(_("One of <coordinates> and <input> must be given"))
     if coords and input:
-        grass.fatal(_(
+        gcore.fatal(_(
             "Options <coordinates> and <input> are mutually exclusive"))
 
     # parse field separator
@@ -169,59 +170,59 @@ def main():
     ofs = separator(ofs)
 
     # set up projection params
-    s = grass.read_command("g.proj", flags='j')
+    s = gcore.read_command("g.proj", flags='j')
     kv = parse_key_val(s)
     if "XY location" in kv['+proj'] and (ll_in or ll_out):
-        grass.fatal(_("Unable to project to or from a XY location"))
+        gcore.fatal(_("Unable to project to or from a XY location"))
 
     in_proj = None
 
     if ll_in:
         in_proj = "+proj=longlat +datum=WGS84"
-        grass.verbose(
+        gcore.verbose(
             "Assuming LL WGS84 as input, current projection as output ")
 
     if ll_out:
-        in_proj = grass.read_command('g.proj', flags='jf')
+        in_proj = gcore.read_command('g.proj', flags='jf')
 
     if proj_in:
         if '+' in proj_in:
             in_proj = proj_in
         else:
-            grass.fatal(_("Invalid PROJ.4 input specification"))
+            gcore.fatal(_("Invalid PROJ.4 input specification"))
 
     if not in_proj:
-        grass.verbose("Assuming current location as input")
-        in_proj = grass.read_command('g.proj', flags='jf')
+        gcore.verbose("Assuming current location as input")
+        in_proj = gcore.read_command('g.proj', flags='jf')
 
     in_proj = in_proj.strip()
-    grass.verbose("Input parameters: '%s'" % in_proj)
+    gcore.verbose("Input parameters: '%s'" % in_proj)
 
     out_proj = None
 
     if ll_out:
         out_proj = "+proj=longlat +datum=WGS84"
-        grass.verbose(
+        gcore.verbose(
             "Assuming current projection as input, LL WGS84 as output ")
 
     if ll_in:
-        out_proj = grass.read_command('g.proj', flags='jf')
+        out_proj = gcore.read_command('g.proj', flags='jf')
 
     if proj_out:
         if '+' in proj_out:
             out_proj = proj_out
         else:
-            grass.fatal(_("Invalid PROJ.4 output specification"))
+            gcore.fatal(_("Invalid PROJ.4 output specification"))
 
     if not out_proj:
-        grass.fatal(_("Missing output projection parameters "))
+        gcore.fatal(_("Missing output projection parameters "))
     out_proj = out_proj.strip()
-    grass.verbose("Output parameters: '%s'" % out_proj)
+    gcore.verbose("Output parameters: '%s'" % out_proj)
 
     # set up input file
     if coords:
         x, y = coords.split(',')
-        tmpfile = grass.tempfile()
+        tmpfile = gcore.tempfile()
         fd = open(tmpfile, "w")
         fd.write("%s%s%s\n" % (x, ifs, y))
         fd.close()
@@ -233,9 +234,9 @@ def main():
         else:
             infile = input
             if not os.path.exists(infile):
-                grass.fatal(_("Unable to read input data"))
+                gcore.fatal(_("Unable to read input data"))
             inf = file(infile)
-            grass.debug("input file=[%s]" % infile)
+            gcore.debug("input file=[%s]" % infile)
 
     # set up output file
     if not output:
@@ -244,7 +245,7 @@ def main():
     else:
         outfile = output
         outf = open(outfile, 'w')
-        grass.debug("output file=[%s]" % outfile)
+        gcore.debug("output file=[%s]" % outfile)
 
     # set up output style
     if not decimal:
@@ -263,7 +264,7 @@ def main():
     cmd = ['cs2cs'] + copyinp + outfmt + \
         in_proj.split() + ['+to'] + out_proj.split()
 
-    p = grass.Popen(cmd, stdin=grass.PIPE, stdout=grass.PIPE)
+    p = gcore.Popen(cmd, stdin=gcore.PIPE, stdout=gcore.PIPE)
 
     tr = TrThread(ifs, inf, p.stdin)
     tr.start()
@@ -276,7 +277,7 @@ def main():
                 xy, z = line.split(' ', 1)
                 x, y = xy.split('\t')
             except ValueError:
-                grass.fatal(line)
+                gcore.fatal(line)
 
             outf.write('%s%s%s%s%s\n' %
                        (x.strip(), ofs, y.strip(), ofs, z.strip()))
@@ -294,9 +295,9 @@ def main():
     p.wait()
 
     if p.returncode != 0:
-        grass.warning(_(
+        gcore.warning(_(
             "Projection transform probably failed, please investigate"))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     main()

scripts/r.blend/r.blend.py

@@ -40,14 +40,13 @@
 #%end
 #% flag
 #% key: c
-#% description: Combine resulting R,G,B layers into single output map 
+#% description: Combine resulting R,G,B layers into single output map
 #%end
 
-
-import sys
 import os
 import string
-import grass.script as grass
+import grass.script as gscript
+
 
 def main():
     first = options['first']
@@ -55,13 +54,13 @@ def main():
     output = options['output']
     percent = options['percent']
 
-    mapset = grass.gisenv()['MAPSET']
+    mapset = gscript.gisenv()['MAPSET']
 
-    if not grass.overwrite():
-	for ch in ['r','g','b']:
-	    map = '%s.%s' % (output, ch)
-	    if grass.find_file(map, element = 'cell', mapset = mapset)['file']:
-		grass.fatal(_("Raster map <%s> already exists.") % map)
+    if not gscript.overwrite():
+        for ch in ['r', 'g', 'b']:
+            map = '%s.%s' % (output, ch)
+            if gscript.find_file(map, element='cell', mapset=mapset)['file']:
+                gscript.fatal(_("Raster map <%s> already exists.") % map)
 
     percent = float(percent)
     perc_inv = 100.0 - percent
@@ -69,47 +68,54 @@ def main():
     frac1 = percent / 100.0
     frac2 = perc_inv / 100.0
 
-    grass.message(_("Calculating the three component maps..."))
+    gscript.message(_("Calculating the three component maps..."))
 
-    template = string.Template("$$output.$ch = if(isnull($$first), $ch#$$second, if(isnull($$second), $ch#$$first, $$frac1 * $ch#$$first + $$frac2 * $ch#$$second))")
-    cmd = [template.substitute(ch = ch) for ch in ['r','g','b']]
+    template = string.Template("$$output.$ch = "
+                               "if(isnull($$first), $ch#$$second, "
+                               "if(isnull($$second), $ch#$$first, "
+                               "$$frac1 * $ch#$$first + "
+                               "$$frac2 * $ch#$$second))")
+    cmd = [template.substitute(ch=ch) for ch in ['r', 'g', 'b']]
     cmd = ';'.join(cmd)
 
-    grass.mapcalc(cmd,
-		  output = output,
-		  first = first, second = second,
-		  frac1 = frac1, frac2 = frac2)
-
-    for ch in ['r','g','b']:
-	map = "%s.%s" % (output, ch)
-	grass.run_command('r.colors', map = map, color = 'grey255')
-	grass.run_command('r.support', map = map, history="",
-			  title = "Color blend of %s and %s" % (first, second),
-			  description = "generated by r.blend")
-	grass.run_command('r.support', map = map,
-			  history = "r.blend %s channel." % ch)
-	grass.run_command('r.support', map = map,
-			  history = "  %d%% of %s, %d%% of %s" % (percent, first, perc_inv, second))
-	grass.run_command('r.support', map = map, history = "")
-	grass.run_command('r.support', map = map, history = os.environ['CMDLINE'])
-
+    gscript.mapcalc(cmd, output=output, first=first, second=second,
+                    frac1=frac1, frac2=frac2)
+
+    for ch in ['r', 'g', 'b']:
+        map = "%s.%s" % (output, ch)
+        gscript.run_command('r.colors', map=map, color='grey255')
+        gscript.run_command('r.support', map=map, history="",
+                            title="Color blend of %s and %s" % (first, second),
+                            description="generated by r.blend")
+        gscript.run_command('r.support', map=map,
+                            history="r.blend %s channel." % ch)
+        gscript.run_command('r.support', map=map,
+                            history="  %d%% of %s, %d%% of %s" %
+                                    (percent, first, perc_inv, second))
+        gscript.run_command('r.support', map=map, history="")
+        gscript.run_command('r.support', map=map, history=os.environ['CMDLINE'])
 
     if flags['c']:
-        grass.run_command('r.composite', r = '%s.r' % output,
-	    g = '%s.g' % output, b = '%s.b' % output, output = output)
-
-	grass.run_command('r.support', map = output, history="",
-	    title = "Color blend of %s and %s" % (first, second),
-	    description = "generated by r.blend")
-	grass.run_command('r.support', map = output,
-	    history = "  %d%% of %s, %d%% of %s" % (percent, first, perc_inv, second))
-	grass.run_command('r.support', map = output, history = "")
-	grass.run_command('r.support', map = output, history = os.environ['CMDLINE'])
+        gscript.run_command('r.composite', r='%s.r' % output,
+                            g='%s.g' % output, b='%s.b' % output,
+                            output=output)
+
+        gscript.run_command('r.support', map=output, history="",
+                            title="Color blend of %s and %s" % (first, second),
+                            description="generated by r.blend")
+        gscript.run_command('r.support', map=output,
+                            history="  %d%% of %s, %d%% of %s" %
+                                    (percent, first, perc_inv, second))
+        gscript.run_command('r.support', map=output, history="")
+        gscript.run_command('r.support', map=output,
+                            history=os.environ['CMDLINE'])
     else:
-        grass.message(_("Done. Use the following command to visualize the result:"))
-        grass.message(_("d.rgb r=%s.r g=%s.g b=%s.b") % (output, output, output))
+        gscript.message(_("Done. Use the following command to visualize "
+                          "the result:"))
+        gscript.message(_("d.rgb r=%s.r g=%s.g b=%s.b") %
+                        (output, output, output))
 
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/r.buffer.lowmem/r.buffer.lowmem.py

@@ -53,14 +53,17 @@ scales = {
     'feet': 0.3048,
     'miles': 1609.344,
     'nautmiles': 1852.0
-    }
+}
 
 # what to do in case of user break:
+
+
 def cleanup():
     if grass.find_file(temp_src)['file']:
-        grass.run_command('g.remove', quiet = True, flags = 'fb', type = 'raster', name = temp_src)
+        grass.run_command('g.remove', quiet=True, flags='fb', type='raster', name=temp_src)
     if grass.find_file(temp_dist)['file']:
-        grass.run_command('g.remove', quiet = True, flags = 'fb', type = 'raster', name = temp_dist)
+        grass.run_command('g.remove', quiet=True, flags='fb', type='raster', name=temp_dist)
+
 
 def main():
     global temp_dist, temp_src
@@ -75,13 +78,13 @@ def main():
     temp_dist = "r.buffer.tmp.%s.dist" % tmp
     temp_src = "r.buffer.tmp.%s.src" % tmp
 
-    #check if input file exists
+    # check if input file exists
     if not grass.find_file(input)['file']:
         grass.fatal(_("Raster map <%s> not found") % input)
 
     scale = scales[units]
 
-    distances  = distances.split(',')
+    distances = distances.split(',')
     distances1 = [scale * float(d) for d in distances]
     distances2 = [d * d for d in distances1]
 
@@ -92,8 +95,8 @@ def main():
     else:
         metric = 'squared'
 
-    grass.run_command('r.grow.distance',  input = input, metric = metric,
-                      distance = temp_dist, flags = 'm')
+    grass.run_command('r.grow.distance', input=input, metric=metric,
+                      distance=temp_dist, flags='m')
 
     if zero:
         exp = "$temp_src = if($input == 0,null(),1)"
@@ -101,22 +104,22 @@ def main():
         exp = "$temp_src = if(isnull($input),null(),1)"
 
     grass.message(_("Extracting buffers (1/2)..."))
-    grass.mapcalc(exp, temp_src = temp_src, input = input)
+    grass.mapcalc(exp, temp_src=temp_src, input=input)
 
     exp = "$output = if(!isnull($input),$input,%s)"
     if metric == 'squared':
         for n, dist2 in enumerate(distances2):
-            exp %= "if($dist <= %f,%d,%%s)" % (dist2,n + 2)
+            exp %= "if($dist <= %f,%d,%%s)" % (dist2, n + 2)
     else:
         for n, dist2 in enumerate(distances1):
-            exp %= "if($dist <= %f,%d,%%s)" % (dist2,n + 2)
+            exp %= "if($dist <= %f,%d,%%s)" % (dist2, n + 2)
     exp %= "null()"
 
     grass.message(_("Extracting buffers (2/2)..."))
-    grass.mapcalc(exp, output = output, input = temp_src, dist = temp_dist)
+    grass.mapcalc(exp, output=output, input=temp_src, dist=temp_dist)
 
-    p = grass.feed_command('r.category', map = output,
-                           separator=':', rules = '-')
+    p = grass.feed_command('r.category', map=output,
+                           separator=':', rules='-')
     p.stdin.write("1:distances calculated from these locations\n")
     d0 = "0"
     for n, d in enumerate(distances):
@@ -125,11 +128,11 @@ def main():
     p.stdin.close()
     p.wait()
 
-    grass.run_command('r.colors', map = output, color = 'rainbow')
+    grass.run_command('r.colors', map=output, color='rainbow')
 
     # write cmd history:
     grass.raster_history(output)
-    
+
 if __name__ == "__main__":
     options, flags = grass.parser()
     atexit.register(cleanup)

scripts/r.colors.stddev/r.colors.stddev.py

@@ -30,18 +30,21 @@
 #% description: Force center at zero
 #%end
 
-import sys
 import os
 import atexit
-import grass.script as grass
+
+import grass.script as gscript
+
 
 def z(n):
     return mean + n * stddev
 
+
 def cleanup():
     if tmpmap:
-	grass.run_command('g.remove', flags = 'f', type = 'raster',
-                      name = tmpmap, quiet = True)
+        gscript.run_command('g.remove', flags='f', type='raster',
+                            name=tmpmap, quiet=True)
+
 
 def main():
     global tmpmap
@@ -52,90 +55,89 @@ def main():
     bands = flags['b']
 
     if not zero:
-	s = grass.read_command('r.univar', flags = 'g', map = map)
-	kv = grass.parse_key_val(s)
-	global mean, stddev
-	mean = float(kv['mean'])
-	stddev = float(kv['stddev'])
-
-	if not bands:
-	    # smooth free floating blue/white/red
-	    rules = '\n'.join([
-		"0% blue",
-		"%f blue"  % z(-2),
-		"%f white" % mean,
-		"%f red"   % z(+2),
-		"100% red"])
-	else:
-	    # banded free floating  black/red/yellow/green/yellow/red/black
-
-	    # reclass with labels only works for category (integer) based maps
-            #r.reclass input="$GIS_OPT_MAP" output="${GIS_OPT_MAP}.stdevs" << EOF
-
-	    # >3 S.D. outliers colored black so they show up in d.histogram w/ white background
-	    rules = '\n'.join([
-		"0% black",
-		"%f black"  % z(-3),
-		"%f red"    % z(-3),
-		"%f red"    % z(-2),
-		"%f yellow" % z(-2),
-		"%f yellow" % z(-1),
-		"%f green"  % z(-1),
-		"%f green"  % z(+1),
-		"%f yellow" % z(+1),
-		"%f yellow" % z(+2),
-		"%f red"    % z(+2),
-		"%f red"    % z(+3),
-		"%f black"  % z(+3),
-		"100% black"])
+        s = gscript.read_command('r.univar', flags='g', map=map)
+        kv = gscript.parse_key_val(s)
+        global mean, stddev
+        mean = float(kv['mean'])
+        stddev = float(kv['stddev'])
+
+        if not bands:
+            # smooth free floating blue/white/red
+            rules = '\n'.join(["0% blue",
+                               "%f blue" % z(-2),
+                               "%f white" % mean,
+                               "%f red" % z(+2),
+                               "100% red"])
+        else:
+            # banded free floating  black/red/yellow/green/yellow/red/black
+
+            # reclass with labels only works for category (integer) based maps
+            # r.reclass input="$GIS_OPT_MAP" output="${GIS_OPT_MAP}.stdevs" <<
+            # EOF
+
+            # >3 S.D. outliers colored black so they show up in d.histogram w/ white background
+            rules = '\n'.join(["0% black",
+                               "%f black" % z(-3),
+                               "%f red" % z(-3),
+                               "%f red" % z(-2),
+                               "%f yellow" % z(-2),
+                               "%f yellow" % z(-1),
+                               "%f green" % z(-1),
+                               "%f green" % z(+1),
+                               "%f yellow" % z(+1),
+                               "%f yellow" % z(+2),
+                               "%f red" % z(+2),
+                               "%f red" % z(+3),
+                               "%f black" % z(+3),
+                               "100% black"])
     else:
-	tmpmap = "r_col_stdev_abs_%d" % os.getpid()
-	grass.mapcalc("$tmp = abs($map)", tmp = tmpmap, map = map)
-
-	# data centered on 0  (e.g. map of deviations)
-	info = grass.raster_info(tmpmap)
-	maxv = info['max']
-
-	# current r.univar truncates percentage to the base integer
-	s = grass.read_command('r.univar', flags = 'eg', map = map, percentile = [95.45,68.2689,99.7300])
-	kv = grass.parse_key_val(s)
-
-	stddev1 = float(kv['percentile_68_2689'])
-	stddev2 = float(kv['percentile_95_45'])
-	stddev3 = float(kv['percentile_99_73'])
-
-	if not bands:
-	    # zero centered smooth blue/white/red
-	    rules = '\n'.join([
-		"%f blue" % -maxv,
-		"%f blue" % -stddev2,
-		"0 white",
-		"%f red"  % stddev2,
-		"%f red"  % maxv])
-	else:
-	    # zero centered banded  black/red/yellow/green/yellow/red/black
-
-	    # >3 S.D. outliers colored black so they show up in d.histogram w/ white background
-	    rules = '\n'.join([
-		"%f black" % -maxv,
-		"%f black" % -stddev3,
-		"%f red" % -stddev3,
-		"%f red" % -stddev2,
-		"%f yellow" % -stddev2,
-		"%f yellow" % -stddev1,
-		"%f green" % -stddev1,
-		"%f green" % stddev1,
-		"%f yellow" % stddev1,
-		"%f yellow" % stddev2,
-		"%f red" % stddev2,
-		"%f red" % stddev3,
-		"%f black" % stddev3,
-		"%f black" % maxv,
-		])
-
-    grass.write_command('r.colors', map = map, rules = '-', stdin = rules)
+        tmpmap = "r_col_stdev_abs_%d" % os.getpid()
+        gscript.mapcalc("$tmp = abs($map)", tmp=tmpmap, map=map)
+
+        # data centered on 0  (e.g. map of deviations)
+        info = gscript.raster_info(tmpmap)
+        maxv = info['max']
+
+        # current r.univar truncates percentage to the base integer
+        s = gscript.read_command('r.univar', flags='eg', map=map,
+                                 percentile=[95.45,
+                                             68.2689,
+                                             99.7300])
+        kv = gscript.parse_key_val(s)
+
+        stddev1 = float(kv['percentile_68_2689'])
+        stddev2 = float(kv['percentile_95_45'])
+        stddev3 = float(kv['percentile_99_73'])
+
+        if not bands:
+            # zero centered smooth blue/white/red
+            rules = '\n'.join(["%f blue" % -maxv,
+                               "%f blue" % -stddev2,
+                               "0 white",
+                               "%f red" % stddev2,
+                               "%f red" % maxv])
+        else:
+            # zero centered banded  black/red/yellow/green/yellow/red/black
+
+            # >3 S.D. outliers colored black so they show up in d.histogram w/ white background
+            rules = '\n'.join(["%f black" % -maxv,
+                               "%f black" % -stddev3,
+                               "%f red" % -stddev3,
+                               "%f red" % -stddev2,
+                               "%f yellow" % -stddev2,
+                               "%f yellow" % -stddev1,
+                               "%f green" % -stddev1,
+                               "%f green" % stddev1,
+                               "%f yellow" % stddev1,
+                               "%f yellow" % stddev2,
+                               "%f red" % stddev2,
+                               "%f red" % stddev3,
+                               "%f black" % stddev3,
+                               "%f black" % maxv, ])
+
+    gscript.write_command('r.colors', map=map, rules='-', stdin=rules)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     atexit.register(cleanup)
     main()

scripts/r.fillnulls/r.fillnulls.py

@@ -109,15 +109,18 @@ usermask = None
 mapset = None
 
 # what to do in case of user break:
+
+
 def cleanup():
-    #delete internal mask and any TMP files:
+    # delete internal mask and any TMP files:
     if len(tmp_vmaps) > 0:
-        grass.run_command('g.remove', quiet = True, flags = 'fb', type = 'vector', name = tmp_vmaps)
+        grass.run_command('g.remove', quiet=True, flags='fb', type='vector', name=tmp_vmaps)
     if len(tmp_rmaps) > 0:
-        grass.run_command('g.remove', quiet = True, flags = 'fb', type = 'raster', name = tmp_rmaps)
+        grass.run_command('g.remove', quiet=True, flags='fb', type='raster', name=tmp_rmaps)
     if usermask and mapset:
-        if grass.find_file(usermask, mapset = mapset)['file']:
-            grass.run_command('g.rename', quiet = True, raster = (usermask, 'MASK'), overwrite = True)
+        if grass.find_file(usermask, mapset=mapset)['file']:
+            grass.run_command('g.rename', quiet=True, raster=(usermask, 'MASK'), overwrite=True)
+
 
 def main():
     global usermask, mapset, tmp_rmaps, tmp_vmaps
@@ -131,14 +134,18 @@ def main():
     segmax = int(options['segmax'])
     npmin = int(options['npmin'])
     lambda_ = float(options['lambda'])
+<<<<<<< 1ca5ade0f050cc22722fdcbb57af91135215607e
     quiet = True # FIXME
 
+=======
+    quiet = True  # FIXME
+>>>>>>> scripts modules: support python3
     mapset = grass.gisenv()['MAPSET']
-    unique = str(os.getpid()) # Shouldn't we use temp name?
+    unique = str(os.getpid())  # Shouldn't we use temp name?
     prefix = 'r_fillnulls_%s_' % unique
-    failed_list = list() # a list of failed holes. Caused by issues with v.surf.rst. Connected with #1813
+    failed_list = list()  # a list of failed holes. Caused by issues with v.surf.rst. Connected with #1813
 
-    #check if input file exists
+    # check if input file exists
     if not grass.find_file(input)['file']:
         grass.fatal(_("Raster map <%s> not found") % input)
 
@@ -148,19 +155,19 @@ def main():
     # check if a MASK is already present
     # and remove it to not interfere with NULL lookup part
     # as we don't fill MASKed parts!
-    if grass.find_file('MASK', mapset = mapset)['file']:
+    if grass.find_file('MASK', mapset=mapset)['file']:
         usermask = "usermask_mask." + unique
         grass.message(_("A user raster mask (MASK) is present. Saving it..."))
-        grass.run_command('g.rename', quiet = quiet, raster = ('MASK',usermask))
+        grass.run_command('g.rename', quiet=quiet, raster=('MASK', usermask))
 
-    #check if method is rst to use v.surf.rst
+    # check if method is rst to use v.surf.rst
     if method == 'rst':
         # idea: filter all NULLS and grow that area(s) by 3 pixel, then
         # interpolate from these surrounding 3 pixel edge
         filling = prefix + 'filled'
 
         grass.use_temp_region()
-        grass.run_command('g.region', align = input, quiet = quiet)
+        grass.run_command('g.region', align=input, quiet=quiet)
         region = grass.region()
         ns_res = region['nsres']
         ew_res = region['ewres']
@@ -172,10 +179,10 @@ def main():
         if usermask:
             grass.message(_("Skipping masked raster parts"))
             grass.mapcalc("$tmp1 = if(isnull($input) && !($mask == 0 || isnull($mask)),1,null())",
-                tmp1 = prefix + 'nulls', input = input, mask = usermask)
+                          tmp1=prefix + 'nulls', input=input, mask=usermask)
         else:
             grass.mapcalc("$tmp1 = if(isnull($input),1,null())",
-                tmp1 = prefix + 'nulls', input = input)
+                          tmp1=prefix + 'nulls', input=input)
         tmp_rmaps.append(prefix + 'nulls')
 
         # restoring user's mask, if present
@@ -183,7 +190,7 @@ def main():
         if usermask:
             grass.message(_("Restoring user mask (MASK)..."))
             try:
-                grass.run_command('g.rename', quiet=quiet, raster = (usermask, 'MASK'))
+                grass.run_command('g.rename', quiet=quiet, raster=(usermask, 'MASK'))
             except CalledModuleError:
                 grass.warning(_("Failed to restore user MASK!"))
             usermask = None
@@ -196,19 +203,27 @@ def main():
                               radius=edge + 0.01, old=1, new=1,
                               out=prefix + 'grown', quiet=quiet)
         except CalledModuleError:
-            grass.fatal(_("abandoned. Removing temporary map, restoring user mask if needed:"))
+            grass.fatal(_("abandoned. Removing temporary map, restoring "
+                          "user mask if needed:"))
 
         # assign unique IDs to each hole or hole system (holes closer than edge distance)
         grass.message(_("Assigning IDs to NULL areas"))
         tmp_rmaps.append(prefix + 'clumped')
         try:
-            grass.run_command('r.clump', input=prefix + 'grown', output=prefix + 'clumped', quiet=quiet)
+            grass.run_command(
+                'r.clump',
+                input=prefix +
+                'grown',
+                output=prefix +
+                'clumped',
+                quiet=quiet)
         except CalledModuleError:
-            grass.fatal(_("abandoned. Removing temporary map, restoring user mask if needed:"))
+            grass.fatal(_("abandoned. Removing temporary map, restoring "
+                          "user mask if needed:"))
 
         # get a list of unique hole cat's
         grass.mapcalc("$out = if(isnull($inp), null(), $clumped)",
-                        out = prefix + 'holes', inp = prefix + 'nulls', clumped = prefix + 'clumped')
+                      out=prefix + 'holes', inp=prefix + 'nulls', clumped=prefix + 'clumped')
         tmp_rmaps.append(prefix + 'holes')
 
         # use new IDs to identify holes
@@ -217,12 +232,19 @@ def main():
                               input=prefix + 'holes', output=prefix + 'holes',
                               type='area', quiet=quiet)
         except:
-            grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
+            grass.fatal(_("abandoned. Removing temporary maps, restoring "
+                          "user mask if needed:"))
         tmp_vmaps.append(prefix + 'holes')
 
         # get a list of unique hole cat's
         cats_file_name = grass.tempfile(False)
-        grass.run_command('v.db.select', flags = 'c', map = prefix + 'holes', columns = 'cat', file = cats_file_name, quiet = quiet)
+        grass.run_command(
+            'v.db.select',
+            flags='c',
+            map=prefix + 'holes',
+            columns='cat',
+            file=cats_file_name,
+            quiet=quiet)
         cat_list = list()
         cats_file = file(cats_file_name)
         for line in cats_file:
@@ -248,17 +270,19 @@ def main():
                                   output=holename + '_pol',
                                   cats=cat, quiet=quiet)
             except CalledModuleError:
-                grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
+                grass.fatal(_("abandoned. Removing temporary maps, restoring "
+                              "user mask if needed:"))
             tmp_vmaps.append(holename + '_pol')
 
-            # zoom to specific hole with a buffer of two cells around the hole to remove rest of data
+            # zoom to specific hole with a buffer of two cells around the hole to
+            # remove rest of data
             try:
                 grass.run_command('g.region',
                                   vector=holename + '_pol', align=input,
-                                  w = 'w-%d' % (edge * 2 * ew_res),
-                                  e = 'e+%d' % (edge * 2 * ew_res),
-                                  n = 'n+%d' % (edge * 2 * ns_res),
-                                  s = 's-%d' % (edge * 2 * ns_res),
+                                  w='w-%d' % (edge * 2 * ew_res),
+                                  e='e+%d' % (edge * 2 * ew_res),
+                                  n='n+%d' % (edge * 2 * ns_res),
+                                  s='s-%d' % (edge * 2 * ns_res),
                                   quiet=quiet)
             except CalledModuleError:
                 grass.fatal(_("abandoned. Removing temporary maps, restoring "
@@ -269,12 +293,13 @@ def main():
                 grass.run_command('g.remove', flags='fb', type='vector',
                                   name=holename + '_pol', quiet=quiet)
             except CalledModuleError:
-                grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
+                grass.fatal(_("abandoned. Removing temporary maps, restoring "
+                              "user mask if needed:"))
             tmp_vmaps.remove(holename + '_pol')
 
             # copy only data around hole
             grass.mapcalc("$out = if($inp == $catn, $inp, null())",
-                            out = holename, inp = prefix + 'holes', catn = cat)
+                          out=holename, inp=prefix + 'holes', catn=cat)
             tmp_rmaps.append(holename)
 
             # If here loop is split into two, next part of loop can be run in parallel
@@ -285,13 +310,14 @@ def main():
             tmp_rmaps.append(holename + '_grown')
             try:
                 grass.run_command('r.grow', input=holename, radius=edge + 0.01,
-                             old=-1, out=holename + '_grown', quiet=quiet)
+                                  old=-1, out=holename + '_grown', quiet=quiet)
             except CalledModuleError:
-                grass.fatal(_("abandoned. Removing temporary map, restoring user mask if needed:"))
+                grass.fatal(_("abandoned. Removing temporary map, restoring "
+                              "user mask if needed:"))
 
             # no idea why r.grow old=-1 doesn't replace existing values with NULL
             grass.mapcalc("$out = if($inp == -1, null(), $dem)",
-                            out = holename + '_edges', inp = holename + '_grown', dem = input)
+                          out=holename + '_edges', inp=holename + '_grown', dem=input)
             tmp_rmaps.append(holename + '_edges')
 
             # convert to points for interpolation
@@ -301,10 +327,11 @@ def main():
                                   input=holename + '_edges', output=holename,
                                   type='point', flags='z', quiet=quiet)
             except CalledModuleError:
-                grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
+                grass.fatal(_("abandoned. Removing temporary maps, restoring "
+                              "user mask if needed:"))
 
             # count number of points to control segmax parameter for interpolation:
-            pointsnumber = grass.vector_info_topo(map = holename)['points']
+            pointsnumber = grass.vector_info_topo(map=holename)['points']
             grass.verbose(_("Interpolating %d points") % pointsnumber)
 
             if pointsnumber < 2:
@@ -339,29 +366,41 @@ def main():
                     tmp_vmaps.remove(holename)
                 except:
                     pass
-                grass.warning(_("Filling has failed silently. Leaving temporary maps with prefix <%s> for debugging.") % holename)
+                grass.warning(
+                    _("Filling has failed silently. Leaving temporary maps "
+                      "with prefix <%s> for debugging.") %
+                    holename)
                 failed_list.append(holename)
                 continue
 
             # append hole result to interpolated version later used to patch into original DEM
             if first:
                 tmp_rmaps.append(filling)
-                grass.run_command('g.region', align = input, raster = holename + '_dem', quiet = quiet)
+                grass.run_command('g.region', align=input, raster=holename + '_dem', quiet=quiet)
                 grass.mapcalc("$out = if(isnull($inp), null(), $dem)",
-                                out = filling, inp = holename, dem = holename + '_dem')
+                              out=filling, inp=holename, dem=holename + '_dem')
                 first = False
             else:
                 tmp_rmaps.append(filling + '_tmp')
-                grass.run_command('g.region', align = input, raster = (filling, holename + '_dem'), quiet = quiet)
-                grass.mapcalc("$out = if(isnull($inp), if(isnull($fill), null(), $fill), $dem)",
-                                out = filling + '_tmp', inp = holename, dem = holename + '_dem', fill = filling)
+                grass.run_command(
+                    'g.region', align=input, raster=(
+                        filling, holename + '_dem'), quiet=quiet)
+                grass.mapcalc(
+                    "$out = if(isnull($inp), if(isnull($fill), null(), $fill), $dem)",
+                    out=filling + '_tmp',
+                    inp=holename,
+                    dem=holename + '_dem',
+                    fill=filling)
                 try:
                     grass.run_command('g.rename',
                                       raster=(filling + '_tmp', filling),
                                       overwrite=True, quiet=quiet)
                 except CalledModuleError:
-                    grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
-                tmp_rmaps.remove(filling + '_tmp') # this map has been removed. No need for later cleanup.
+                    grass.fatal(
+                        _("abandoned. Removing temporary maps, restoring user "
+                          "mask if needed:"))
+                # this map has been removed. No need for later cleanup.
+                tmp_rmaps.remove(filling + '_tmp')
 
             # remove temporary maps to not overfill disk
             try:
@@ -379,7 +418,8 @@ def main():
                                         holename + '_edges',
                                         holename + '_dem'))
             except CalledModuleError:
-                grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
+                grass.fatal(_("abandoned. Removing temporary maps, restoring "
+                              "user mask if needed:"))
             try:
                 tmp_vmaps.remove(holename)
             except:
@@ -390,27 +430,27 @@ def main():
             except CalledModuleError:
                 grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
 
-    #check if method is different from rst to use r.resamp.bspline
+    # check if method is different from rst to use r.resamp.bspline
     if method != 'rst':
         grass.message(_("Using %s bspline interpolation") % method)
 
         # clone current region
         grass.use_temp_region()
-        grass.run_command('g.region', align = input)
+        grass.run_command('g.region', align=input)
 
         reg = grass.region()
         # launch r.resamp.bspline
         tmp_rmaps.append(prefix + 'filled')
         if usermask:
-            grass.run_command('r.resamp.bspline', input = input, mask = usermask,
-                output = prefix + 'filled', method = method,
-                ew_step = 3 * reg['ewres'], ns_step = 3 * reg['nsres'],
-                lambda_=lambda_, flags='n')
+            grass.run_command('r.resamp.bspline', input=input, mask=usermask,
+                              output=prefix + 'filled', method=method,
+                              ew_step=3 * reg['ewres'], ns_step=3 * reg['nsres'],
+                              lambda_=lambda_, flags='n')
         else:
-            grass.run_command('r.resamp.bspline', input = input,
-                output = prefix + 'filled', method = method,
-                ew_step = 3 * reg['ewres'], ns_step = 3 * reg['nsres'],
-                lambda_=lambda_, flags='n')
+            grass.run_command('r.resamp.bspline', input=input,
+                              output=prefix + 'filled', method=method,
+                              ew_step=3 * reg['ewres'], ns_step=3 * reg['nsres'],
+                              lambda_=lambda_, flags='n')
 
     # restoring user's mask, if present:
     if usermask:
@@ -422,13 +462,14 @@ def main():
         usermask = None
 
     # set region to original extents, align to input
-    grass.run_command('g.region', n = reg_org['n'], s = reg_org['s'],
-                    e = reg_org['e'], w = reg_org['w'], align = input)
+    grass.run_command('g.region', n=reg_org['n'], s=reg_org['s'],
+                      e=reg_org['e'], w=reg_org['w'], align=input)
 
     # patch orig and fill map
     grass.message(_("Patching fill data into NULL areas..."))
     # we can use --o here as g.parser already checks on startup
-    grass.run_command('r.patch', input = (input,prefix + 'filled'), output = output, overwrite = True)
+    grass.run_command('r.patch', input=(input, prefix + 'filled'),
+                      output=output, overwrite=True)
 
     # restore the real region
     grass.del_temp_region()
@@ -439,7 +480,9 @@ def main():
     grass.raster_history(output)
 
     if len(failed_list) > 0:
-        grass.warning(_("Following holes where not filled. Temporary maps with are left in place to allow examination of unfilled holes"))
+        grass.warning(
+            _("Following holes where not filled. Temporary maps with are left "
+              "in place to allow examination of unfilled holes"))
         outlist = failed_list[0]
         for hole in failed_list[1:]:
             outlist = ', ' + outlist

scripts/r.grow/r.grow.py

@@ -72,8 +72,9 @@ from grass.exceptions import CalledModuleError
 def cleanup():
     for map in [temp_dist, temp_val]:
         if map:
-            grass.run_command('g.remove', flags = 'fb', quiet = True,
-                              type='rast', name = map)
+            grass.run_command('g.remove', flags='fb', quiet=True,
+                              type='rast', name=map)
+
 
 def main():
     global temp_dist, temp_val
@@ -108,7 +109,7 @@ def main():
         metric = 'squared'
         radius = radius * radius
 
-    #check if input file exists
+    # check if input file exists
     if not grass.find_file(input)['file']:
         grass.fatal(_("Raster map <%s> not found") % input)
 
@@ -120,10 +121,10 @@ def main():
 
     grass.mapcalc(
         "$output = if(!isnull($input),$old,if($dist < $radius,$new,null()))",
-        output = output, input = input, radius = radius,
-        old = old, new = new, dist = temp_dist)
+        output=output, input=input, radius=radius,
+        old=old, new=new, dist=temp_dist)
 
-    grass.run_command('r.colors', map = output, raster = input)
+    grass.run_command('r.colors', map=output, raster=input)
 
     # write cmd history:
     grass.raster_history(output)

scripts/r.import/r.import.py

@@ -161,7 +161,8 @@ def main():
         if tgtres_value <= 0:
             grass.fatal(_("Resolution value can't be smaller than 0"))
     elif tgtres == 'value':
-         grass.fatal(_("Please provide the resolution for the imported dataset or change to 'estimated' resolution"))
+        grass.fatal(
+            _("Please provide the resolution for the imported dataset or change to 'estimated' resolution"))
 
     grassenv = grass.gisenv()
     tgtloc = grassenv['LOCATION_NAME']
@@ -211,14 +212,18 @@ def main():
             parameters['band'] = bands
         try:
             grass.run_command('r.in.gdal', **parameters)
-            grass.verbose(_("Input <%s> successfully imported without reprojection") % GDALdatasource)
+            grass.verbose(
+                _("Input <%s> successfully imported without reprojection") %
+                GDALdatasource)
             return 0
         except CalledModuleError as e:
             grass.fatal(_("Unable to import GDAL dataset <%s>") % GDALdatasource)
-    
+
     # make sure target is not xy
     if grass.parse_command('g.proj', flags='g')['name'] == 'xy_location_unprojected':
-        grass.fatal(_("Coordinate reference system not available for current location <%s>") % tgtloc)
+        grass.fatal(
+            _("Coordinate reference system not available for current location <%s>") %
+            tgtloc)
 
     # switch to temp location
     os.environ['GISRC'] = str(SRCGISRC)
@@ -327,7 +332,9 @@ def main():
         grass.run_command('g.remove', type='vector', name=vreg,
                           flags='f', quiet=True)
 
-        grass.message(_("Estimated target resolution for input band <{out}>: {res}").format(out=outfile, res=estres))
+        grass.message(
+            _("Estimated target resolution for input band <{out}>: {res}").format(
+                out=outfile, res=estres))
         if flags['e']:
             continue
 
@@ -340,7 +347,9 @@ def main():
             res = estres
         elif tgtres == 'value':
             res = tgtres_value
-            grass.message(_("Using given resolution for input band <{out}>: {res}").format(out=outfile, res=res))
+            grass.message(
+                _("Using given resolution for input band <{out}>: {res}").format(
+                    out=outfile, res=res))
             # align to requested resolution
             grass.run_command('g.region', res=res, flags='a')
         else:

scripts/r.in.aster/r.in.aster.py

@@ -5,9 +5,9 @@
 # MODULE:    r_in_aster.py
 # AUTHOR(S): Michael Barton (michael.barton@asu.edu) and
 #               Glynn Clements (glynn@gclements.plus.com)
-#               Based on r.in.aster bash script for GRASS 
+#               Based on r.in.aster bash script for GRASS
 #               by Michael Barton and Paul Kelly
-# PURPOSE:   Rectifies, georeferences, & imports Terra-ASTER imagery 
+# PURPOSE:   Rectifies, georeferences, & imports Terra-ASTER imagery
 #               using gdalwarp
 # COPYRIGHT: (C) 2008 by the GRASS Development Team
 #
@@ -57,16 +57,16 @@ import grass.script as grass
 
 bands = {
     'L1A': {
-        '1':  "VNIR_Band1:ImageData",
-        '2':  "VNIR_Band2:ImageData",
+        '1': "VNIR_Band1:ImageData",
+        '2': "VNIR_Band2:ImageData",
         '3n': "VNIR_Band3N:ImageData",
         '3b': "VNIR_Band3B:ImageData",
-        '4':  "SWIR_Band4:ImageData",
-        '5':  "SWIR_Band5:ImageData",
-        '6':  "SWIR_Band6:ImageData",
-        '7':  "SWIR_Band7:ImageData",
-        '8':  "SWIR_Band8:ImageData",
-        '9':  "SWIR_Band9:ImageData",
+        '4': "SWIR_Band4:ImageData",
+        '5': "SWIR_Band5:ImageData",
+        '6': "SWIR_Band6:ImageData",
+        '7': "SWIR_Band7:ImageData",
+        '8': "SWIR_Band8:ImageData",
+        '9': "SWIR_Band9:ImageData",
         '10': "TIR_Band10:ImageData",
         '11': "TIR_Band11:ImageData",
         '12': "TIR_Band12:ImageData",
@@ -74,16 +74,16 @@ bands = {
         '14': "TIR_Band14:ImageData"
     },
     'L1B': {
-        '1':  "VNIR_Swath:ImageData1",
-        '2':  "VNIR_Swath:ImageData2",
+        '1': "VNIR_Swath:ImageData1",
+        '2': "VNIR_Swath:ImageData2",
         '3n': "VNIR_Swath:ImageData3N",
         '3b': "VNIR_Swath:ImageData3B",
-        '4':  "SWIR_Swath:ImageData4",
-        '5':  "SWIR_Swath:ImageData5",
-        '6':  "SWIR_Swath:ImageData6",
-        '7':  "SWIR_Swath:ImageData7",
-        '8':  "SWIR_Swath:ImageData8",
-        '9':  "SWIR_Swath:ImageData9",
+        '4': "SWIR_Swath:ImageData4",
+        '5': "SWIR_Swath:ImageData5",
+        '6': "SWIR_Swath:ImageData6",
+        '7': "SWIR_Swath:ImageData7",
+        '8': "SWIR_Swath:ImageData8",
+        '9': "SWIR_Swath:ImageData9",
         '10': "TIR_Swath:ImageData10",
         '11': "TIR_Swath:ImageData11",
         '12': "TIR_Swath:ImageData12",
@@ -92,35 +92,35 @@ bands = {
     }
 }
 
+
 def main():
     input = options['input']
     proctype = options['proctype']
     output = options['output']
     band = options['band']
 
-    #check whether gdalwarp is in path and executable
+    # check whether gdalwarp is in path and executable
     if not grass.find_program('gdalwarp', '--help'):
         grass.fatal(_("gdalwarp is not in the path and executable"))
 
-    #create temporary file to hold gdalwarp output before importing to GRASS
-    tempfile = grass.read_command("g.tempfile", pid = os.getpid()).strip() + '.tif'
+    # create temporary file to hold gdalwarp output before importing to GRASS
+    tempfile = grass.read_command("g.tempfile", pid=os.getpid()).strip() + '.tif'
 
-    #get projection information for current GRASS location
-    proj = grass.read_command('g.proj', flags = 'jf').strip()
+    # get projection information for current GRASS location
+    proj = grass.read_command('g.proj', flags='jf').strip()
 
-    #currently only runs in projected location
+    # currently only runs in projected location
     if "XY location" in proj:
-      grass.fatal(_("This module needs to be run in a projected location (found: %s)") % proj)
-
+        grass.fatal(_("This module needs to be run in a projected location (found: %s)") % proj)
 
-    #process list of bands
-    allbands = ['1','2','3n','3b','4','5','6','7','8','9','10','11','12','13','14']
+    # process list of bands
+    allbands = ['1', '2', '3n', '3b', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14']
     if band == 'all':
         bandlist = allbands
     else:
         bandlist = band.split(',')
 
-    #initialize datasets for L1A and L1B
+    # initialize datasets for L1A and L1B
     if proctype in ["L1A", "L1B"]:
         for band in bandlist:
             if band in allbands:
@@ -129,36 +129,37 @@ def main():
                 import_aster(proj, srcfile, tempfile, band)
             else:
                 grass.fatal(_('band %s is not an available Terra/ASTER band') % band)
-    elif proctype == "DEM": 
+    elif proctype == "DEM":
         srcfile = input
         import_aster(proj, srcfile, tempfile, "DEM")
 
-    #cleanup
+    # cleanup
     grass.message(_("Cleaning up ..."))
     grass.try_remove(tempfile)
     grass.message(_("Done."))
 
     return
 
+
 def import_aster(proj, srcfile, tempfile, band):
-    #run gdalwarp with selected options (must be in $PATH)
-    #to translate aster image to geotiff
+    # run gdalwarp with selected options (must be in $PATH)
+    # to translate aster image to geotiff
     grass.message(_("Georeferencing aster image ..."))
     grass.debug("gdalwarp -t_srs %s %s %s" % (proj, srcfile, tempfile))
 
     if platform.system() == "Darwin":
-        cmd = ["arch", "-i386", "gdalwarp", "-t_srs", proj, srcfile, tempfile ]
+        cmd = ["arch", "-i386", "gdalwarp", "-t_srs", proj, srcfile, tempfile]
     else:
-        cmd = ["gdalwarp", "-t_srs", proj, srcfile, tempfile ]
+        cmd = ["gdalwarp", "-t_srs", proj, srcfile, tempfile]
     p = grass.call(cmd)
     if p != 0:
-        #check to see if gdalwarp executed properly
+        # check to see if gdalwarp executed properly
         return
 
-    #import geotiff to GRASS
+    # import geotiff to GRASS
     grass.message(_("Importing into GRASS ..."))
     outfile = "%s.%s" % (output, band)
-    grass.run_command("r.in.gdal", input = tempfile, output = outfile)
+    grass.run_command("r.in.gdal", input=tempfile, output=outfile)
 
     # write cmd history
     grass.raster_history(outfile)

scripts/r.in.srtm/r.in.srtm.py

@@ -19,18 +19,18 @@
 # Aug 2004: modified to accept files from other directories
 #           (by H. Bowman)
 # June 2005: added flag to read in US 1-arcsec tiles (H. Bowman)
-# April 2006: links updated from ftp://e0dps01u.ecs.nasa.gov/srtm/             
+# April 2006: links updated from ftp://e0dps01u.ecs.nasa.gov/srtm/
 #             to current links below
 # October 2008: Converted to Python by Glynn Clements
 #########################
-#Derived from:
+# Derived from:
 # ftp://e0srp01u.ecs.nasa.gov/srtm/version1/Documentation/Notes_for_ARCInfo_users.txt
 #     (note: document was updated silently end of 2003)
 #
 # ftp://e0srp01u.ecs.nasa.gov/srtm/version1/Documentation/SRTM_Topo.txt
 #  "3.0 Data Formats
 #  [...]
-#  To be more exact, these coordinates refer to the geometric center of 
+#  To be more exact, these coordinates refer to the geometric center of
 #  the lower left pixel, which in the case of SRTM-1 data will be about
 #  30 meters in extent."
 #
@@ -40,7 +40,7 @@
 #
 #- BIL uses *center* of the UL (!) pixel:
 #      http://downloads.esri.com/support/whitepapers/other_/eximgav.pdf
-#  
+#
 #- GDAL uses *corners* of pixels for its coordinates.
 #
 # NOTE: Even, if small difference: SRTM is referenced to EGM96, not WGS84 ellps
@@ -116,12 +116,13 @@ from grass.exceptions import CalledModuleError
 
 def cleanup():
     if not in_temp:
-	return
+        return
     for ext in ['.bil', '.hdr', '.prj', '.hgt.zip']:
-	grass.try_remove(tile + ext)
+        grass.try_remove(tile + ext)
     os.chdir('..')
     grass.try_rmdir(tmpdir)
 
+
 def main():
     global tile, tmpdir, in_temp
 
@@ -131,55 +132,55 @@ def main():
     output = options['output']
     one = flags['1']
 
-    #are we in LatLong location?
+    # are we in LatLong location?
     s = grass.read_command("g.proj", flags='j')
     kv = grass.parse_key_val(s)
     if kv['+proj'] != 'longlat':
-	grass.fatal(_("This module only operates in LatLong locations"))
+        grass.fatal(_("This module only operates in LatLong locations"))
 
     # use these from now on:
     infile = input
     while infile[-4:].lower() in ['.hgt', '.zip']:
-	infile = infile[:-4]
+        infile = infile[:-4]
     (fdir, tile) = os.path.split(infile)
 
     if not output:
-	tileout = tile
+        tileout = tile
     else:
-	tileout = output
+        tileout = output
 
     zipfile = infile + ".hgt.zip"
     hgtfile = os.path.join(fdir, tile[:7] + ".hgt")
     if os.path.isfile(zipfile):
-        #### check if we have unzip
-	if not grass.find_program('unzip'):
-	    grass.fatal(_('The "unzip" program is required, please install it first'))
-
-	# really a ZIP file?
-	# make it quiet in a safe way (just in case -qq isn't portable)
-	tenv = os.environ.copy()
-	tenv['UNZIP'] = '-qq'
-	if grass.call(['unzip', '-t', zipfile], env = tenv) != 0:
-	    grass.fatal(_("'%s' does not appear to be a valid zip file.") % zipfile)
-
-	is_zip = True
+        # check if we have unzip
+        if not grass.find_program('unzip'):
+            grass.fatal(_('The "unzip" program is required, please install it first'))
+
+        # really a ZIP file?
+        # make it quiet in a safe way (just in case -qq isn't portable)
+        tenv = os.environ.copy()
+        tenv['UNZIP'] = '-qq'
+        if grass.call(['unzip', '-t', zipfile], env=tenv) != 0:
+            grass.fatal(_("'%s' does not appear to be a valid zip file.") % zipfile)
+
+        is_zip = True
     elif os.path.isfile(hgtfile):
-	# try and see if it's already unzipped
-	is_zip = False
+        # try and see if it's already unzipped
+        is_zip = False
     else:
-	grass.fatal(_("File '%s' or '%s' not found") % (zipfile, hgtfile))
+        grass.fatal(_("File '%s' or '%s' not found") % (zipfile, hgtfile))
 
-    #make a temporary directory
+    # make a temporary directory
     tmpdir = grass.tempfile()
     grass.try_remove(tmpdir)
     os.mkdir(tmpdir)
 
     if is_zip:
-	shutil.copyfile(zipfile, os.path.join(tmpdir, tile + ".hgt.zip"))
+        shutil.copyfile(zipfile, os.path.join(tmpdir, tile + ".hgt.zip"))
     else:
-	shutil.copyfile(hgtfile, os.path.join(tmpdir, tile + ".hgt"))
+        shutil.copyfile(hgtfile, os.path.join(tmpdir, tile + ".hgt"))
 
-    #change to temporary directory
+    # change to temporary directory
     os.chdir(tmpdir)
     in_temp = True
 
@@ -188,26 +189,26 @@ def main():
     bilfile = tile + ".bil"
 
     if is_zip:
-        #unzip & rename data file:
-	grass.message(_("Extracting '%s'...") % infile)
-	if grass.call(['unzip', zipfile], env = tenv) != 0:
-	    grass.fatal(_("Unable to unzip file."))
+        # unzip & rename data file:
+        grass.message(_("Extracting '%s'...") % infile)
+        if grass.call(['unzip', zipfile], env=tenv) != 0:
+            grass.fatal(_("Unable to unzip file."))
 
     grass.message(_("Converting input file to BIL..."))
     os.rename(hgtfile, bilfile)
 
     north = tile[0]
-    ll_latitude  = int(tile[1:3])
+    ll_latitude = int(tile[1:3])
     east = tile[3]
     ll_longitude = int(tile[4:7])
 
     # are we on the southern hemisphere? If yes, make LATITUDE negative.
     if north == "S":
-	ll_latitude *= -1
+        ll_latitude *= -1
 
     # are we west of Greenwich? If yes, make LONGITUDE negative.
     if east == "W":
-	ll_longitude *= -1
+        ll_longitude *= -1
 
     # Calculate Upper Left from Lower Left
     ulxmap = "%.1f" % ll_longitude
@@ -215,10 +216,10 @@ def main():
     ulymap = "%.1f" % (ll_latitude + 1)
 
     if not one:
-	tmpl = tmpl3sec
+        tmpl = tmpl3sec
     else:
-	grass.message(_("Attempting to import 1-arcsec data."))
-	tmpl = tmpl1sec
+        grass.message(_("Attempting to import 1-arcsec data."))
+        tmpl = tmpl1sec
 
     header = tmpl % (ulxmap, ulymap)
     hdrfile = tile + '.hdr'
@@ -226,7 +227,7 @@ def main():
     outf.write(header)
     outf.close()
 
-    #create prj file: To be precise, we would need EGS96! But who really cares...
+    # create prj file: To be precise, we would need EGS96! But who really cares...
     prjfile = tile + '.prj'
     outf = file(prjfile, 'w')
     outf.write(proj)
@@ -238,7 +239,7 @@ def main():
         grass.fatal(_("Unable to import data"))
 
     # nice color table
-    grass.run_command('r.colors', map = tileout, color = 'srtm')
+    grass.run_command('r.colors', map=tileout, color='srtm')
 
     # write cmd history:
     grass.raster_history(tileout)

scripts/r.in.wms/r.in.wms.py

@@ -58,8 +58,8 @@ This program is free software under the GNU General Public License
 #%option
 #% key: srs
 #% type: integer
-#% description: EPSG code of requested source projection 
-#% answer:4326 
+#% description: EPSG code of requested source projection
+#% answer:4326
 #% guisection: Request
 #%end
 
@@ -178,29 +178,31 @@ sys.path.insert(1, os.path.join(os.path.dirname(sys.path[0]), 'etc', 'r.in.wms')
 
 import grass.script as grass
 
+
 def GetRegionParams(opt_region):
 
-    # set region 
+    # set region
     if opt_region:
         reg_spl = opt_region.strip().split('@', 1)
         reg_mapset = '.'
         if len(reg_spl) > 1:
             reg_mapset = reg_spl[1]
-            
-        if not grass.find_file(name = reg_spl[0], element = 'windows', mapset = reg_mapset)['name']:
-             grass.fatal(_("Region <%s> not found") % opt_region)
-    
+
+        if not grass.find_file(name=reg_spl[0], element='windows', mapset=reg_mapset)['name']:
+            grass.fatal(_("Region <%s> not found") % opt_region)
+
     if opt_region:
         s = grass.read_command('g.region',
-                                quiet = True,
-                                flags = 'ug',
-                                region = opt_region)
-        region_params = grass.parse_key_val(s, val_type = float)
+                               quiet=True,
+                               flags='ug',
+                               region=opt_region)
+        region_params = grass.parse_key_val(s, val_type=float)
     else:
         region_params = grass.region()
 
     return region_params
 
+
 def main():
 
     if 'GRASS' in options['driver']:
@@ -211,7 +213,7 @@ def main():
         grass.debug("Using GDAL WMS driver")
         from wms_gdal_drv import WMSGdalDrv
         wms = WMSGdalDrv()
-    
+
     if flags['c']:
         wms.GetCapabilities(options)
     else:

scripts/r.in.wms/srs.py

@@ -1,5 +1,5 @@
 """!
-@brief WMS, WMTS and NASA OnEarth drivers implemented in GRASS using GDAL Python bindings. 
+@brief WMS, WMTS and NASA OnEarth drivers implemented in GRASS using GDAL Python bindings.
 
 List of classes:
  - srs.py::Srs
@@ -32,6 +32,7 @@ class Srs:
           * urn:ogc:def:crs:EPSG:4326
         :param string axisorder: Force / override axisorder ('xy' or 'yx')
     """
+
     def __init__(self, srs):
         self.id = srs
         self.naming_authority = None
@@ -45,7 +46,7 @@ class Srs:
 
         values = self.id.split(':')
 
-        if self.id.find('/def/crs/') != -1: # URI Style 1
+        if self.id.find('/def/crs/') != -1:  # URI Style 1
             self.encoding = "uri"
             vals = self.id.split('/')
             self.authority = vals[5].upper()
@@ -84,7 +85,7 @@ class Srs:
             self.code = int(values[1])
 
         if self.code in axisorder_yx:
-                self.axisorder = 'yx'
+            self.axisorder = 'yx'
 
     def getcode(self):
         """Create for example "EPSG:4326" string and return back
@@ -101,10 +102,10 @@ class Srs:
         """
 
         return 'urn:%s:def:crs:%s:%s:%s' % (
-                    (self.naming_authority and self.naming_authority or "ogc"),
-                                    (self.authority or ""),
-                                    (self.version or ""),
-                                    (self.code or ""))
+            (self.naming_authority and self.naming_authority or "ogc"),
+            (self.authority or ""),
+            (self.version or ""),
+            (self.code or ""))
 
 axisorder_yx = frozenset([
     4326,

scripts/r.in.wms/wms_base.py

@@ -33,12 +33,13 @@ from grass.exceptions import CalledModuleError
 
 
 class WMSBase:
+
     def __init__(self):
         # these variables are information for destructor
         self.temp_files_to_cleanup = []
 
         self.params = {}
-        self.tile_size = {'bbox' : None}
+        self.tile_size = {'bbox': None}
 
         self.temp_map = None
         self.temp_warpmap = None
@@ -81,31 +82,34 @@ class WMSBase:
             self.params[key] = options[key]
 
         if (self.params ['password'] and self.params ['username'] == '') or \
-           (self.params ['password'] == '' and self.params ['username']):
-                grass.fatal(_("Please insert both %s and %s parameters or none of them." % ('password', 'username')))
+           (self.params['password'] == '' and self.params['username']):
+            grass.fatal(_("Please insert both %s and %s parameters or none of them." %
+                          ('password', 'username')))
 
         self.params['bgcolor'] = options['bgcolor'].strip()
 
         if options['format'] == "jpeg" and \
            not 'format' in driver_props['ignored_params']:
             if not flags['o'] and \
-              'WMS' in self.params['driver']:
+                    'WMS' in self.params['driver']:
                 grass.warning(_("JPEG format does not support transparency"))
 
         self.params['format'] = drv_info.GetFormat(options['format'])
         if not self.params['format']:
             self.params['format'] = self.params['format']
 
-        #TODO: get srs from Tile Service file in OnEarth_GRASS driver
+        # TODO: get srs from Tile Service file in OnEarth_GRASS driver
         self.params['srs'] = int(options['srs'])
-        if self.params['srs'] <= 0 and  not 'srs' in driver_props['ignored_params']:
+        if self.params['srs'] <= 0 and not 'srs' in driver_props['ignored_params']:
             grass.fatal(_("Invalid EPSG code %d") % self.params['srs'])
 
         self.params['wms_version'] = options['wms_version']
         if "CRS" in GetSRSParamVal(self.params['srs']) and self.params['wms_version'] == "1.1.1":
             self.params['wms_version'] = "1.3.0"
-            grass.warning(_("WMS version <1.3.0> will be used, because version <1.1.1> does not support <%s>projection")
-                            % GetSRSParamVal(self.params['srs']))
+            grass.warning(
+                _("WMS version <1.3.0> will be used, because version <1.1.1> does not support <%s>projection") %
+                GetSRSParamVal(
+                    self.params['srs']))
 
         if self.params['wms_version'] == "1.3.0":
             self.params['proj_name'] = "CRS"
@@ -114,7 +118,7 @@ class WMSBase:
 
         # read projection info
         self.proj_location = grass.read_command('g.proj',
-                                                flags ='jf').rstrip('\n')
+                                                flags='jf').rstrip('\n')
         self.proj_location = self._modifyProj(self.proj_location)
 
         if self.params['srs'] in [3857, 900913]:
@@ -124,8 +128,8 @@ class WMSBase:
             self.proj_srs = '+proj=merc +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +no_defs +a=6378137 +b=6378137 +nadgrids=@null +to_meter=1'
         else:
             self.proj_srs = grass.read_command('g.proj',
-                                               flags = 'jf',
-                                               epsg = str(GetEpsg(self.params['srs']))).rstrip('\n')
+                                               flags='jf',
+                                               epsg=str(GetEpsg(self.params['srs']))).rstrip('\n')
 
         self.proj_srs = self._modifyProj(self.proj_srs)
 
@@ -143,9 +147,18 @@ class WMSBase:
         if maxrows <= min_tile_size:
             grass.fatal(_("Maxrows must be greater than 100"))
 
-        # setting optimal tile size according to maxcols and maxrows constraint and region cols and rows
-        self.tile_size['cols'] = int(self.region['cols'] / ceil(self.region['cols'] / float(maxcols)))
-        self.tile_size['rows'] = int(self.region['rows'] / ceil(self.region['rows'] / float(maxrows)))
+        # setting optimal tile size according to maxcols and maxrows constraint
+        # and region cols and rows
+        self.tile_size['cols'] = int(
+            self.region['cols'] /
+            ceil(
+                self.region['cols'] /
+                float(maxcols)))
+        self.tile_size['rows'] = int(
+            self.region['rows'] /
+            ceil(
+                self.region['rows'] /
+                float(maxrows)))
 
         # default format for GDAL library
         self.gdal_drv_format = "GTiff"
@@ -167,33 +180,32 @@ class WMSBase:
         not_relevant_params = []
         for i_param in driver_props['ignored_params']:
 
-            if options.has_key(i_param) and \
+            if i_param in options and \
                options[i_param] and \
-               i_param not in ['srs', 'wms_version', 'format']: # params with default value
-                not_relevant_params.append('<' + i_param  + '>')
+               i_param not in ['srs', 'wms_version', 'format']:  # params with default value
+                not_relevant_params.append('<' + i_param + '>')
 
         if len(not_relevant_params) > 0:
             grass.warning(_("These parameter are ignored: %s\n\
-                             %s driver does not support the parameters." %\
+                             %s driver does not support the parameters." %
                             (','.join(not_relevant_params), options['driver'])))
 
         not_relevant_flags = []
         for i_flag in driver_props['ignored_flags']:
 
             if flags[i_flag]:
-                not_relevant_flags.append('<' + i_flag  + '>')
+                not_relevant_flags.append('<' + i_flag + '>')
 
         if len(not_relevant_flags) > 0:
             grass.warning(_("These flags are ignored: %s\n\
-                             %s driver does not support the flags." %\
+                             %s driver does not support the flags." %
                             (','.join(not_relevant_flags), options['driver'])))
 
     def GetMap(self, options, flags):
         """!Download data from WMS server."""
 
         self._initializeParameters(options, flags)
-
-        self.bbox     = self._computeBbox()
+        self.bbox = self._computeBbox()
 
         self.temp_map = self._download()
 
@@ -244,13 +256,13 @@ class WMSBase:
         grass.debug('Fetching capabilities OK')
         return cap
 
-    def _fetchDataFromServer(self, url, username = None, password = None):
+    def _fetchDataFromServer(self, url, username=None, password=None):
         """!Fetch data from server
         """
         request = Request(url)
         if username and password:
-                    base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
-                    request.add_header("Authorization", "Basic %s" % base64string)
+            base64string = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
+            request.add_header("Authorization", "Basic %s" % base64string)
 
         try:
             return urlopen(request)
@@ -260,7 +272,7 @@ class WMSBase:
     def GetCapabilities(self, options):
         """!Get capabilities from WMS server
         """
-        cap  = self._fetchCapabilities(options)
+        cap = self._fetchCapabilities(options)
         capfile_output = options['capfile_output'].strip()
 
         # save to file
@@ -283,7 +295,7 @@ class WMSBase:
         """
         self._debug("_computeBbox", "started")
 
-        bbox_region_items = {'maxy' : 'n', 'miny' : 's', 'maxx' : 'e', 'minx' : 'w'}
+        bbox_region_items = {'maxy': 'n', 'miny': 's', 'maxx': 'e', 'minx': 'w'}
         bbox = {}
 
         if self.proj_srs == self.proj_location:  # TODO: do it better
@@ -302,21 +314,21 @@ class WMSBase:
 
             try:
                 temp_region_opened = open(temp_region, 'w')
-                temp_region_opened.write("%f %f\n%f %f\n%f %f\n%f %f\n"  %\
-                                       (self.region['e'], self.region['n'],\
-                                        self.region['w'], self.region['n'],\
-                                        self.region['w'], self.region['s'],\
-                                        self.region['e'], self.region['s'] ))
+                temp_region_opened.write("%f %f\n%f %f\n%f %f\n%f %f\n" %
+                                         (self.region['e'], self.region['n'],
+                                          self.region['w'], self.region['n'],
+                                          self.region['w'], self.region['s'],
+                                          self.region['e'], self.region['s']))
             except IOError:
-                 grass.fatal(_("Unable to write data into tempfile"))
+                grass.fatal(_("Unable to write data into tempfile"))
             finally:
                 temp_region_opened.close()
 
-            points = grass.read_command('m.proj', flags = 'd',
-                                        proj_out = self.proj_srs,
-                                        proj_in = self.proj_location,
-                                        input = temp_region,
-                                        quiet = True) # TODO: stdin
+            points = grass.read_command('m.proj', flags='d',
+                                        proj_out=self.proj_srs,
+                                        proj_in=self.proj_location,
+                                        input=temp_region,
+                                        quiet=True)  # TODO: stdin
             grass.try_remove(temp_region)
             if not points:
                 grass.fatal(_("Unable to determine region, %s failed") % 'm.proj')
@@ -337,12 +349,12 @@ class WMSBase:
                     bbox['minx'] = point[0]
                     continue
 
-                if   bbox['maxy'] < point[1]:
+                if bbox['maxy'] < point[1]:
                     bbox['maxy'] = point[1]
                 elif bbox['miny'] > point[1]:
                     bbox['miny'] = point[1]
 
-                if   bbox['maxx'] < point[0]:
+                if bbox['maxx'] < point[0]:
                     bbox['maxx'] = point[0]
                 elif bbox['minx'] > point[0]:
                     bbox['minx'] = point[0]
@@ -359,7 +371,7 @@ class WMSBase:
         """!Reproject data  using gdalwarp if needed
         """
         # reprojection of raster
-        if self.proj_srs != self.proj_location: # TODO: do it better
+        if self.proj_srs != self.proj_location:  # TODO: do it better
             grass.message(_("Reprojecting raster..."))
             self.temp_warpmap = grass.tempfile()
 
@@ -383,14 +395,14 @@ class WMSBase:
                                       '-s_srs', '%s' % self.proj_srs,
                                       '-t_srs', '%s' % self.proj_location,
                                       '-r', gdal_method, '-dstalpha',
-                                      self.temp_map, self.temp_warpmap], stdout = nuldev)
+                                      self.temp_map, self.temp_warpmap], stdout=nuldev)
                 # RGBA rasters
                 else:
                     ps = grass.Popen(['gdalwarp',
                                       '-s_srs', '%s' % self.proj_srs,
                                       '-t_srs', '%s' % self.proj_location,
                                       '-r', gdal_method,
-                                      self.temp_map, self.temp_warpmap], stdout = nuldev)
+                                      self.temp_map, self.temp_warpmap], stdout=nuldev)
                 ps.wait()
             except OSError as e:
                 grass.fatal('%s \nThis can be caused by missing %s utility. ' % (e, 'gdalwarp'))
@@ -423,10 +435,12 @@ class WMSBase:
 
         return temp_file
 
+
 class GRASSImporter:
+
     def __init__(self, opt_output):
 
-        self.cleanup_mask   = False
+        self.cleanup_mask = False
         self.cleanup_layers = False
 
         # output map name
@@ -438,9 +452,9 @@ class GRASSImporter:
 
         # check names of temporary rasters, which module may create
         maps = []
-        for suffix in ('.red', '.green', '.blue', '.alpha', self.original_mask_suffix ):
+        for suffix in ('.red', '.green', '.blue', '.alpha', self.original_mask_suffix):
             rast = self.opt_output + suffix
-            if grass.find_file(rast, element = 'cell', mapset = '.')['file']:
+            if grass.find_file(rast, element='cell', mapset='.')['file']:
                 maps.append(rast)
 
         if len(maps) != 0:
@@ -457,7 +471,8 @@ class GRASSImporter:
                 grass.fatal(_('%s failed') % 'r.mask')
 
             # restore original mask, if exists
-            if grass.find_file(self.opt_output + self.original_mask_suffix, element = 'cell', mapset = '.' )['name']:
+            if grass.find_file(self.opt_output + self.original_mask_suffix,
+                               element='cell', mapset='.')['name']:
                 try:
                     mask_copy = self.opt_output + self.original_mask_suffix
                     grass.run_command('g.copy', quiet=True,
@@ -470,15 +485,15 @@ class GRASSImporter:
             maps = []
             for suffix in ('.red', '.green', '.blue', '.alpha', self.original_mask_suffix):
                 rast = self.opt_output + suffix
-                if grass.find_file(rast, element = 'cell', mapset = '.')['file']:
+                if grass.find_file(rast, element='cell', mapset='.')['file']:
                     maps.append(rast)
 
             if maps:
                 grass.run_command('g.remove',
-                                  quiet = True,
-                                  flags = 'fb',
-                                  type = 'raster',
-                                  name = ','.join(maps))
+                                  quiet=True,
+                                  flags='fb',
+                                  type='raster',
+                                  name=','.join(maps))
 
         # delete environmental variable which overrides region
         if 'GRASS_REGION' in os.environ.keys():
@@ -500,18 +515,18 @@ class GRASSImporter:
         self.cleanup_layers = True
 
         # setting region for full extend of imported raster
-        if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
+        if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file']:
             region_map = self.opt_output + '.red'
         else:
             region_map = self.opt_output
-        os.environ['GRASS_REGION'] = grass.region_env(rast = region_map)
+        os.environ['GRASS_REGION'] = grass.region_env(rast=region_map)
 
         # mask created from alpha layer, which describes real extend
         # of warped layer (may not be a rectangle), also mask contains
         # transparent parts of raster
-        if grass.find_file( self.opt_output + '.alpha', element = 'cell', mapset = '.' )['name']:
+        if grass.find_file(self.opt_output + '.alpha', element='cell', mapset='.')['name']:
             # saving current mask (if exists) into temp raster
-            if grass.find_file('MASK', element = 'cell', mapset = '.' )['name']:
+            if grass.find_file('MASK', element='cell', mapset='.')['name']:
                 try:
                     mask_copy = self.opt_output + self.original_mask_suffix
                     grass.run_command('g.copy', quiet=True,
@@ -530,8 +545,8 @@ class GRASSImporter:
             except CalledModuleError:
                 grass.fatal(_('%s failed') % 'r.mask')
 
-        #TODO one band + alpha band?
-        if grass.find_file(self.opt_output + '.red', element = 'cell', mapset = '.')['file']:
+        # TODO one band + alpha band?
+        if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file']:
             try:
                 grass.run_command('r.composite',
                                   quiet=True, overwrite=True,
@@ -544,7 +559,9 @@ class GRASSImporter:
 
         grass.message(_('<%s> created.') % self.opt_output)
 
+
 class WMSDriversInfo:
+
     def __init__(self):
         """!Provides information about driver parameters.
         """
@@ -553,11 +570,16 @@ class WMSDriversInfo:
         self.f_labels = ["geotiff", "tiff", "png", "jpeg", "gif", "png8"]
 
         # form for request
-        self.formats = ["image/geotiff", "image/tiff", "image/png", "image/jpeg", "image/gif", "image/png8"]
+        self.formats = [
+            "image/geotiff",
+            "image/tiff",
+            "image/png",
+            "image/jpeg",
+            "image/gif",
+            "image/png8"]
 
         self.srs = ("epsg", "crs")
 
-
     def GetDrvProperties(self, driver):
         """!Get information about driver parameters.
         """
@@ -570,7 +592,6 @@ class WMSDriversInfo:
         if 'OnEarth' in driver:
             return self._OnEarthProperties()
 
-
     def _OnEarthProperties(self):
 
         props = {}
@@ -604,7 +625,7 @@ class WMSDriversInfo:
         props = {}
         props['ignored_flags'] = []
         props['ignored_params'] = ['urlparams', 'bgcolor', 'capfile', 'capfile_output',
-                                    'username', 'password']
+                                   'username', 'password']
         props['req_multiple_layers'] = True
 
         return props
@@ -631,8 +652,7 @@ class WMSDriversInfo:
         return self.srs
 
 
-
-#TODO move to utils?
+# TODO move to utils?
 def GetSRSParamVal(srs):
     """!Decides whether to use CRS or EPSG prefix according to srs number.
     """
@@ -642,6 +662,7 @@ def GetSRSParamVal(srs):
     else:
         return "EPSG:%d" % srs
 
+
 def GetEpsg(srs):
     """
      @return EPSG number

scripts/r.in.wms/wms_cap_parsers.py

@@ -18,32 +18,36 @@ This program is free software under the GNU General Public License
 """
 try:
     from xml.etree.ElementTree import ParseError
-except ImportError: # < Python 2.7
+except ImportError:  # < Python 2.7
     from xml.parsers.expat import ExpatError as ParseError
 
 import xml.etree.ElementTree as etree
-import grass.script as grass 
+import grass.script as grass
+
 
 class BaseCapabilitiesTree(etree.ElementTree):
+
     def __init__(self, cap_file):
         """!Initialize xml.etree.ElementTree
         """
         try:
-            etree.ElementTree.__init__(self, file = cap_file)
+            etree.ElementTree.__init__(self, file=cap_file)
         except ParseError:
             raise ParseError(_("Unable to parse XML file"))
         except IOError as error:
             raise ParseError(_("Unable to open XML file '%s'.\n%s\n" % (cap_file, error)))
 
         if self.getroot() is None:
-            raise ParseError(_("Root node was not found.")) 
-        
+            raise ParseError(_("Root node was not found."))
+
+
 class WMSXMLNsHandler:
+
     def __init__(self, caps):
         """!Handle XML namespaces according to WMS version of capabilities.
         """
         self.namespace = "{http://www.opengis.net/wms}"
-        
+
         if caps.getroot().find("Service") is not None:
             self.use_ns = False
         elif caps.getroot().find(self.namespace + "Service") is not None:
@@ -51,7 +55,7 @@ class WMSXMLNsHandler:
         else:
             raise ParseError(_("Unable to parse capabilities file.\n\
                                 Tag <%s> was not found.") % "Service")
-    
+
     def Ns(self, tag_name):
         """!Add namespace to tag_name according to version
         """
@@ -59,30 +63,32 @@ class WMSXMLNsHandler:
             tag_name = self.namespace + tag_name
         return tag_name
 
+
 class WMSCapabilitiesTree(BaseCapabilitiesTree):
-    def __init__(self, cap_file, force_version = None):
+
+    def __init__(self, cap_file, force_version=None):
         """!Parses WMS capabilities file.
             If the capabilities file cannot be parsed if it raises xml.etree.ElementTree.ParseError.
 
-        The class manges inheritance in 'Layer' elements. Inherited elements 
+        The class manges inheritance in 'Layer' elements. Inherited elements
         are added to 'Layer' element.
-        The class also removes elements which are in invalid form and are needed 
+        The class also removes elements which are in invalid form and are needed
         by wxGUI capabilities dialog.
 
-        @param cap_file - capabilities file        
+        @param cap_file - capabilities file
         @param force_version - force capabilities file version (1.1.1, 1.3.0)
         """
         BaseCapabilitiesTree.__init__(self, cap_file)
         self.xml_ns = WMSXMLNsHandler(self)
 
         grass.debug('Checking WMS capabilities tree.', 4)
-        
+
         if not "version" in self.getroot().attrib:
             raise ParseError(_("Missing version attribute root node "
-                                "in Capabilities XML file"))
+                               "in Capabilities XML file"))
         else:
             wms_version = self.getroot().attrib["version"]
-        
+
         if wms_version == "1.3.0":
             self.proj_tag = "CRS"
         else:
@@ -102,54 +108,54 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
 
     def _checkFormats(self, capability):
         """!Check if format element is defined.
-        """        
+        """
         request = self._find(capability, "Request")
         get_map = self._find(request, "GetMap")
         formats = self._findall(get_map, "Format")
- 
-    def _checkLayerTree(self, parent_layer, first = True):
+
+    def _checkLayerTree(self, parent_layer, first=True):
         """!Recursively check layer tree and manage inheritance in the tree
         """
         if first:
             self._initLayer(parent_layer, None)
-        
+
         layers = parent_layer.findall((self.xml_ns.Ns("Layer")))
-        
+
         for l in layers:
             self._initLayer(l, parent_layer)
             self._checkLayerTree(l, False)
-        
+
     def _initLayer(self, layer, parent_layer):
         """Inherit elements from parent layer
 
         @param layer - <Layer> element which inherits
-        @param parent_layer - <Layer> element which is inherited from 
+        @param parent_layer - <Layer> element which is inherited from
         """
         if parent_layer is not None:
-            replaced_elements = [ ["EX_GeographicBoundingBox", "replace"],
-                                  ["Attribution", "replace"],
-                                  ["MinScaleDenominator", "replace"],
-                                  ["MaxScaleDenominator", "replace"],
-                                  ["AuthorityURL", "add"]]
-            
+            replaced_elements = [["EX_GeographicBoundingBox", "replace"],
+                                 ["Attribution", "replace"],
+                                 ["MinScaleDenominator", "replace"],
+                                 ["MaxScaleDenominator", "replace"],
+                                 ["AuthorityURL", "add"]]
+
             for element in replaced_elements:
                 elems = layer.findall(self.xml_ns.Ns(element[0]))
 
                 if len(elems) != 0 or element[1] == "add":
                     for e in parent_layer.findall(self.xml_ns.Ns(element[0])):
                         layer.append(e)
-            
+
             inh_arguments = ["queryable", "cascaded", "opaque",
                              "noSubsets", "fixedWidth", "fixedHeight"]
-            
+
             for attr in parent_layer.attrib:
                 if attr not in layer.attrib and attr in inh_arguments:
                     layer.attrib[attr] = parent_layer.attrib[attr]
-            
+
             self._inhNotSame(self.proj_tag, "element_content", layer, parent_layer)
             self._inhNotSame("BoundingBox", "attribute", layer, parent_layer, self.proj_tag)
 
-            # remove invalid Styles 
+            # remove invalid Styles
             styles = layer.findall(self.xml_ns.Ns('Style'))
             for s in styles:
                 s_name = s.find(self.xml_ns.Ns('Name'))
@@ -160,7 +166,7 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
             self._inhNotSame("Style", "child_element_content", layer, parent_layer, "Name")
             self._inhNotSame("Dimension", "attribute", layer, parent_layer, "name")
 
-    def _inhNotSame(self, element_name, cmp_type, layer, parent_layer, add_arg = None):
+    def _inhNotSame(self, element_name, cmp_type, layer, parent_layer, add_arg=None):
         """Inherit elements which have unique values.
 
         @param element_name - name of inherited element
@@ -168,7 +174,7 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
         @param cmp_type - 'child_element_content' - compared value is text of a child of the <Layer> element
         @param cmp_type - 'attribute' - compared value is text of the <Layer> element attribute
         @param layer - <Layer> element which inherits
-        @param parent_layer - <Layer> element which is inherited from 
+        @param parent_layer - <Layer> element which is inherited from
         @param add_arg - name of child element or attribute
         """
         elem = layer.findall(self.xml_ns.Ns(element_name))
@@ -176,50 +182,50 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
         parent_elems = []
         if parent_layer is not None:
             parent_elems = parent_layer.findall(self.xml_ns.Ns(element_name))
-        
+
         for par_elem in parent_elems:
             parent_cmp_text = None
             if cmp_type == "attribute":
                 if add_arg in par_elem.attrib:
-                    parent_cmp_text = par_elem.attrib[add_arg];
+                    parent_cmp_text = par_elem.attrib[add_arg]
 
             elif cmp_type == "element_content":
                 parent_cmp_text = par_elem.text
-                
+
             elif cmp_type == "child_element_content":
                 parent_cmp = par_elem.find(self.xml_ns.Ns(add_arg))
                 if parent_cmp is not None:
                     parent_cmp_text = parent_cmp.text
-            
+
             if parent_cmp_text is None:
                 continue
-            
+
             is_there = False
             for elem in elem:
                 cmp_text = None
                 if cmp_type == "attribute":
                     if add_arg in elem.attrib:
                         cmp_text = elem.attrib[add_arg]
-                
+
                 elif cmp_type == "element_content":
                     cmp_text = elem.text
-                
+
                 elif cmp_type == "child_element_content":
                     cmp = elem.find(self.xml_ns.Ns(add_arg))
                     if cmp is not None:
                         cmp_text = cmp.text
-                
+
                 if cmp_text is None or \
                    cmp_text.lower() == parent_cmp_text.lower():
                     is_there = True
                     break
-            
+
             if not is_there:
                 layer.append(par_elem)
 
     def _find(self, etreeElement, tag):
         """!Find child element.
-            If the element is not found it raises xml.etree.ElementTree.ParseError.  
+            If the element is not found it raises xml.etree.ElementTree.ParseError.
         """
         res = etreeElement.find(self.xml_ns.Ns(tag))
 
@@ -231,7 +237,7 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
 
     def _findall(self, etreeElement, tag):
         """!Find all children element.
-            If no element is found it raises xml.etree.ElementTree.ParseError.  
+            If no element is found it raises xml.etree.ElementTree.ParseError.
         """
         res = etreeElement.findall(self.xml_ns.Ns(tag))
 
@@ -251,9 +257,11 @@ class WMSCapabilitiesTree(BaseCapabilitiesTree):
         """
         return self.xml_ns
 
+
 class WMTSXMLNsHandler:
     """!Handle XML namespaces which are used in WMTS capabilities file.
     """
+
     def NsWmts(self, tag):
         """!Add namespace.
         """
@@ -264,19 +272,21 @@ class WMTSXMLNsHandler:
         """
         return "{http://www.opengis.net/ows/1.1}" + tag
 
+
 class WMTSCapabilitiesTree(BaseCapabilitiesTree):
+
     def __init__(self, cap_file):
         """!Parses WMTS capabilities file.
             If the capabilities file cannot be parsed it raises xml.etree.ElementTree.ParseError.
 
-        The class also removes elements which are in invalid form and are needed 
+        The class also removes elements which are in invalid form and are needed
         by wxGUI capabilities dialog or for creation of GetTile request by GRASS WMS library.
 
-        @param cap_file - capabilities file        
+        @param cap_file - capabilities file
         """
         BaseCapabilitiesTree.__init__(self, cap_file)
         self.xml_ns = WMTSXMLNsHandler()
-        
+
         grass.debug('Checking WMTS capabilities tree.', 4)
 
         contents = self._find(self.getroot(), 'Contents', self.xml_ns.NsWmts)
@@ -320,8 +330,8 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
 
         for t_mat in tile_mats:
             if not self._checkMat(t_mat):
-               grass.debug('Removed invalid <TileMatrix> element.', 4)
-               mat_set.remove(t_mat)
+                grass.debug('Removed invalid <TileMatrix> element.', 4)
+                mat_set.remove(t_mat)
 
         tile_mats = mat_set.findall(self.xml_ns.NsWmts('TileMatrix'))
         if not tile_mats:
@@ -329,12 +339,12 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
 
         return True
 
-    def _checkMat(self, t_mat):        
+    def _checkMat(self, t_mat):
         """!Check <TileMatrix>.
         """
         def _checkElement(t_mat, e, func):
             element = t_mat.find(self.xml_ns.NsWmts(e))
-            if element is None or not element.text: 
+            if element is None or not element.text:
                 return False
 
             try:
@@ -346,12 +356,12 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
                 return False
             return True
 
-        for e, func in [['ScaleDenominator', float], 
-                        ['TileWidth', int], 
+        for e, func in [['ScaleDenominator', float],
+                        ['TileWidth', int],
                         ['TileHeight', int]]:
             if not _checkElement(t_mat, e, func):
                 return False
-                        
+
         tile_mat_id = t_mat.find(self.xml_ns.NsOws('Identifier'))
         if tile_mat_id is None or not tile_mat_id.text:
             return False
@@ -364,13 +374,13 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
         if len(tl) < 2:
             return False
 
-        for t in tl:              
+        for t in tl:
             try:
                 t = float(t)
             except ValueError:
                 return False
         return True
-    
+
     def _checkLayer(self, layer):
         """!Check <Layer> element.
         """
@@ -395,7 +405,7 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
         contents = self.getroot().find(self.xml_ns.NsWmts('Contents'))
         mat_sets = contents.findall(self.xml_ns.NsWmts('TileMatrixSet'))
 
-        for link in  mat_set_links:
+        for link in mat_set_links:
             # <TileMatrixSetLink> does not point to existing  <TileMatrixSet>
             if not self._checkMatSetLink(link, mat_sets):
                 grass.debug('Removed invalid <TileMatrixSetLink> element.', 4)
@@ -433,7 +443,7 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
             if not tile_mat_limits:
                 grass.debug('Removed invalid <TileMatrixSetLimits> element.', 4)
                 link.remove(tile_mat_set_limits)
-          
+
         if not found:
             return False
 
@@ -456,9 +466,9 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
                 return False
         return True
 
-    def _find(self, etreeElement, tag, ns = None):
+    def _find(self, etreeElement, tag, ns=None):
         """!Find child element.
-            If the element is not found it raises xml.etree.ElementTree.ParseError.  
+            If the element is not found it raises xml.etree.ElementTree.ParseError.
         """
         if not ns:
             res = etreeElement.find(tag)
@@ -471,9 +481,9 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
 
         return res
 
-    def _findall(self, etreeElement, tag, ns = None):
+    def _findall(self, etreeElement, tag, ns=None):
         """!Find all children element.
-            If no element is found it raises xml.etree.ElementTree.ParseError.  
+            If no element is found it raises xml.etree.ElementTree.ParseError.
         """
         if not ns:
             res = etreeElement.findall(tag)
@@ -491,15 +501,17 @@ class WMTSCapabilitiesTree(BaseCapabilitiesTree):
         """
         return self.xml_ns
 
+
 class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
+
     def __init__(self, cap_file):
         """!Parse NASA OnEarth tile service file.
             If the file cannot be parsed it raises xml.etree.ElementTree.ParseError.
 
-        The class also removes elements which are in invalid form and are needed 
+        The class also removes elements which are in invalid form and are needed
         by wxGUI capabilities dialog or for creation of GetMap request by GRASS WMS library.
 
-        @param cap_file - capabilities file        
+        @param cap_file - capabilities file
         """
         BaseCapabilitiesTree.__init__(self, cap_file)
 
@@ -509,7 +521,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
 
         grass.debug('Check if OnEarth capabilities tree was finished.', 4)
 
-    def _checkLayerTree(self, parent_layer, first = True):
+    def _checkLayerTree(self, parent_layer, first=True):
         """!Recursively check layer tree.
         """
         if first:
@@ -526,11 +538,11 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
                 grass.debug(('Removed invalid <%s> element.' % l.tag), 4)
                 parent_layer.remove(l)
             if l.tag == 'TiledGroups':
-               self._checkLayerTree(l, False)
+                self._checkLayerTree(l, False)
 
     def _find(self, etreeElement, tag):
         """!Find child element.
-            If the element is not found it raises xml.etree.ElementTree.ParseError.  
+            If the element is not found it raises xml.etree.ElementTree.ParseError.
         """
         res = etreeElement.find(tag)
 
@@ -545,7 +557,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
         """
         if layer.tag == 'TiledGroups':
             return True
-            
+
         name = layer.find('Name')
         if name is None or not name.text:
             return False
@@ -574,7 +586,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
         """!Get all urls from tile pattern.
         """
         urls = []
-        if  tile_pattern.text is not None:
+        if tile_pattern.text is not None:
             tile_patt_lines = tile_pattern.text.split('\n')
 
             for line in tile_patt_lines:
@@ -585,7 +597,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
     def gettilepatternurldata(self, url):
         """!Parse url string in Tile Pattern.
         """
-        par_url = bbox = width = height = None 
+        par_url = bbox = width = height = None
 
         bbox_idxs = self.geturlparamidxs(url, "bbox=")
         if bbox_idxs is None:
@@ -593,7 +605,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
 
         par_url = [url[:bbox_idxs[0] - 1], url[bbox_idxs[1]:]]
 
-        bbox = url[bbox_idxs[0] + len('bbox=') : bbox_idxs[1]]
+        bbox = url[bbox_idxs[0] + len('bbox='): bbox_idxs[1]]
         bbox_list = bbox.split(',')
         if len(bbox_list) < 4:
             return None
@@ -608,8 +620,8 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
             return None
 
         try:
-            width = int(url[width_idxs[0] + len('width=') : width_idxs[1]])
-        except  ValueError:
+            width = int(url[width_idxs[0] + len('width='): width_idxs[1]])
+        except ValueError:
             return None
 
         height_idxs = self.geturlparamidxs(url, "height=")
@@ -617,8 +629,8 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
             return None
 
         try:
-            height = int(url[height_idxs[0] + len('height=') : height_idxs[1]])
-        except  ValueError:
+            height = int(url[height_idxs[0] + len('height='): height_idxs[1]])
+        except ValueError:
             return None
 
         if height < 0 or width < 0:
@@ -630,7 +642,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
         """!Find start and end index of parameter and it's value in url string
         """
         start_i = params_str.lower().find(param_key)
-        if start_i < 0: 
+        if start_i < 0:
             return None
         end_i = params_str.find("&", start_i)
         if end_i < 0:

scripts/r.in.wms/wms_gdal_drv.py

@@ -1,5 +1,5 @@
 """!
-@brief GDAL WMS driver. 
+@brief GDAL WMS driver.
 
 List of classes:
  - wms_drv::NullDevice
@@ -14,7 +14,7 @@ This program is free software under the GNU General Public License
 """
 
 import os
-import grass.script as grass 
+import grass.script as grass
 
 try:
     from osgeo import gdal
@@ -26,129 +26,133 @@ import xml.etree.ElementTree as etree
 
 from wms_base import WMSBase, GetSRSParamVal
 
+
 class NullDevice():
+
     def write(self, s):
         pass
 
+
 class WMSGdalDrv(WMSBase):
+
     def _createXML(self):
         """!Create XML for GDAL WMS driver
-        
+
         @return path to XML file
         """
         self._debug("_createXML", "started")
-        
+
         gdal_wms = etree.Element("GDAL_WMS")
         service = etree.SubElement(gdal_wms, "Service")
         name = etree.Element("name")
-        service.set("name","WMS")
-        
+        service.set("name", "WMS")
+
         version = etree.SubElement(service, "Version")
-        version.text =self.params['wms_version']
-        
+        version.text = self.params['wms_version']
+
         server_url = etree.SubElement(service, "ServerUrl")
-        server_url.text =self.params['url']
-        
-        srs = etree.SubElement(service, self.params['proj_name'])   
+        server_url.text = self.params['url']
+
+        srs = etree.SubElement(service, self.params['proj_name'])
         srs.text = GetSRSParamVal(self.params['srs'])
-        
+
         image_format = etree.SubElement(service, "ImageFormat")
         image_format.text = self.params['format']
-        
+
         image_format = etree.SubElement(service, "Transparent")
         image_format.text = self.params['transparent']
-        
+
         layers = etree.SubElement(service, "Layers")
         layers.text = self.params['layers']
-        
+
         styles = etree.SubElement(service, "Styles")
         styles.text = self.params['styles']
-        
+
         data_window = etree.SubElement(gdal_wms, "DataWindow")
 
         upper_left_x = etree.SubElement(data_window, "UpperLeftX")
-        upper_left_x.text = str(self.bbox['minx']) 
-        
+        upper_left_x.text = str(self.bbox['minx'])
+
         upper_left_y = etree.SubElement(data_window, "UpperLeftY")
-        upper_left_y.text = str(self.bbox['maxy']) 
-        
+        upper_left_y.text = str(self.bbox['maxy'])
+
         lower_right_x = etree.SubElement(data_window, "LowerRightX")
-        lower_right_x.text = str(self.bbox['maxx']) 
-        
+        lower_right_x.text = str(self.bbox['maxx'])
+
         lower_right_y = etree.SubElement(data_window, "LowerRightY")
         lower_right_y.text = str(self.bbox['miny'])
-        
+
         size_x = etree.SubElement(data_window, "SizeX")
-        size_x.text = str(self.region['cols']) 
-        
+        size_x.text = str(self.region['cols'])
+
         size_y = etree.SubElement(data_window, "SizeY")
-        size_y.text = str(self.region['rows']) 
-        
+        size_y.text = str(self.region['rows'])
+
         # RGB + alpha
         self.temp_map_bands_num = 4
         block_size_x = etree.SubElement(gdal_wms, "BandsCount")
         block_size_x.text = str(self.temp_map_bands_num)
-        
+
         block_size_x = etree.SubElement(gdal_wms, "BlockSizeX")
-        block_size_x.text = str(self.tile_size['cols']) 
-        
+        block_size_x.text = str(self.tile_size['cols'])
+
         block_size_y = etree.SubElement(gdal_wms, "BlockSizeY")
         block_size_y.text = str(self.tile_size['rows'])
-        
+
         xml_file = self._tempfile()
-        
+
         etree.ElementTree(gdal_wms).write(xml_file)
-        
+
         self._debug("_createXML", "finished -> %s" % xml_file)
-        
+
         return xml_file
-    
+
     def _download(self):
         """!Downloads data from WMS server using GDAL WMS driver
-        
+
         @return temp_map with stored downloaded data
         """
         grass.message("Downloading data from WMS server...")
 
-        # GDAL WMS driver does not flip geographic coordinates 
+        # GDAL WMS driver does not flip geographic coordinates
         # according to WMS standard 1.3.0.
-        if ("+proj=latlong" in self.proj_srs or \
-            "+proj=longlat" in self.proj_srs) and \
-            self.params['wms_version'] == "1.3.0":
+        if ("+proj=latlong" in self.proj_srs or
+                "+proj=longlat" in self.proj_srs) and \
+                self.params['wms_version'] == "1.3.0":
             grass.warning(_("If module will not be able to fetch the data in this " +
                             "geographic projection, \n try 'WMS_GRASS' driver or use WMS version 1.1.1."))
 
         self._debug("_download", "started")
-        
-        temp_map = self._tempfile()        
+
+        temp_map = self._tempfile()
 
         xml_file = self._createXML()
         wms_dataset = gdal.Open(xml_file, gdal.GA_ReadOnly)
         grass.try_remove(xml_file)
         if wms_dataset is None:
             grass.fatal(_("Unable to open GDAL WMS driver"))
-        
+
         self._debug("_download", "GDAL dataset created")
-        
+
         driver = gdal.GetDriverByName(self.gdal_drv_format)
         if driver is None:
             grass.fatal(_("Unable to find %s driver" % format))
-        
+
         metadata = driver.GetMetadata()
-        if not metadata.has_key(gdal.DCAP_CREATECOPY) or \
+        if gdal.DCAP_CREATECOPY not in metadata or \
            metadata[gdal.DCAP_CREATECOPY] == 'NO':
             grass.fatal(_('Driver %s supports CreateCopy() method.') % self.gdal_drv_name)
-        
+
         self._debug("_download", "calling GDAL CreateCopy...")
-        
+
         temp_map_dataset = driver.CreateCopy(temp_map, wms_dataset, 0)
-        
+
         if temp_map_dataset is None:
             grass.fatal(_("Incorrect WMS query"))
-        
-        temp_map_dataset  = None
+
+        temp_map_dataset = None
         wms_dataset = None
-        
+
         self._debug("_download", "finished")
-        
+
         return temp_map

scripts/r.mask/r.mask.py

@@ -75,11 +75,12 @@ from grass.exceptions import CalledModuleError
 
 def cleanup():
     if tmp:
-        grass.run_command('g.remove', flags = 'f', type = 'raster',
-                          name = tmp, quiet = True)
+        grass.run_command('g.remove', flags='f', type='raster',
+                          name=tmp, quiet=True)
     if tmp_hull:
-        grass.run_command('g.remove', flags = 'f', type = 'vector',
-                          name = tmp_hull, quiet = True)
+        grass.run_command('g.remove', flags='f', type='vector',
+                          name=tmp_hull, quiet=True)
+
 
 def main():
     raster = options['raster']
@@ -95,13 +96,13 @@ def main():
         grass.fatal(_("Either parameter <raster> ot parameter <vector> is required"))
 
     mapset = grass.gisenv()['MAPSET']
-    exists = bool(grass.find_file('MASK', element = 'cell', mapset = mapset)['file'])
+    exists = bool(grass.find_file('MASK', element='cell', mapset=mapset)['file'])
 
     if remove:
         # -> remove
         if exists:
-            grass.run_command('g.remove', flags = 'f', quiet = True,
-                              type = 'raster', name = 'MASK')
+            grass.run_command('g.remove', flags='f', quiet=True,
+                              type='raster', name='MASK')
             grass.message(_("Raster MASK removed"))
         else:
             grass.fatal(_("No existing MASK to remove"))
@@ -112,9 +113,9 @@ def main():
                 grass.fatal(_("MASK already found in current mapset. Delete first or overwrite."))
             else:
                 grass.warning(_("MASK already exists and will be overwritten"))
-                grass.run_command('g.remove', flags = 'f', quiet = True,
-                                  type = 'raster', name = 'MASK')
-        
+                grass.run_command('g.remove', flags='f', quiet=True,
+                                  type='raster', name='MASK')
+
         if raster:
             # check if input raster exists
             if not grass.find_file(raster)['file']:
@@ -125,7 +126,12 @@ def main():
                     grass.fatal(_("The raster map <%s> must be integer (CELL type) "
                                   " in order to use the 'maskcats' parameter") % raster)
 
-            p = grass.feed_command('r.reclass', input = raster, output = 'MASK', overwrite = True, rules = '-')
+            p = grass.feed_command(
+                'r.reclass',
+                input=raster,
+                output='MASK',
+                overwrite=True,
+                rules='-')
             p.stdin.write("%s = 1" % maskcats)
             p.stdin.close()
             p.wait()
@@ -133,13 +139,13 @@ def main():
             vector_name = grass.find_file(vector, 'vector')['fullname']
             if not vector_name:
                 grass.fatal(_("Vector map <%s> not found") % vector)
-            
+
             # parser bug?
             if len(cats) == 0:
                 cats = None
             if len(where) == 0:
                 where = None
-            
+
             if grass.vector_info_topo(vector_name)['areas'] < 1:
                 grass.warning(_("No area found in vector map <%s>. "
                                 "Creating a convex hull for MASK.") % vector_name)
@@ -152,23 +158,25 @@ def main():
                                       input=vector_name, output=tmp_hull,
                                       layer=layer, cats=cats, where=where)
                 except CalledModuleError:
-                    grass.fatal(_("Unable to create a convex hull for vector map <%s>") % vector_name)
+                    grass.fatal(
+                        _("Unable to create a convex hull for vector map <%s>") %
+                        vector_name)
             else:
                 to_rast_input = vector_name
-            
+
             env = os.environ.copy()
             if grass.verbosity() > 1:
                 env['GRASS_VERBOSE'] = '1'
-            grass.run_command('v.to.rast', input = to_rast_input, layer = layer,
-                              output = 'MASK', use = 'val', val = '1',
-                              type = 'area', cats = cats, where = where, env = env)
-        
+            grass.run_command('v.to.rast', input=to_rast_input, layer=layer,
+                              output='MASK', use='val', val='1',
+                              type='area', cats=cats, where=where, env=env)
+
         if invert:
             global tmp
             tmp = "r_mask_%d" % os.getpid()
-            grass.run_command('g.rename', raster = ('MASK', tmp), quiet = True)
+            grass.run_command('g.rename', raster=('MASK', tmp), quiet=True)
             grass.message(_("Creating inverted raster MASK..."))
-            grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp = tmp)
+            grass.mapcalc("MASK = if(isnull($tmp), 1, null())", tmp=tmp)
             grass.verbose(_("Inverted raster MASK created"))
         else:
             grass.verbose(_("Raster MASK created"))

scripts/r.out.xyz/r.out.xyz.py

@@ -37,6 +37,7 @@ import sys
 from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
+
 def main():
     # if no output filename, output to stdout
     output = options['output']

scripts/r.pack/r.pack.py

@@ -40,9 +40,11 @@ import tarfile
 from grass.script.utils import try_rmdir, try_remove
 from grass.script import core as grass
 
+
 def cleanup():
     try_rmdir(tmp)
 
+
 def main():
     infile = options['input']
     compression_off = flags['c']
@@ -54,30 +56,30 @@ def main():
         outfile_path, outfile_base = os.path.split(os.path.abspath(options['output']))
     else:
         outfile_path, outfile_base = os.path.split(os.path.abspath(infile + ".pack"))
-    
+
     outfile = os.path.join(outfile_path, outfile_base)
-    
+
     global tmp
     tmp = grass.tempdir()
     tmp_dir = os.path.join(tmp, infile)
     os.mkdir(tmp_dir)
     grass.debug('tmp_dir = %s' % tmp_dir)
-    
-    gfile = grass.find_file(name = infile, element = 'cell', mapset = mapset)
+
+    gfile = grass.find_file(name=infile, element='cell', mapset=mapset)
     if not gfile['name']:
         grass.fatal(_("Raster map <%s> not found") % infile)
-    
+
     if os.path.exists(outfile):
         if os.getenv('GRASS_OVERWRITE'):
             grass.warning(_("Pack file <%s> already exists and will be overwritten") % outfile)
             try_remove(outfile)
         else:
             grass.fatal(_("option <output>: <%s> exists.") % outfile)
-    
+
     grass.message(_("Packing <%s> to <%s>...") % (gfile['fullname'], outfile))
     basedir = os.path.sep.join(os.path.normpath(gfile['file']).split(os.path.sep)[:-2])
-    olddir  = os.getcwd()
-    
+    olddir = os.getcwd()
+
     # copy elements
     for element in ['cats', 'cell', 'cellhd', 'colr', 'fcell', 'hist']:
         path = os.path.join(basedir, element, infile)
@@ -85,14 +87,14 @@ def main():
             grass.debug('copying %s' % path)
             shutil.copyfile(path,
                             os.path.join(tmp_dir, element))
-            
+
     if os.path.exists(os.path.join(basedir, 'cell_misc', infile)):
         shutil.copytree(os.path.join(basedir, 'cell_misc', infile),
                         os.path.join(tmp_dir, 'cell_misc'))
-        
+
     if not os.listdir(tmp_dir):
         grass.fatal(_("No raster map components found"))
-                    
+
     # copy projection info
     # (would prefer to use g.proj*, but this way is 5.3 and 5.7 compat)
     gisenv = grass.gisenv()
@@ -101,22 +103,22 @@ def main():
                             'PERMANENT', 'PROJ_' + support)
         if os.path.exists(path):
             shutil.copyfile(path, os.path.join(tmp_dir, 'PROJ_' + support))
-    
+
     # pack it all up
     os.chdir(tmp)
     if compression_off:
-        tar = tarfile.TarFile.open(name = outfile_base, mode = 'w:')
+        tar = tarfile.TarFile.open(name=outfile_base, mode='w:')
     else:
-        tar = tarfile.TarFile.open(name = outfile_base, mode = 'w:gz')
-    tar.add(infile, recursive = True)
+        tar = tarfile.TarFile.open(name=outfile_base, mode='w:gz')
+    tar.add(infile, recursive=True)
     tar.close()
     try:
         shutil.move(outfile_base, outfile)
     except shutil.Error as e:
         grass.fatal(e)
-        
+
     os.chdir(olddir)
-    
+
     grass.verbose(_("Raster map saved to '%s'" % outfile))
 
 

scripts/r.plane/r.plane.py

@@ -59,38 +59,37 @@
 #%end
 #%option
 #% key: type
-#% type: string 
+#% type: string
 #% options: CELL,FCELL,DCELL
 #% description: Type of raster map to be created
 #% answer: FCELL
 #%end
 
-import sys
-import os
 import math
 import string
-import grass.script as grass
+import grass.script as gscript
+
 
 def main():
     name = options['output']
     type = options['type']
     dip = float(options['dip'])
-    az  = float(options['azimuth'])
-    ea  = float(options['easting'])
-    no  = float(options['northing'])
-    el  = float(options['elevation'])
+    az = float(options['azimuth'])
+    ea = float(options['easting'])
+    no = float(options['northing'])
+    el = float(options['elevation'])
 
-    reg = grass.region()
+    # reg = gscript.region()
 
     ### test input values ###
     if abs(dip) >= 90:
-	grass.fatal(_("dip must be between -90 and 90."))
+        gscript.fatal(_("dip must be between -90 and 90."))
 
     if az < 0 or az >= 360:
-	grass.fatal(_("azimuth must be between 0 and 360"))
+        gscript.fatal(_("azimuth must be between 0 and 360"))
 
-    ### now the actual algorithm
-    az_r  = math.radians(-az)
+    # now the actual algorithm
+    az_r = math.radians(-az)
     sinaz = math.sin(az_r)
     cosaz = math.cos(az_r)
 
@@ -102,27 +101,28 @@ def main():
     kz = el - ea * sinaz * tandip - no * cosaz * tandip
 
     if type == "CELL":
-	round = "round"
-	dtype = "int"
+        round = "round"
+        dtype = "int"
     elif type == "FCELL":
-	round = ""
-	dtype = "float"
+        round = ""
+        dtype = "float"
     else:
-	round = ""
-	dtype = "double"
+        round = ""
+        dtype = "double"
 
-    grass.mapcalc("$name = $type($round(x() * $kx + y() * $ky + $kz))",
-		  name = name, type = dtype, round = round, kx = kx, ky = ky, kz = kz)
+    gscript.mapcalc("$name = $type($round(x() * $kx + y() * $ky + $kz))",
+                    name=name, type=dtype, round=round, kx=kx, ky=ky, kz=kz)
 
-    grass.run_command('r.support', map = name, history = '')
-    grass.raster_history(name)
+    gscript.run_command('r.support', map=name, history='')
+    gscript.raster_history(name)
 
-    grass.message(_("Done."))
-    t = string.Template("Raster map <$name> generated by r.plane " +
-			"at point $ea E, $no N, elevation $el with dip = $dip degrees and " +
-			"aspect = $az degrees ccw from north.")
-    grass.message(t.substitute(name = name, ea = ea, no = no, el = el, dip = dip, az = az))
+    gscript.message(_("Done."))
+    t = string.Template("Raster map <$name> generated by r.plane "
+                        "at point $ea E, $no N, elevation $el with dip = $dip"
+                        " degrees and aspect = $az degrees ccw from north.")
+    gscript.message(t.substitute(name=name, ea=ea, no=no, el=el, dip=dip,
+                                 az=az))
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/r.reclass.area/r.reclass.area.py

@@ -204,7 +204,7 @@ def main():
     limit = float(value)
     if mode == 'greater' and method == 'rmarea':
         grass.fatal(_("You have to specify mode='lesser' with method='rmarea'"))
-    
+
     if not grass.find_file(infile)['name']:
         grass.fatal(_("Raster map <%s> not found") % infile)
 

scripts/r.shade/r.shade.py

@@ -111,15 +111,17 @@ def main():
             relief_map = relief_map_tmp
             to_remove.append(relief_map_tmp)
         gcore.run_command('r.his', hue=drape_map, intensity=relief_map,
-                          red=tmp_r, green=tmp_g, blue=tmp_b, **rhis_extra_args)
+                          red=tmp_r, green=tmp_g, blue=tmp_b,
+                          **rhis_extra_args)
         to_remove.extend([tmp_r, tmp_g, tmp_b])
         gcore.run_command('r.composite', red=tmp_r, green=tmp_g,
                           blue=tmp_b, output=output_map)
         remove(to_remove)  # who knows if finally is called when exit
-    except CalledModuleError, error:
+    except CalledModuleError as error:
         remove(to_remove)
         # TODO: implement module name to CalledModuleError
-        gcore.fatal(_("Module %s failed. Check the above error messages.") % error.cmd)
+        gcore.fatal(_("Module %s failed. Check the above error messages.") %
+                    error.cmd)
 
 
 if __name__ == "__main__":

scripts/r.tileset/r.tileset.py

@@ -106,13 +106,14 @@
 # An array of points indexed by 0 for "x" and 4 for "y" + by number 0, 1, 2, and 3
 # A reprojector [0] is name of source projection, [1] is name of destination
 # A projection - [0] is proj.4 text, [1] is scale
+from __future__ import print_function
 
 import sys
 import tempfile
 import math
 
 from grass.script.utils import separator
-from grass.script import core as grass
+from grass.script import core as gcore
 from grass.exceptions import CalledModuleError
 
 
@@ -158,7 +159,7 @@ def project(file, source, dest):
     errors = 0
     points = []
     try:
-        ret = grass.read_command('m.proj',
+        ret = gcore.read_command('m.proj',
                                  quiet=True,
                                  flags='d',
                                  proj_in=source['proj'],
@@ -166,10 +167,10 @@ def project(file, source, dest):
                                  sep=';',
                                  input=file)
     except CalledModuleError:
-        grass.fatal(cs2cs + ' failed')
+        gcore.fatal(cs2cs + ' failed')
 
     if not ret:
-        grass.fatal(cs2cs + ' failed')
+        gcore.fatal(cs2cs + ' failed')
 
     for line in ret.splitlines():
         if "*" in line:
@@ -238,40 +239,42 @@ def main():
     max_rows = int(options['maxrows']) - int(options['overlap'])
 
     if max_cols == 0:
-        grass.fatal(_("It is not possibile to set 'maxcols=%s' and "
+        gcore.fatal(_("It is not possibile to set 'maxcols=%s' and "
                       "'overlap=%s'. Please set maxcols>overlap" %
                       (options['maxcols'], options['overlap'])))
     elif max_rows == 0:
-        grass.fatal(_("It is not possibile to set 'maxrows=%s' and "
+        gcore.fatal(_("It is not possibile to set 'maxrows=%s' and "
                       "'overlap=%s'. Please set maxrows>overlap" %
                       (options['maxrows'], options['overlap'])))
     # destination projection
     if not options['destproj']:
-        dest_proj = grass.read_command('g.proj',
+        dest_proj = gcore.read_command('g.proj',
                                        quiet=True,
                                        flags='jf').rstrip('\n')
         if not dest_proj:
-            grass.fatal(_('g.proj failed'))
+            gcore.fatal(_('g.proj failed'))
     else:
         dest_proj = options['destproj']
-    grass.debug("Getting destination projection -> '%s'" % dest_proj)
+    gcore.debug("Getting destination projection -> '%s'" % dest_proj)
 
     # projection scale
     if not options['destscale']:
-        ret = grass.parse_command('g.proj',
+        ret = gcore.parse_command('g.proj',
                                   quiet=True,
                                   flags='j')
         if not ret:
-            grass.fatal(_('g.proj failed'))
+            gcore.fatal(_('g.proj failed'))
 
         if '+to_meter' in ret:
             dest_scale = ret['+to_meter'].strip()
         else:
-            grass.warning(_("Scale (%s) not found, assuming '1'") % '+to_meter')
+            gcore.warning(
+                _("Scale (%s) not found, assuming '1'") %
+                '+to_meter')
             dest_scale = '1'
     else:
         dest_scale = options['destscale']
-    grass.debug('Getting destination projection scale -> %s' % dest_scale)
+    gcore.debug('Getting destination projection scale -> %s' % dest_scale)
 
     # set up the projections
     srs_source = {'proj': options['sourceproj'],
@@ -279,17 +282,17 @@ def main():
     srs_dest = {'proj': dest_proj, 'scale': float(dest_scale)}
 
     if options['region']:
-        grass.run_command('g.region',
+        gcore.run_command('g.region',
                           quiet=True,
                           region=options['region'])
-    dest_bbox = grass.region()
-    grass.debug('Getting destination region')
+    dest_bbox = gcore.region()
+    gcore.debug('Getting destination region')
 
     # output field separator
     fs = separator(options['separator'])
 
     # project the destination region into the source:
-    grass.verbose('Projecting destination region into source...')
+    gcore.verbose('Projecting destination region into source...')
     dest_bbox_points = bboxToPoints(dest_bbox)
 
     dest_bbox_source_points, errors_dest = projectPoints(dest_bbox_points,
@@ -297,24 +300,24 @@ def main():
                                                          dest=srs_source)
 
     if len(dest_bbox_source_points) == 0:
-        grass.fatal(_("There are no tiles available. Probably the output "
+        gcore.fatal(_("There are no tiles available. Probably the output "
                       "projection system it is not compatible with the "
                       "projection of the current location"))
 
     source_bbox = pointsToBbox(dest_bbox_source_points)
 
-    grass.verbose('Projecting source bounding box into destination...')
+    gcore.verbose('Projecting source bounding box into destination...')
 
     source_bbox_points = bboxToPoints(source_bbox)
 
     source_bbox_dest_points, errors_source = projectPoints(source_bbox_points,
-                                                            source=srs_source,
-                                                            dest=srs_dest)
+                                                           source=srs_source,
+                                                           dest=srs_dest)
 
     x_metric = 1 / dest_bbox['ewres']
     y_metric = 1 / dest_bbox['nsres']
 
-    grass.verbose('Computing length of sides of source bounding box...')
+    gcore.verbose('Computing length of sides of source bounding box...')
 
     source_bbox_dest_lengths = sideLengths(source_bbox_dest_points,
                                            x_metric, y_metric)
@@ -324,12 +327,14 @@ def main():
     # In the direction (x or y) in which the world is least skewed (ie north south in lat long)
     # Divide the world into strips. These strips are as big as possible contrained by max_
     # In the other direction do the same thing.
-    # Theres some recomputation of the size of the world that's got to come in here somewhere.
+    # Theres some recomputation of the size of the world that's got to come in
+    # here somewhere.
 
     # For now, however, we are going to go ahead and request more data than is necessary.
     # For small regions far from the critical areas of projections this makes very little difference
     # in the amount of data gotten.
-    # We can make this efficient for big regions or regions near critical points later.
+    # We can make this efficient for big regions or regions near critical
+    # points later.
 
     bigger = []
     bigger.append(max(source_bbox_dest_lengths['x']))
@@ -342,7 +347,7 @@ def main():
     # I'm going to make the numbers all simpler and add this extra cell to
     # every tile.
 
-    grass.message(_('Computing tiling...'))
+    gcore.message(_('Computing tiling...'))
     tiles = [-1, -1]
     tile_base_size = [-1, -1]
     tiles_extra_1 = [-1, -1]
@@ -363,7 +368,7 @@ def main():
         # Add overlap to tiles (doesn't effect tileset_size
         tile_size_overlap[i] = tile_size[i] + int(options['overlap'])
 
-    grass.verbose("There will be %d by %d tiles each %d by %d cells" %
+    gcore.verbose("There will be %d by %d tiles each %d by %d cells" %
                   (tiles[0], tiles[1], tile_size[0], tile_size[1]))
 
     ximax = tiles[0]
@@ -380,16 +385,21 @@ def main():
     tile_bbox = {'w': -1, 's': -1, 'e': -1, 'n': -1}
 
     if errors_dest > 0:
-        grass.warning(_("During computation %i tiles could not be created" %
+        gcore.warning(_("During computation %i tiles could not be created" %
                         errors_dest))
 
     while xi < ximax:
-        tile_bbox['w'] = float(min_x) + (float(xi) * float(tile_size[0]) / float(tileset_size[0])) * float(span_x)
-        tile_bbox['e'] = float(min_x) + (float(xi + 1) * float(tile_size_overlap[0]) / float(tileset_size[0])) * float(span_x)
+        tile_bbox['w'] = float(
+            min_x) + (float(xi) * float(tile_size[0]) / float(tileset_size[0])) * float(span_x)
+        tile_bbox['e'] = float(min_x) + (float(xi + 1) * float(tile_size_overlap[0]
+                                                               ) / float(tileset_size[0])) * float(span_x)
         yi = 0
         while yi < yimax:
-            tile_bbox['s'] = float(min_y) + (float(yi) * float(tile_size[1]) / float(tileset_size[1])) * float(span_y)
-            tile_bbox['n'] = float(min_y) + (float(yi + 1) * float(tile_size_overlap[1]) / float(tileset_size[1])) * float(span_y)
+            tile_bbox['s'] = float(
+                min_y) + (float(yi) * float(tile_size[1]) / float(tileset_size[1])) * float(span_y)
+            tile_bbox['n'] = float(min_y) + (
+                float(yi + 1) * float(tile_size_overlap[1]) /
+                float(tileset_size[1])) * float(span_y)
             tile_bbox_points = bboxToPoints(tile_bbox)
             tile_dest_bbox_points, errors = projectPoints(tile_bbox_points,
                                                           source=srs_source,
@@ -397,24 +407,24 @@ def main():
             tile_dest_bbox = pointsToBbox(tile_dest_bbox_points)
             if bboxesIntersect(tile_dest_bbox, dest_bbox):
                 if flags['w']:
-                    print "bbox=%s,%s,%s,%s&width=%s&height=%s" % \
+                    print("bbox=%s,%s,%s,%s&width=%s&height=%s" %
                           (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'],
                            tile_bbox['n'], tile_size_overlap[0],
-                           tile_size_overlap[1])
+                           tile_size_overlap[1]))
                 elif flags['g']:
-                    print "w=%s;s=%s;e=%s;n=%s;cols=%s;rows=%s" % \
+                    print("w=%s;s=%s;e=%s;n=%s;cols=%s;rows=%s" %
                           (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'],
                            tile_bbox['n'], tile_size_overlap[0],
-                           tile_size_overlap[1])
+                           tile_size_overlap[1]))
                 else:
-                    print "%s%s%s%s%s%s%s%s%s%s%s" % \
+                    print("%s%s%s%s%s%s%s%s%s%s%s" %
                           (tile_bbox['w'], fs, tile_bbox['s'], fs,
                            tile_bbox['e'], fs, tile_bbox['n'], fs,
-                           tile_size_overlap[0], fs, tile_size_overlap[1])
+                           tile_size_overlap[0], fs, tile_size_overlap[1]))
             yi += 1
         xi += 1
 
 if __name__ == "__main__":
     cs2cs = 'cs2cs'
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     sys.exit(main())

scripts/r.unpack/r.unpack.py

@@ -82,7 +82,8 @@ def main():
         if os.environ.get('GRASS_OVERWRITE', '0') != '1':
             grass.fatal(_('Raster map <{name}> already exists'.format(name=map_name)))
         else:
-            grass.warning(_('Raster map <{name}> already exists and will be overwritten'.format(name=map_name)))
+            grass.warning(
+                _('Raster map <{name}> already exists and will be overwritten'.format(name=map_name)))
 
     # extract data
     tar.extractall()
@@ -100,36 +101,37 @@ def main():
 
     if flags['o']:
         grass.warning(_("Overriding projection check (using current location's projection)."))
-        
+
     else:
-        
+
         diff_result_1 = diff_result_2 = None
-        
+
         proj_info_file_1 = 'PROJ_INFO'
         proj_info_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
 
         skip_projection_check = False
         if not os.path.exists(proj_info_file_1):
             if os.path.exists(proj_info_file_2):
-                grass.fatal(_("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."))
+                grass.fatal(
+                    _("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."))
             skip_projection_check = True  # XY location
 
         if not skip_projection_check:
             if not grass.compare_key_value_text_files(filename_a=proj_info_file_1,
                                                       filename_b=proj_info_file_2,
-                                                      proj=True):                                                      
+                                                      proj=True):
                 diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
-        
+
             proj_units_file_1 = 'PROJ_UNITS'
             proj_units_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
-        
+
             if not grass.compare_key_value_text_files(filename_a=proj_units_file_1,
                                                       filename_b=proj_units_file_2,
-                                                      units=True):                                                      
+                                                      units=True):
                 diff_result_2 = diff_files(proj_units_file_1, proj_units_file_2)
-        
+
             if diff_result_1 or diff_result_2:
-                
+
                 if diff_result_1:
                     grass.warning(_("Difference between PROJ_INFO file of packed map "
                                     "and of current location:\n{diff}").format(diff=''.join(diff_result_1)))

scripts/r3.in.xyz/r3.in.xyz.py

@@ -280,7 +280,7 @@ def main():
                                       **addl_opts)
 
         grass.debug("i=%d, %%=%d  (workers=%d)" % (i, i % workers, workers))
-        #print sys.getsizeof(proc)  # sizeof(proc array)  [not so big]
+        # print sys.getsizeof(proc)  # sizeof(proc array)  [not so big]
 
         if i % workers is 0:
             # wait for the ones launched so far to finish
@@ -299,7 +299,7 @@ def main():
 
     grass.verbose(_("Assembling 3D cube ..."))
 
-    #input order: lower most strata first
+    # input order: lower most strata first
     slices = grass.read_command('g.list', type='raster', sep=',',
                                 pattern='tmp.r3xyz.%d.*' % os.getpid()).rstrip(os.linesep)
     grass.debug(slices)

scripts/v.build.all/v.build.all.py

@@ -22,6 +22,7 @@ import sys
 from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
+
 def main():
     env = grass.gisenv()
     mapset = env['MAPSET']
@@ -29,17 +30,17 @@ def main():
 
     vectors = grass.list_grouped('vect')[mapset]
     num_vectors = len(vectors)
-    
+
     if grass.verbosity() < 2:
         quiet = True
     else:
         quiet = False
-        
+
     i = 1
     for vect in vectors:
         map = "%s@%s" % (vect, mapset)
-        grass.message(_("%s\nBuilding topology for vector map <%s> (%d of %d)...\n%s") % \
-                          ('-' * 80, map, i, num_vectors, '-' * 80))
+        grass.message(_("%s\nBuilding topology for vector map <%s> (%d of %d)...\n%s") %
+                      ('-' * 80, map, i, num_vectors, '-' * 80))
         grass.verbose(_("v.build map=%s") % map)
         try:
             grass.run_command("v.build", map=map, quiet=quiet)

scripts/v.centroids/v.centroids.py

@@ -50,20 +50,19 @@
 #%end
 
 import sys
-import os
-import re
-import grass.script as grass
+import grass.script as gscript
+
 
 def main():
     if options['option'] == 'add':
-        num_bound = grass.vector_info_topo(map = options['input'])['boundaries']
-	if num_bound == 0:
-	    grass.fatal(_("Input vector map contains no boundaries."))
+        num_bound = gscript.vector_info_topo(map=options['input'])['boundaries']
+        if num_bound == 0:
+            gscript.fatal(_("Input vector map contains no boundaries."))
 
-	grass.exec_command("v.category", type = 'area', **options)
+        gscript.exec_command("v.category", type='area', **options)
 
     sys.exit(0)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/v.db.addcolumn/v.db.addcolumn.py

@@ -3,7 +3,7 @@
 ############################################################################
 #
 # MODULE:       v.db.addcolumnumn
-# AUTHOR(S):    Moritz Lennert 
+# AUTHOR(S):    Moritz Lennert
 #               Converted to Python by Glynn Clements
 # PURPOSE:      interface to db.execute to add a column to the attribute table
 #               connected to a given vector map
@@ -42,29 +42,31 @@ import sys
 import os
 import grass.script as grass
 
+
 def main():
-    map     = options['map']
-    layer   = options['layer']
+    map = options['map']
+    layer = options['layer']
     columns = options['columns']
     columns = [col.strip() for col in columns.split(',')]
-    
+
     # does map exist in CURRENT mapset?
     mapset = grass.gisenv()['MAPSET']
-    exists = bool(grass.find_file(map, element = 'vector', mapset = mapset)['file'])
-    
+    exists = bool(grass.find_file(map, element='vector', mapset=mapset)['file'])
+
     if not exists:
         grass.fatal(_("Vector map <%s> not found in current mapset") % map)
-    
+
     try:
         f = grass.vector_db(map)[int(layer)]
     except KeyError:
-        grass.fatal(_("There is no table connected to this map. Run v.db.connect or v.db.addtable first."))
-    
-    table    = f['table']
+        grass.fatal(
+            _("There is no table connected to this map. Run v.db.connect or v.db.addtable first."))
+
+    table = f['table']
     database = f['database']
-    driver   = f['driver']
-    column_existing = grass.vector_columns(map, int(layer)).keys()    
-    
+    driver = f['driver']
+    column_existing = grass.vector_columns(map, int(layer)).keys()
+
     for col in columns:
         if not col:
             grass.fatal(_("There is an empty column. Did you leave a trailing comma?"))
@@ -73,13 +75,13 @@ def main():
             grass.error(_("Column <%s> is already in the table. Skipping.") % col_name)
             continue
         grass.verbose(_("Adding column <%s> to the table") % col_name)
-        p = grass.feed_command('db.execute', input = '-', database = database, driver = driver)
+        p = grass.feed_command('db.execute', input='-', database=database, driver=driver)
         p.stdin.write("ALTER TABLE %s ADD COLUMN %s" % (table, col))
         grass.debug("ALTER TABLE %s ADD COLUMN %s" % (table, col))
         p.stdin.close()
         if p.wait() != 0:
             grass.fatal(_("Unable to add column <%s>.") % col)
-    
+
     # write cmd history:
     grass.vector_history(map)
 

scripts/v.db.addtable/v.db.addtable.py

@@ -3,7 +3,7 @@
 ############################################################################
 #
 # MODULE:       v.db.addtable
-# AUTHOR(S):    Markus Neteler 
+# AUTHOR(S):    Markus Neteler
 #               Converted to Python by Glynn Clements
 #               Key column added by Martin Landa <landa.martin gmail.com>
 # PURPOSE:      interface to db.execute to creates and add a new table to given vector map
@@ -23,14 +23,14 @@
 #%end
 #%option G_OPT_V_MAP
 #%end
-#%option 
+#%option
 #% key: table
 #% type: string
 #% description: Name of new attribute table (default: vector map name)
 #% required: no
 #% guisection: Definition
 #%end
-#%option 
+#%option
 #% key: layer
 #% type: integer
 #% description: Layer number where to add new attribute table
@@ -64,14 +64,14 @@ def main():
     layer = options['layer']
     columns = options['columns']
     key = options['key']
-    
+
     # does map exist in CURRENT mapset?
     mapset = grass.gisenv()['MAPSET']
-    if not grass.find_file(vector, element = 'vector', mapset = mapset)['file']:
+    if not grass.find_file(vector, element='vector', mapset=mapset)['file']:
         grass.fatal(_("Vector map <%s> not found in current mapset") % vector)
-    
+
     map_name = vector.split('@')[0]
-    
+
     if not table:
         if layer == '1':
             grass.verbose(_("Using vector map name as table name: <%s>") % map_name)
@@ -79,44 +79,46 @@ def main():
         else:
             # to avoid tables with identical names on higher layers
             table = "%s_%s" % (map_name, layer)
-            grass.verbose(_("Using vector map name extended by layer number as table name: <%s>") % table)
+            grass.verbose(
+                _("Using vector map name extended by layer number as table name: <%s>") %
+                table)
     else:
         grass.verbose(_("Using user specified table name: %s") % table)
-    
+
     # check if DB parameters are set, and if not set them.
-    grass.run_command('db.connect', flags = 'c')
+    grass.run_command('db.connect', flags='c')
     grass.verbose(_("Creating new DB connection based on default mapset settings..."))
     kv = grass.db_connection()
     database = kv['database']
     driver = kv['driver']
     schema = kv['schema']
-    
+
     # maybe there is already a table linked to the selected layer?
     nuldev = file(os.devnull, 'w')
     try:
-        grass.vector_db(map_name, stderr = nuldev)[int(layer)]
+        grass.vector_db(map_name, stderr=nuldev)[int(layer)]
         grass.fatal(_("There is already a table linked to layer <%s>") % layer)
     except KeyError:
         pass
-    
+
     # maybe there is already a table with that name?
-    tables = grass.read_command('db.tables', flags = 'p', database = database, driver = driver,
-                                stderr = nuldev)
-    
+    tables = grass.read_command('db.tables', flags='p', database=database, driver=driver,
+                                stderr=nuldev)
+
     if not table in tables.splitlines():
         if columns:
             column_def = [x.strip().lower() for x in columns.strip().split(',')]
         else:
             column_def = []
-        
+
         # if not existing, create it:
         column_def_key = "%s integer" % key
         if column_def_key not in column_def:
             column_def.insert(0, column_def_key)
         column_def = ','.join(column_def)
-        
+
         grass.verbose(_("Creating table with columns (%s)...") % column_def)
-        
+
         sql = "CREATE TABLE %s (%s)" % (table, column_def)
         try:
             grass.run_command('db.execute',
@@ -127,22 +129,22 @@ def main():
     # connect the map to the DB:
     if schema:
         table = '{schema}.{table}'.format(schema=schema, table=table)
-    grass.run_command('v.db.connect', quiet = True,
-                      map = map_name, database = database, driver = driver,
-                      layer = layer, table = table, key = key)
-    
+    grass.run_command('v.db.connect', quiet=True,
+                      map=map_name, database=database, driver=driver,
+                      layer=layer, table=table, key=key)
+
     # finally we have to add cats into the attribute DB to make modules such as v.what.rast happy:
     # (creates new row for each vector line):
-    grass.run_command('v.to.db', map = map_name, layer = layer,
-                      option = 'cat', column = key, qlayer = layer)
-    
+    grass.run_command('v.to.db', map=map_name, layer=layer,
+                      option='cat', column=key, qlayer=layer)
+
     grass.verbose(_("Current attribute table links:"))
     if grass.verbosity() > 2:
-        grass.run_command('v.db.connect', flags = 'p', map = map_name)
-    
+        grass.run_command('v.db.connect', flags='p', map=map_name)
+
     # write cmd history:
     grass.vector_history(map_name)
-    
+
     return 0
 
 if __name__ == "__main__":

scripts/v.db.dropcolumn/v.db.dropcolumn.py

@@ -5,7 +5,7 @@
 # MODULE:       v.db.dropcolumn
 # AUTHOR(S):    Markus Neteler
 #               Converted to Python by Glynn Clements
-# PURPOSE:      interface to db.execute to drop a column from the 
+# PURPOSE:      interface to db.execute to drop a column from the
 #               attribute table connected to a given vector map
 #               - Based on v.db.addcolumn
 #               - with special trick for SQLite
@@ -45,43 +45,43 @@ from grass.exceptions import CalledModuleError
 
 
 def main():
-    map    = options['map']
-    layer  = options['layer']
+    map = options['map']
+    layer = options['layer']
     columns = options['columns'].split(',')
-    
+
     mapset = grass.gisenv()['MAPSET']
-    
+
     # does map exist in CURRENT mapset?
-    if not grass.find_file(map, element = 'vector', mapset = mapset)['file']:
+    if not grass.find_file(map, element='vector', mapset=mapset)['file']:
         grass.fatal(_("Vector map <%s> not found in current mapset") % map)
-    
+
     f = grass.vector_layer_db(map, layer)
-    
+
     table = f['table']
     keycol = f['key']
     database = f['database']
     driver = f['driver']
-    
+
     if not table:
         grass.fatal(_("There is no table connected to the input vector map. "
                       "Unable to delete any column. Exiting."))
-    
+
     if keycol in columns:
         grass.fatal(_("Unable to delete <%s> column as it is needed to keep table <%s> "
-                      "connected to the input vector map <%s>") % \
-                        (keycol, table, map))
-    
+                      "connected to the input vector map <%s>") %
+                    (keycol, table, map))
+
     for column in columns:
-        if not grass.vector_columns(map, layer).has_key(column):
+        if column not in grass.vector_columns(map, layer):
             grass.warning(_("Column <%s> not found in table <%s>. Skipped") % (column, table))
             continue
-        
+
         if driver == "sqlite":
             # echo "Using special trick for SQLite"
             # http://www.sqlite.org/faq.html#q11
             colnames = []
             coltypes = []
-            for f in grass.db_describe(table, database = database, driver = driver)['cols']:
+            for f in grass.db_describe(table, database=database, driver=driver)['cols']:
                 if f[0] == column:
                     continue
                 colnames.append(f[0])
@@ -100,21 +100,21 @@ def main():
                 "CREATE UNIQUE INDEX ${table}_cat ON ${table} (${keycol} )",
                 "DROP TABLE ${table}_backup",
                 "COMMIT"
-                ]
+            ]
             tmpl = string.Template(';\n'.join(cmds))
-            sql = tmpl.substitute(table = table, coldef = coltypes, colnames = colnames, keycol = keycol)
+            sql = tmpl.substitute(table=table, coldef=coltypes, colnames=colnames, keycol=keycol)
         else:
             sql = "ALTER TABLE %s DROP COLUMN %s" % (table, column)
 
         try:
-            grass.write_command('db.execute', input = '-', database = database, driver = driver,
-                                stdin = sql)
+            grass.write_command('db.execute', input='-', database=database, driver=driver,
+                                stdin=sql)
         except CalledModuleError:
             grass.fatal(_("Deleting column failed"))
-    
+
     # write cmd history:
     grass.vector_history(map)
-    
+
 if __name__ == "__main__":
     options, flags = grass.parser()
     main()

scripts/v.db.droprow/v.db.droprow.py

@@ -51,7 +51,7 @@ def main():
         return 1
 
     # write cmd history:
-    grass.vector_history(map = options['output'])
+    grass.vector_history(map=options['output'])
 
     return 0
 

scripts/v.db.droptable/v.db.droptable.py

@@ -3,7 +3,7 @@
 ############################################################################
 #
 # MODULE:       v.db.droptable
-# AUTHOR(S):   	Markus Neteler 
+# AUTHOR(S):   	Markus Neteler
 #               Converted to Python by Glynn Clements
 # PURPOSE:      interface to db.execute to drop an existing table of given vector map
 # COPYRIGHT:    (C) 2005, 2008 by the GRASS Development Team
@@ -36,7 +36,7 @@
 
 import sys
 import os
-import grass.script as grass
+import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
 
@@ -47,56 +47,58 @@ def main():
     layer = options['layer']
 
     # do some paranoia tests as well:
-    f = grass.vector_layer_db(map, layer)
-    
+    f = gscript.vector_layer_db(map, layer)
+
     if not table:
-	# Removing table name connected to selected layer
-	table = f['table']
-	if not table:
-	    grass.fatal(_("No table assigned to layer <%s>") % layer)
+        # Removing table name connected to selected layer
+        table = f['table']
+        if not table:
+            gscript.fatal(_("No table assigned to layer <%s>") % layer)
     else:
-	# Removing user specified table
-	existingtable = f['table']
-	if existingtable != table:
-	    grass.fatal(_("User selected table <%s> but the table <%s> is linked to layer <%s>")
-			% (table, existingtable, layer))
-
-    # we use the DB settings selected layer 
+        # Removing user specified table
+        existingtable = f['table']
+        if existingtable != table:
+            gscript.fatal(_("User selected table <%s> but the table <%s> "
+                            "is linked to layer <%s>") %
+                          (table, existingtable, layer))
+
+    # we use the DB settings selected layer
     database = f['database']
     driver = f['driver']
 
-    grass.message(_("Removing table <%s> linked to layer <%s> of vector map <%s>")
-		  % (table, layer, map)) 
+    gscript.message(_("Removing table <%s> linked to layer <%s> of vector"
+                      " map <%s>") % (table, layer, map))
 
     if not force:
-	grass.message(_("You must use the -f (force) flag to actually remove the table. Exiting."))
-	grass.message(_("Leaving map/table unchanged."))
-	sys.exit(0)
+        gscript.message(_("You must use the -f (force) flag to actually "
+                          "remove the table. Exiting."))
+        gscript.message(_("Leaving map/table unchanged."))
+        sys.exit(0)
 
-    grass.message(_("Dropping table <%s>...") % table)
+    gscript.message(_("Dropping table <%s>...") % table)
 
     try:
-        grass.write_command('db.execute', stdin="DROP TABLE %s" % table,
-                            input='-', database=database, driver=driver)
+        gscript.write_command('db.execute', stdin="DROP TABLE %s" % table,
+                              input='-', database=database, driver=driver)
     except CalledModuleError:
-        grass.fatal(_("An error occurred while running db.execute"))
+        gscript.fatal(_("An error occurred while running db.execute"))
 
-    grass.run_command('v.db.connect', flags = 'd', map = map, layer = layer)
+    gscript.run_command('v.db.connect', flags='d', map=map, layer=layer)
 
-    grass.message(_("Current attribute table link(s):")) 
+    gscript.message(_("Current attribute table link(s):"))
     # silently test first to avoid confusing error messages
     nuldev = file(os.devnull, 'w')
     try:
-        grass.run_command('v.db.connect', flags='p', map=map, quiet=True,
-                          stdout=nuldev, stderr=nuldev)
+        gscript.run_command('v.db.connect', flags='p', map=map, quiet=True,
+                            stdout=nuldev, stderr=nuldev)
     except CalledModuleError:
-        grass.message(_("(No database links remaining)"))
+        gscript.message(_("(No database links remaining)"))
     else:
-        grass.run_command('v.db.connect', flags='p', map=map)
+        gscript.run_command('v.db.connect', flags='p', map=map)
 
     # write cmd history:
-    grass.vector_history(map)
+    gscript.vector_history(map)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     main()

scripts/v.db.join/v.db.join.py

@@ -80,7 +80,7 @@ def main():
         
     maptable = f['table']
     database = f['database']
-    driver   = f['driver']
+    driver = f['driver']
 
     if driver == 'dbf':
         grass.fatal(_("JOIN is not supported for tables stored in DBF format"))
@@ -89,7 +89,7 @@ def main():
         grass.fatal(_("There is no table connected to this map. Unable to join any column."))
 
     # check if column is in map table
-    if not grass.vector_columns(map, layer).has_key(column):
+    if column not in grass.vector_columns(map, layer):
         grass.fatal(_("Column <%s> not found in table <%s>") % (column,
                                                                 maptable))
 
@@ -157,7 +157,9 @@ def main():
                                    otable=otable, ocolumn=ocolumn,
                                    colname=colname)
         grass.debug(stmt, 1)
-        grass.verbose(_("Updating column <%s> of vector map <%s>...") % (colname, map))
+        grass.verbose(
+            _("Updating column <%s> of vector map <%s>...") %
+            (colname, map))
         try:
             grass.write_command('db.execute', stdin=stmt, input='-',
                                 database=database, driver=driver)

scripts/v.db.reconnect.all/v.db.reconnect.all.py

@@ -53,28 +53,32 @@ import sys
 import os
 import string
 
-import grass.script as grass
+import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
 # substitute variables (gisdbase, location_name, mapset)
+
+
 def substitute_db(database):
-    gisenv = grass.gisenv()
+    gisenv = gscript.gisenv()
     tmpl = string.Template(database)
 
-    return tmpl.substitute(GISDBASE = gisenv['GISDBASE'],
-                           LOCATION_NAME = gisenv['LOCATION_NAME'],
-                           MAPSET = gisenv['MAPSET'])
+    return tmpl.substitute(GISDBASE=gisenv['GISDBASE'],
+                           LOCATION_NAME=gisenv['LOCATION_NAME'],
+                           MAPSET=gisenv['MAPSET'])
 
 # create database if doesn't exist
+
+
 def create_db(driver, database):
     subst_database = substitute_db(database)
     if driver == 'dbf':
         path = subst_database
         # check if destination directory exists
         if not os.path.isdir(path):
-	    # create dbf database
+            # create dbf database
             os.makedirs(path)
-	    return True
+            return True
         return False
 
     if driver == 'sqlite':
@@ -83,77 +87,86 @@ def create_db(driver, database):
         if not os.path.isdir(path):
             os.makedirs(path)
 
-    if subst_database in grass.read_command('db.databases', quiet = True,
-                                      driver = driver).splitlines():
+    if subst_database in gscript.read_command('db.databases', quiet=True,
+                                              driver=driver).splitlines():
         return False
 
-    grass.info(_("Target database doesn't exist, "
-                 "creating a new database using <%s> driver...") % driver)
+    gscript.info(_("Target database doesn't exist, "
+                   "creating a new database using <%s> driver...") % driver)
     try:
-        grass.run_command('db.createdb', driver = driver,
-                          database = subst_database)
+        gscript.run_command('db.createdb', driver=driver,
+                            database=subst_database)
     except CalledModuleError:
-        grass.fatal(_("Unable to create database <%s> by driver <%s>") % \
-                        (subst_database, driver))
+        gscript.fatal(_("Unable to create database <%s> by driver <%s>") %
+                      (subst_database, driver))
 
     return False
 
 # copy tables if required (-c)
+
+
 def copy_tab(from_driver, from_database, from_table,
              to_driver, to_database, to_table):
-    if to_table in grass.read_command('db.tables', quiet = True,
-                                      driver = to_driver,
-                                      database = to_database,
-                                      stderr = nuldev).splitlines():
+    if to_table in gscript.read_command('db.tables', quiet=True,
+                                        driver=to_driver,
+                                        database=to_database,
+                                        stderr=nuldev).splitlines():
         return False
 
-    grass.info("Copying table <%s> to target database..." % to_table)
+    gscript.info("Copying table <%s> to target database..." % to_table)
     try:
-        grass.run_command('db.copy', from_driver = from_driver,
-                          from_database = from_database,
-                          from_table = from_table, to_driver = to_driver,
-                          to_database = to_database,
-                          to_table = to_table)
+        gscript.run_command('db.copy', from_driver=from_driver,
+                            from_database=from_database,
+                            from_table=from_table, to_driver=to_driver,
+                            to_database=to_database,
+                            to_table=to_table)
     except CalledModuleError:
-        grass.fatal(_("Unable to copy table <%s>") % from_table)
+        gscript.fatal(_("Unable to copy table <%s>") % from_table)
 
     return True
 
 # drop tables if required (-d)
+
+
 def drop_tab(vector, layer, table, driver, database):
     # disconnect
     try:
-        grass.run_command('v.db.connect', flags = 'd', quiet = True, map = vector,
-			          layer = layer, table = table)
+        gscript.run_command('v.db.connect', flags='d', quiet=True, map=vector,
+                            layer=layer, table=table)
     except CalledModuleError:
-        grass.warning(_("Unable to disconnect table <%s> from vector <%s>") % (table, vector))
+        gscript.warning(_("Unable to disconnect table <%s> from vector <%s>") %
+                        (table, vector))
     # drop table
     try:
-        grass.run_command('db.droptable', quiet = True, flags = 'f',
-                          driver = driver, database = database,
-                          table = table)
+        gscript.run_command('db.droptable', quiet=True, flags='f',
+                            driver=driver, database=database,
+                            table=table)
     except CalledModuleError:
-        grass.fatal(_("Unable to drop table <%s>") % table)
+        gscript.fatal(_("Unable to drop table <%s>") % table)
 
 # create index on key column
+
+
 def create_index(driver, database, table, index_name, key):
     if driver == 'dbf':
-	return False
+        return False
 
-    grass.info(_("Creating index <%s>...") % index_name)
+    gscript.info(_("Creating index <%s>...") % index_name)
     try:
-        grass.run_command('db.execute', quiet = True,
-                          driver = driver, database = database,
-                          sql = "create unique index %s on %s(%s)" % (index_name, table, key))
+        gscript.run_command('db.execute', quiet=True, driver=driver,
+                            database=database,
+                            sql="create unique index %s on %s(%s)" %
+                                (index_name, table, key))
     except CalledModuleError:
-        grass.warning(_("Unable to create index <%s>") % index_name)
+        gscript.warning(_("Unable to create index <%s>") % index_name)
+
 
 def main():
     # old connection
     old_database = options['old_database']
     old_schema = options['old_schema']
     # new connection
-    default_connection = grass.db_connection()
+    default_connection = gscript.db_connection()
     if options['new_driver']:
         new_driver = options['new_driver']
     else:
@@ -168,24 +181,25 @@ def main():
         new_schema = default_connection['schema']
 
     if old_database == '':
-    	old_database = None
+        old_database = None
     old_database_subst = None
     if old_database is not None:
-	old_database_subst = substitute_db(old_database)
+        old_database_subst = substitute_db(old_database)
 
     new_database_subst = substitute_db(new_database)
 
     if old_database_subst == new_database_subst and old_schema == new_schema:
-	grass.fatal(_("Old and new database connection is identical. Nothing to do."))
+        gscript.fatal(_("Old and new database connection is identical. "
+                        "Nothing to do."))
 
-    mapset = grass.gisenv()['MAPSET']
+    mapset = gscript.gisenv()['MAPSET']
 
-    vectors = grass.list_grouped('vect')[mapset]
+    vectors = gscript.list_grouped('vect')[mapset]
     num_vectors = len(vectors)
 
     if flags['c']:
-	# create new database if not existing
-	create_db(new_driver, new_database)
+        # create new database if not existing
+        create_db(new_driver, new_database)
 
     i = 0
     for vect in vectors:
@@ -213,21 +227,22 @@ def main():
             else:
                 new_schema_table = table
 
-            grass.debug("DATABASE = '%s' SCHEMA = '%s' TABLE = '%s' ->\n"
-                        "      NEW_DATABASE = '%s' NEW_SCHEMA_TABLE = '%s'" % \
-                            (old_database, schema, table, new_database, new_schema_table))
+            gscript.debug("DATABASE = '%s' SCHEMA = '%s' TABLE = '%s' ->\n"
+                          "      NEW_DATABASE = '%s' NEW_SCHEMA_TABLE = '%s'" %
+                          (old_database, schema, table, new_database,
+                           new_schema_table))
 
             do_reconnect = True
-	    if old_database_subst is not None:
-		if database != old_database_subst:
-		    do_reconnect = False
-	    if database == new_database_subst:
-		do_reconnect = False
-	    if schema != old_schema:
-		do_reconnect = False
+            if old_database_subst is not None:
+                if database != old_database_subst:
+                    do_reconnect = False
+            if database == new_database_subst:
+                do_reconnect = False
+            if schema != old_schema:
+                do_reconnect = False
 
             if do_reconnect == True:
-                grass.verbose(_("Reconnecting layer %d...") % layer)
+                gscript.verbose(_("Reconnecting layer %d...") % layer)
 
                 if flags['c']:
                     # check if table exists in new database
@@ -236,26 +251,34 @@ def main():
 
                 # drop original table if required
                 if flags['d']:
-                    drop_tab(vect, layer, schema_table, driver, substitute_db(database))
+                    drop_tab(
+                        vect,
+                        layer,
+                        schema_table,
+                        driver,
+                        substitute_db(database))
 
                 # reconnect tables (don't use substituted new_database)
-		# NOTE: v.db.connect creates an index on the key column
+                # NOTE: v.db.connect creates an index on the key column
                 try:
-                    grass.run_command('v.db.connect', flags = 'o', quiet = True, map = vect,
-                                      layer = layer, driver = new_driver, database = new_database,
-                                      table = new_schema_table, key = key)
+                    gscript.run_command('v.db.connect', flags='o', quiet=True,
+                                        map=vect, layer=layer,
+                                        driver=new_driver,
+                                        database=new_database,
+                                        table=new_schema_table, key=key)
                 except CalledModuleError:
-                    grass.warning(_("Unable to connect table <%s> to vector <%s> on layer <%s>") %
-				  (table, vect, str(layer)))
+                    gscript.warning(_("Unable to connect table <%s> to vector "
+                                      "<%s> on layer <%s>") %
+                                    (table, vect, str(layer)))
 
             else:
-		if database != new_database_subst:
-		    grass.warning(_("Layer <%d> will not be reconnected because "
-				    "database or schema do not match.") % layer)
-
+                if database != new_database_subst:
+                    gscript.warning(_("Layer <%d> will not be reconnected "
+                                      "because database or schema do not "
+                                      "match.") % layer)
     return 0
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     nuldev = file(os.devnull, 'w')
     sys.exit(main())

scripts/v.db.renamecolumn/v.db.renamecolumn.py

@@ -5,10 +5,10 @@
 # MODULE:       v.db.renamecolumn
 # AUTHOR(S):    Markus Neteler
 #               Converted to Python by Glynn Clements
-# PURPOSE:      interface to db.execute to drop a column from the 
+# PURPOSE:      interface to db.execute to drop a column from the
 #               attribute table connected to a given vector map
 #               - Based on v.db.dropcolumn
-#               - with special trick for SQLite and DBF (here the new col is 
+#               - with special trick for SQLite and DBF (here the new col is
 #                 added/values copied/old col deleted)
 # COPYRIGHT:    (C) 2007 by the GRASS Development Team
 #
@@ -30,7 +30,7 @@
 #%end
 #%option G_OPT_V_FIELD
 #%end
-#%option 
+#%option
 #% key: column
 #% type: string
 #% description: Old and new name of the column (old,new)
@@ -43,6 +43,7 @@ import sys
 import os
 import grass.script as grass
 
+
 def main():
     map = options['map']
     layer = options['layer']
@@ -50,7 +51,7 @@ def main():
 
     mapset = grass.gisenv()['MAPSET']
 
-    if not grass.find_file(map, element = 'vector', mapset = mapset):
+    if not grass.find_file(map, element='vector', mapset=mapset):
         grass.fatal(_("Vector map <%s> not found in current mapset") % map)
 
     f = grass.vector_layer_db(map, layer)
@@ -69,10 +70,14 @@ def main():
 
     if driver == "dbf":
         if len(newcol) > 10:
-            grass.fatal(_("Column name <%s> too long. The DBF driver supports column names not longer than 10 characters") % newcol)
+            grass.fatal(
+                _("Column name <%s> too long. The DBF driver supports column names not longer than 10 characters") %
+                newcol)
 
     if oldcol == keycol:
-        grass.fatal(_("Cannot rename column <%s> as it is needed to keep table <%s> connected to the input vector map") % (oldcol, table))
+        grass.fatal(
+            _("Cannot rename column <%s> as it is needed to keep table <%s> connected to the input vector map") %
+            (oldcol, table))
 
     # describe old col
     oldcoltype = None
@@ -93,10 +98,10 @@ def main():
         else:
             colspec = "%s %s" % (newcol, oldcoltype)
 
-        grass.run_command('v.db.addcolumn', map = map, layer = layer, column = colspec)
+        grass.run_command('v.db.addcolumn', map=map, layer=layer, column=colspec)
         sql = "UPDATE %s SET %s=%s" % (table, newcol, oldcol)
-        grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = sql)
-        grass.run_command('v.db.dropcolumn', map = map, layer = layer, column = oldcol)
+        grass.write_command('db.execute', input='-', database=database, driver=driver, stdin=sql)
+        grass.run_command('v.db.dropcolumn', map=map, layer=layer, column=oldcol)
     elif driver == 'mysql':
         if oldcoltype.upper() == "CHARACTER":
             newcoltype = "varchar(%s)" % (oldcollength)
@@ -104,10 +109,10 @@ def main():
             newcoltype = oldcoltype
 
         sql = "ALTER TABLE %s CHANGE %s %s %s" % (table, oldcol, newcol, newcoltype)
-        grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = sql)
+        grass.write_command('db.execute', input='-', database=database, driver=driver, stdin=sql)
     else:
         sql = "ALTER TABLE %s RENAME %s TO %s" % (table, oldcol, newcol)
-        grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = sql)
+        grass.write_command('db.execute', input='-', database=database, driver=driver, stdin=sql)
 
     # write cmd history:
     grass.vector_history(map)

scripts/v.db.univar/v.db.univar.py

@@ -53,50 +53,49 @@
 
 import sys
 import os
-import grass.script as grass
+import grass.script as gscript
 from grass.exceptions import CalledModuleError
 
+
 def main():
     global tmp
-    tmp = grass.tempfile()
+    tmp = gscript.tempfile()
 
     vector = options['map']
     layer = options['layer']
     column = options['column']
     where = options['where']
     perc = options['percentile']
-    extend = flags['e']
-    shellstyle = flags['g']
 
-    if not grass.find_file(vector, element='vector')['file']:
-        grass.fatal(_("Vector map <%s> not found") % vector)
+    if not gscript.find_file(vector, element='vector')['file']:
+        gscript.fatal(_("Vector map <%s> not found") % vector)
 
     try:
-        fi = grass.vector_db(vector, stderr = nuldev)[int(layer)]
+        fi = gscript.vector_db(vector, stderr=nuldev)[int(layer)]
     except KeyError:
-        grass.fatal(_("No attribute table linked to layer <%s>") % layer)
-                
+        gscript.fatal(_("No attribute table linked to layer <%s>") % layer)
+
     table = fi['table']
     database = fi['database']
     driver = fi['driver']
-    
+
     passflags = None
     if flags['e']:
-	passflags = 'e'
+        passflags = 'e'
     if flags['g']:
-	if not passflags:
-	    passflags = 'g'
-	else:
-	    passflags = passflags + 'g'
+        if not passflags:
+            passflags = 'g'
+        else:
+            passflags = passflags + 'g'
 
     try:
-        grass.run_command('db.univar', table = table, column = column, 
-                          database = database, driver = driver,
-                          perc = perc, where = where, flags = passflags)
+        gscript.run_command('db.univar', table=table, column=column,
+                            database=database, driver=driver,
+                            perc=perc, where=where, flags=passflags)
     except CalledModuleError:
         sys.exit(1)
-    
+
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gscript.parser()
     nuldev = file(os.devnull, 'w')
     main()

scripts/v.db.update/v.db.update.py

@@ -54,6 +54,7 @@ import sys
 import os
 import grass.script as grass
 
+
 def main():
     vector = options['map']
     layer = options['layer']
@@ -61,18 +62,19 @@ def main():
     value = options['value']
     qcolumn = options['query_column']
     where = options['where']
-    sqlitefile  = options['sqliteextra']
+    sqlitefile = options['sqliteextra']
 
     mapset = grass.gisenv()['MAPSET']
 
     # does map exist in CURRENT mapset?
-    if not grass.find_file(vector, element = 'vector', mapset = mapset)['file']:
+    if not grass.find_file(vector, element='vector', mapset=mapset)['file']:
         grass.fatal(_("Vector map <%s> not found in current mapset") % vector)
 
     try:
         f = grass.vector_db(vector)[int(layer)]
     except KeyError:
-        grass.fatal(_('There is no table connected to this map. Run v.db.connect or v.db.addtable first.'))
+        grass.fatal(
+            _('There is no table connected to this map. Run v.db.connect or v.db.addtable first.'))
 
     table = f['table']
     database = f['database']
@@ -113,7 +115,7 @@ def main():
         cmd = sqliteload + cmd
 
     grass.verbose("SQL: \"%s\"" % cmd)
-    grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = cmd)
+    grass.write_command('db.execute', input='-', database=database, driver=driver, stdin=cmd)
 
     # write cmd history:
     grass.vector_history(vector)

scripts/v.dissolve/v.dissolve.py

@@ -43,7 +43,10 @@ from grass.exceptions import CalledModuleError
 
 def cleanup():
     nuldev = file(os.devnull, 'w')
-    grass.run_command('g.remove', flags = 'f', type = 'vector', name = '%s_%s' % (output, tmp), quiet = True, stderr = nuldev)
+    grass.run_command(
+        'g.remove', flags='f', type='vector', name='%s_%s' %
+        (output, tmp), quiet=True, stderr=nuldev)
+
 
 def main():
     global output, tmp
@@ -53,44 +56,45 @@ def main():
     layer = options['layer']
     column = options['column']
 
-    #### setup temporary file
+    # setup temporary file
     tmp = str(os.getpid())
 
     # does map exist?
-    if not grass.find_file(input, element = 'vector')['file']:
-	grass.fatal(_("Vector map <%s> not found") % input)
-    
+    if not grass.find_file(input, element='vector')['file']:
+        grass.fatal(_("Vector map <%s> not found") % input)
+
     if not column:
-        grass.warning(_("No '%s' option specified. Dissolving based on category values from layer <%s>.") % \
-                          ("column", layer))
-	grass.run_command('v.extract', flags = 'd', input = input,
-			  output = output, type = 'area', layer = layer)
+        grass.warning(
+            _("No '%s' option specified. Dissolving based on category values from layer <%s>.") %
+            ("column", layer))
+        grass.run_command('v.extract', flags='d', input=input,
+                          output=output, type='area', layer=layer)
     else:
         if int(layer) == -1:
             grass.warning(_("Invalid layer number (%d). "
-                            "Parameter '%s' specified, assuming layer '1'.") % 
+                            "Parameter '%s' specified, assuming layer '1'.") %
                           (int(layer), 'column'))
             layer = '1'
         try:
             coltype = grass.vector_columns(input, layer)[column]
         except KeyError:
             grass.fatal(_('Column <%s> not found') % column)
-        
-	if coltype['type'] not in ('INTEGER', 'SMALLINT', 'CHARACTER', 'TEXT'):
-	    grass.fatal(_("Key column must be of type integer or string"))
+
+        if coltype['type'] not in ('INTEGER', 'SMALLINT', 'CHARACTER', 'TEXT'):
+            grass.fatal(_("Key column must be of type integer or string"))
 
         f = grass.vector_layer_db(input, layer)
 
-	table = f['table']
+        table = f['table']
 
-	tmpfile = '%s_%s' % (output, tmp)
+        tmpfile = '%s_%s' % (output, tmp)
 
         try:
             grass.run_command('v.reclass', input=input, output=tmpfile,
                               layer=layer, column=column)
             grass.run_command('v.extract', flags='d', input=tmpfile,
                               output=output, type='area', layer=layer)
-        except CalledModuleError, e:
+        except CalledModuleError as e:
             grass.fatal(_("Final extraction steps failed."
                           " Check above error messages and"
                           " see following details:\n%s") % e)

scripts/v.import/v.import.py

@@ -153,10 +153,10 @@ def main():
         # list datum transform parameters
         if not options['epsg']:
             grass.fatal(_("Missing value for parameter <%s>") % 'epsg')
-        
+
         return grass.run_command('g.proj', epsg=options['epsg'],
                                  datum_trans=options['datum_trans'])
-    
+
     grassenv = grass.gisenv()
     tgtloc = grassenv['LOCATION_NAME']
     tgtmapset = grassenv['MAPSET']
@@ -191,12 +191,12 @@ def main():
     # switch to temp location
     os.environ['GISRC'] = str(SRCGISRC)
 
-    if options['epsg']: # force given EPSG
+    if options['epsg']:  # force given EPSG
         kwargs = {}
         if options['datum_trans']:
             kwargs['datum_trans'] = options['datum_trans']
         grass.run_command('g.proj', flags='c', epsg=options['epsg'], **kwargs)
-        
+
     # switch to target location
     os.environ['GISRC'] = str(tgtgisrc)
 
@@ -206,21 +206,25 @@ def main():
         try:
             grass.run_command('v.in.ogr', input=OGRdatasource,
                               flags=vflags, overwrite=overwrite, **vopts)
-            grass.message(_("Input <%s> successfully imported without reprojection") % OGRdatasource)
+            grass.message(
+                _("Input <%s> successfully imported without reprojection") %
+                OGRdatasource)
             return 0
         except CalledModuleError:
             grass.fatal(_("Unable to import <%s>") % OGRdatasource)
 
     # make sure target is not xy
     if grass.parse_command('g.proj', flags='g')['name'] == 'xy_location_unprojected':
-        grass.fatal(_("Coordinate reference system not available for current location <%s>") % tgtloc)
+        grass.fatal(
+            _("Coordinate reference system not available for current location <%s>") %
+            tgtloc)
 
     # switch to temp location
     os.environ['GISRC'] = str(SRCGISRC)
 
     # print projection at verbose level
     grass.verbose(grass.read_command('g.proj', flags='p').rstrip(os.linesep))
-    
+
     # make sure input is not xy
     if grass.parse_command('g.proj', flags='g')['name'] == 'xy_location_unprojected':
         grass.fatal(_("Coordinate reference system not available for input <%s>") % OGRdatasource)

scripts/v.in.e00/v.in.e00.py

@@ -43,7 +43,7 @@ import shutil
 import glob
 from grass.script.utils import try_rmdir, try_remove, basename
 from grass.script import vector as gvect
-from grass.script import core as grass
+from grass.script import core as gcore
 from grass.exceptions import CalledModuleError
 
 
@@ -54,113 +54,115 @@ def main():
 
     e00tmp = str(os.getpid())
 
-    #### check for avcimport
-    if not grass.find_program('avcimport'):
-	grass.fatal(_("'avcimport' program not found, install it first") +
-		    "\n" +
-		    "http://avce00.maptools.org")
+    # check for avcimport
+    if not gcore.find_program('avcimport'):
+        gcore.fatal(_("'avcimport' program not found, install it first") +
+                    "\n" + "http://avce00.maptools.org")
 
-    #### check for e00conv
-    if not grass.find_program('e00conv'):
-	grass.fatal(_("'e00conv' program not found, install it first") +
-		    "\n" +
-		    "http://avce00.maptools.org")
+    # check for e00conv
+    if not gcore.find_program('e00conv'):
+        gcore.fatal(_("'e00conv' program not found, install it first") +
+                    "\n" + "http://avce00.maptools.org")
 
     # check that the user didn't use all three, which gets past the parser.
-    if type not in ['point','line','area']:
-	grass.fatal(_('Must specify one of "point", "line", or "area".'))
+    if type not in ['point', 'line', 'area']:
+        gcore.fatal(_('Must specify one of "point", "line", or "area".'))
 
     e00name = basename(filename, 'e00')
     # avcimport only accepts 13 chars:
     e00shortname = e00name[:13]
 
-    #check if this is a split E00 file (.e01, .e02 ...):
+    # check if this is a split E00 file (.e01, .e02 ...):
     merging = False
     if os.path.exists(e00name + '.e01') or os.path.exists(e00name + '.E01'):
-	grass.message(_("Found that E00 file is split into pieces (.e01, ...). Merging..."))
-	merging = True
+        gcore.message(_("Found that E00 file is split into pieces (.e01, ...)."
+                        " Merging..."))
+        merging = True
 
     if vect:
-	name = vect
+        name = vect
     else:
-	name = e00name
+        name = e00name
 
-    ### do import
+    # do import
 
-    #make a temporary directory
-    tmpdir = grass.tempfile()
+    # make a temporary directory
+    tmpdir = gcore.tempfile()
     try_remove(tmpdir)
     os.mkdir(tmpdir)
 
-    files = glob.glob(e00name + '.e[0-9][0-9]') + glob.glob(e00name + '.E[0-9][0-9]')
+    files = glob.glob(
+        e00name + '.e[0-9][0-9]') + glob.glob(e00name + '.E[0-9][0-9]')
     for f in files:
-	shutil.copy(f, tmpdir)
+        shutil.copy(f, tmpdir)
 
-    #change to temporary directory to later avoid removal problems (rm -r ...)
+    # change to temporary directory to later avoid removal problems (rm -r ...)
     os.chdir(tmpdir)
 
-    #check for binay E00 file (we can just check if import fails):
-    #avcimport doesn't set exist status :-(
+    # check for binay E00 file (we can just check if import fails):
+    # avcimport doesn't set exist status :-(
 
     if merging:
-	files.sort()
-	filename = "%s.cat.%s.e00" % (e00name, e00tmp)
-	outf = file(filename, 'wb')
-	for f in files:
-	    inf = file(f, 'rb')
-	    shutil.copyfileobj(inf, outf)
-	    inf.close()
-	outf.close()
+        files.sort()
+        filename = "%s.cat.%s.e00" % (e00name, e00tmp)
+        outf = file(filename, 'wb')
+        for f in files:
+            inf = file(f, 'rb')
+            shutil.copyfileobj(inf, outf)
+            inf.close()
+        outf.close()
 
     nuldev = file(os.devnull, 'w+')
 
-    grass.message(_("An error may appear next which will be ignored..."))
-    if grass.call(['avcimport', filename, e00shortname], stdout = nuldev, stderr = nuldev) == 1:
-	grass.message(_("E00 ASCII found and converted to Arc Coverage in current directory"))
+    gcore.message(_("An error may appear next which will be ignored..."))
+    if gcore.call(['avcimport', filename, e00shortname], stdout=nuldev,
+                  stderr=nuldev) == 1:
+        gcore.message(_("E00 ASCII found and converted to Arc Coverage in "
+                        "current directory"))
     else:
-	grass.message(_("E00 Compressed ASCII found. Will uncompress first..."))
-	try_remove(e00shortname)
-	grass.call(['e00conv', filename, e00tmp + '.e00'])
-	grass.message(_("...converted to Arc Coverage in current directory"))
-	grass.call(['avcimport', e00tmp + '.e00', e00shortname], stderr = nuldev)
-
-    #SQL name fix:
+        gcore.message(
+            _("E00 Compressed ASCII found. Will uncompress first..."))
+        try_remove(e00shortname)
+        gcore.call(['e00conv', filename, e00tmp + '.e00'])
+        gcore.message(_("...converted to Arc Coverage in current directory"))
+        gcore.call(['avcimport', e00tmp + '.e00', e00shortname], stderr=nuldev)
+
+    # SQL name fix:
     name = name.replace('-', '_')
 
-    ## let's import...
-    grass.message(_("Importing %ss...") % type)
+    # let's import...
+    gcore.message(_("Importing %ss...") % type)
 
-    layer = dict(point = 'LAB', line = 'ARC', area = ['LAB','ARC'])
-    itype = dict(point = 'point', line = 'line', area = 'centroid')
+    layer = dict(point='LAB', line='ARC', area=['LAB', 'ARC'])
+    itype = dict(point='point', line='line', area='centroid')
 
     try:
-        grass.run_command('v.in.ogr', flags='o', input=e00shortname,
+        gcore.run_command('v.in.ogr', flags='o', input=e00shortname,
                           layer=layer[type], type=itype[type],
                           output=name)
     except CalledModuleError:
-        grass.fatal(_("An error occurred while running v.in.ogr"))
+        gcore.fatal(_("An error occurred while running v.in.ogr"))
 
-    grass.message(_("Imported <%s> vector map <%s>.") % (type, name))
+    gcore.message(_("Imported <%s> vector map <%s>.") % (type, name))
 
-    #### clean up the mess
+    # clean up the mess
     for root, dirs, files in os.walk('.', False):
-	for f in files:
-	    path = os.path.join(root, f)
-	    try_remove(path)
-	for d in dirs:
-	    path = os.path.join(root, d)
-	    try_rmdir(path)
+        for f in files:
+            path = os.path.join(root, f)
+            try_remove(path)
+        for d in dirs:
+            path = os.path.join(root, d)
+            try_rmdir(path)
 
     os.chdir('..')
     os.rmdir(tmpdir)
-	
-    #### end
-    grass.message(_("Done."))
+
+    # end
+    gcore.message(_("Done."))
 
     # write cmd history:
     gvect.vector_history(name)
 
 if __name__ == "__main__":
-    options, flags = grass.parser()
+    options, flags = gcore.parser()
     main()
-

scripts/v.in.geonames/v.in.geonames.py

@@ -37,11 +37,12 @@
 import os
 import grass.script as grass
 
+
 def main():
-    infile  = options['input']
+    infile = options['input']
     outfile = options['output']
-    
-    #are we in LatLong location?
+
+    # are we in LatLong location?
     s = grass.read_command("g.proj", flags='j')
     kv = grass.parse_key_val(s)
     if kv['+proj'] != 'longlat':
@@ -55,7 +56,8 @@ def main():
     kv = grass.db_connection()
     dbfdriver = kv['driver'] == 'dbf'
     if dbfdriver:
-        grass.warning(_("Since DBF driver is used, the content of the 'alternatenames' column might be cut with respect to the original Geonames.org column content"))
+        grass.warning(
+            _("Since DBF driver is used, the content of the 'alternatenames' column might be cut with respect to the original Geonames.org column content"))
 
     with open(infile) as f:
         num_places = sum(1 for _ in f)
@@ -87,55 +89,54 @@ def main():
 
     # geonameid|name|asciiname|alternatenames|latitude|longitude|featureclass|featurecode|countrycode|cc2|admin1code|admin2code|admin3code|admin4code|population|elevation|gtopo30|timezone|modificationdate
 
-
     # debug:
     # head -n 3 ${TMPFILE}.csv
 
     # use different column names limited to 10 chars for dbf
     if dbfdriver:
         columns = ['geonameid integer',
-           'name varchar(200)',
-           'asciiname varchar(200)',
-           'altname varchar(4000)',
-           'latitude double precision',
-           'longitude double precision',
-           'featrclass varchar(1)',
-           'featrcode varchar(10)',
-           'cntrycode varchar(2)',
-           'cc2 varchar(60)',
-           'admin1code varchar(20)',
-           'admin2code varchar(20)',
-           'admin3code varchar(20)',
-           'admin4code varchar(20)',
-           'population integer',
-           'elevation integer',
-           'gtopo30 integer',
-           'timezone varchar(50)',
-           'mod_date date']
+                   'name varchar(200)',
+                   'asciiname varchar(200)',
+                   'altname varchar(4000)',
+                   'latitude double precision',
+                   'longitude double precision',
+                   'featrclass varchar(1)',
+                   'featrcode varchar(10)',
+                   'cntrycode varchar(2)',
+                   'cc2 varchar(60)',
+                   'admin1code varchar(20)',
+                   'admin2code varchar(20)',
+                   'admin3code varchar(20)',
+                   'admin4code varchar(20)',
+                   'population integer',
+                   'elevation integer',
+                   'gtopo30 integer',
+                   'timezone varchar(50)',
+                   'mod_date date']
     else:
         columns = ['geonameid integer',
-           'name varchar(200)',
-           'asciiname varchar(200)',
-           'alternatename varchar(4000)',
-           'latitude double precision',
-           'longitude double precision',
-           'featureclass varchar(1)',
-           'featurecode varchar(10)',
-           'countrycode varchar(2)',
-           'cc2 varchar(60)',
-           'admin1code varchar(20)',
-           'admin2code varchar(20)',
-           'admin3code varchar(20)',
-           'admin4code varchar(20)',
-           'population integer',
-           'elevation integer',
-           'gtopo30 integer',
-           'timezone varchar(50)',
-           'modification date']
-
-    grass.run_command('v.in.ascii', cat = 0, x = 6, y = 5, sep = 'tab',
-              input = infile, output = outfile,
-              columns = columns)
+                   'name varchar(200)',
+                   'asciiname varchar(200)',
+                   'alternatename varchar(4000)',
+                   'latitude double precision',
+                   'longitude double precision',
+                   'featureclass varchar(1)',
+                   'featurecode varchar(10)',
+                   'countrycode varchar(2)',
+                   'cc2 varchar(60)',
+                   'admin1code varchar(20)',
+                   'admin2code varchar(20)',
+                   'admin3code varchar(20)',
+                   'admin4code varchar(20)',
+                   'population integer',
+                   'elevation integer',
+                   'gtopo30 integer',
+                   'timezone varchar(50)',
+                   'modification date']
+
+    grass.run_command('v.in.ascii', cat=0, x=6, y=5, sep='tab',
+                      input=infile, output=outfile,
+                      columns=columns)
 
     # write cmd history:
     grass.vector_history(outfile)
@@ -143,4 +144,3 @@ def main():
 if __name__ == "__main__":
     options, flags = grass.parser()
     main()
-

scripts/v.in.lines/v.in.lines.py

@@ -41,9 +41,11 @@ import string
 from grass.script.utils import separator, try_remove
 from grass.script import core as grass
 
+
 def cleanup():
     try_remove(tmp)
 
+
 def main():
     global tmp
 
@@ -57,11 +59,9 @@ def main():
     else:
         do3D = ''
 
-
     tmp = grass.tempfile()
 
-
-    #### set up input file
+    # set up input file
     if options['input'] == '-':
         infile = None
         inf = sys.stdin
@@ -71,7 +71,6 @@ def main():
             grass.fatal(_("Unable to read input file <%s>") % infile)
         grass.debug("input file=[%s]" % infile)
 
-
     if not infile:
         # read from stdin and write to tmpfile (v.in.mapgen wants a real file)
         outf = file(tmp, 'w')
@@ -99,8 +98,7 @@ def main():
             outf.close()
             runfile = tmp
 
-
-    ##### check that there are at least two columns (three if -z is given)
+    # check that there are at least two columns (three if -z is given)
     inf = file(runfile)
     for line in inf:
         if len(line.lstrip()) == 0 or line[0] == '#':
@@ -111,9 +109,8 @@ def main():
     if (do3D and numcols < 3) or (not do3D and numcols < 2):
         grass.fatal(_("Not enough data columns. (incorrect fs setting?)"))
 
-
-    grass.run_command('v.in.mapgen', flags = 'f' + do3D,
-                      input = runfile, output = options['output'])
+    grass.run_command('v.in.mapgen', flags='f' + do3D,
+                      input=runfile, output=options['output'])
 
 
 if __name__ == "__main__":