grass71/scripts: revert changes (https://trac.osgeo.org/grass/changeset/68140 and https://trac.osgeo.org/grass/changeset/68178) since they are not fixing bugs and therefore they should go in relbr72

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

scripts/d.correlate/d.correlate.py

@@ -29,23 +29,21 @@
 import sys
 import os
 from grass.script.utils import try_remove
-from grass.script import core as gcore
-
+from grass.script import core as grass
 
 def main():
     layers = options['map'].split(',')
 
     if len(layers) < 2:
-        gcore.error(_("At least 2 maps are required"))
+	grass.error(_("At least 2 maps are required"))
 
-    tmpfile = gcore.tempfile()
+    tmpfile = grass.tempfile()
 
     for map in layers:
-        if not gcore.find_file(map, element='cell')['file']:
-            gcore.fatal(_("Raster map <%s> not found") % map)
+	if not grass.find_file(map, element = 'cell')['file']:
+	    grass.fatal(_("Raster map <%s> not found") % map)
 
-    gcore.write_command('d.text', color='black', size=4, line=1,
-                        stdin="CORRELATION")
+    grass.write_command('d.text', color = 'black', size = 4, line = 1, stdin = "CORRELATION")
 
     os.environ['GRASS_RENDER_FILE_READ'] = 'TRUE'
 
@@ -54,60 +52,53 @@ 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)
-                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()
+	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()
 
     try_remove(tmpfile)
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.parser()
     main()

scripts/d.frame/d.frame.py

@@ -71,15 +71,11 @@ 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:
@@ -92,22 +88,18 @@ 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)
 
@@ -120,23 +112,19 @@ 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:
@@ -146,8 +134,6 @@ 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:
@@ -160,14 +146,10 @@ 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 = map(float, at.split(','))
@@ -178,13 +160,11 @@ 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
@@ -200,7 +180,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:
@@ -210,12 +190,10 @@ 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)):
@@ -224,29 +202,28 @@ 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)
@@ -268,13 +245,12 @@ 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,6 +42,7 @@
 #% description: Plot using Xgraph
 #%end
 
+import sys
 import os
 import string
 import types
@@ -50,38 +51,34 @@ import atexit
 import glob
 import shutil
 from grass.script.utils import try_remove, basename
-from grass.script import core as gcore
-
+from grass.script import core as grass
 
 def cleanup():
     try_remove(tmp)
     for f in glob.glob(tmp + '_*'):
-        try_remove(f)
-
+	try_remove(f)
 
 def plot_xgraph():
     newline = ['\n']
-    p = gcore.Popen(['xgraph'], stdin=gcore.PIPE)
+    p = grass.Popen(['xgraph'], stdin = grass.PIPE)
     for point in sine_cosine_replic + newline + outercircle + newline + vector:
-        if isinstance(point, types.TupleType):
-            p.stdin.write("%f %f\n" % point)
-        else:
-            p.stdin.write(point + '\n')
+	if isinstance(point, types.TupleType):
+	    p.stdin.write("%f %f\n" % point)
+	else:
+	    p.stdin.write(point + '\n')
     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 = gcore.read_command('d.info', flags='d')
+    # 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')
     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
@@ -97,32 +94,32 @@ def plot_dgraph():
     scaleval = ring * totalvalidnumber / totalnumber
 
     sine_cosine_replic_normalized = [
-        ((scaleval * p[0] / maxradius + 1) * 50,
-         (scaleval * p[1] / maxradius + 1) * 50)
-        for p in sine_cosine_replic if isinstance(p, types.TupleType)]
+	((scaleval * p[0]/maxradius + 1)*50,
+	 (scaleval * p[1]/maxradius + 1)*50)
+	for p in sine_cosine_replic
+	if isinstance(p, types.TupleType)]
 
     # 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",
@@ -130,16 +127,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",
@@ -152,7 +149,7 @@ def plot_dgraph():
         "move 97 51",
         "text E",
 
-        # draw legend text
+	# draw legend text
         "width 0",
         "size 10",
         "color 0:180:0",
@@ -164,21 +161,20 @@ def plot_dgraph():
         "color blue",
         "move 0.5 90.5",
         "text Avg. direction"
-    ]
+	]
 
-    p = gcore.feed_command('d.graph', env=tenv)
+    p = grass.feed_command('d.graph', env = tenv)
     for point in lines:
-        if isinstance(point, types.TupleType):
-            p.stdin.write("%f %f\n" % point)
-        else:
-            p.stdin.write(point + '\n')
+	if isinstance(point, types.TupleType):
+	    p.stdin.write("%f %f\n" % point)
+	else:
+	    p.stdin.write(point + '\n')
     p.stdin.close()
     p.wait()
 
-
 def plot_eps(psout):
     # EPS output (by M.Neteler and Bruno Caprile, ITC-irst)
-    gcore.message(_("Generating %s ...") % psout)
+    grass.message(_("Generating %s ...") % psout)
 
     outerradius = maxradius
     epsscale = 0.1
@@ -193,24 +189,24 @@ 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
     southjustification = 8
     westjustification = 8
 
-    northxshift = 1.02 * halfframe
-    northyshift = 1.98 * 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
+    northxshift = 1.02 * halfframe 
+    northyshift = 1.98 * 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  
 
     alldatastring = "all data (null included)"
     realdatastring = "real data angles"
@@ -224,11 +220,7 @@ 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()
@@ -262,24 +254,20 @@ 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
@@ -309,33 +297,29 @@ 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
@@ -350,18 +334,14 @@ 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
@@ -383,20 +363,19 @@ 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()
 
-    gcore.message(_("Done."))
-
+    grass.message(_("Done."))
 
 def main():
     global tmp
@@ -408,33 +387,31 @@ def main():
     eps = options['output']
     xgraph = flags['x']
 
-    tmp = gcore.tempfile()
+    tmp = grass.tempfile()
 
     if eps and xgraph:
-        gcore.fatal(_("Please select only one output method"))
+	grass.fatal(_("Please select only one output method"))
 
-    # 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)"))
+    #### 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)"))
 
     #################################
     # this file contains everthing:
     rawfile = tmp + "_raw"
     rawf = file(rawfile, 'w')
-    gcore.run_command('r.stats', flags='1', input=map, stdout=rawf)
+    grass.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()
 
-    gcore.message(
-        _("Calculating statistics for polar diagram... (be patient)"))
+    grass.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)
@@ -443,26 +420,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:
-        gcore.fatal(_("No data pixel found"))
+	grass.fatal(_("No data pixel found"))
 
     #################################
     # unit vector on raw data converted to radians without no data:
@@ -472,8 +449,9 @@ def main():
     #################################
     # how many are there?:
 
-    occurrences = sorted([(math.radians(x), freq[x]) for x in freq])
-
+    occurrences = [(math.radians(x), freq[x]) for x in freq]
+    occurrences.sort()
+    
     # find the maximum value
     maxradius = max([f for a, f in occurrences])
 
@@ -483,14 +461,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 = []
@@ -503,28 +481,19 @@ 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()
-
-    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])))
+	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])))
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.parser()
     atexit.register(cleanup)
     main()
+

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

@@ -125,10 +125,8 @@ 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,7 +26,6 @@ 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:
@@ -39,25 +38,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,67 +48,66 @@ def main():
     force = flags['f']
 
     # check if DB parameters are set, and if not set them.
-    gscript.run_command('db.connect', flags='c')
+    grass.run_command('db.connect', flags = 'c')
 
-    kv = gscript.db_connection()
+    kv = grass.db_connection()
     database = kv['database']
     driver = kv['driver']
     # schema needed for PG?
 
     if force:
-        gscript.message(_("Forcing ..."))
+	grass.message(_("Forcing ..."))
 
     if column == "cat":
-        gscript.warning(_("Deleting <%s> column which may be needed to keep "
-                          "table connected to a vector map") % column)
+	grass.warning(_("Deleting <%s> column which may be needed to keep table connected to a vector map") % column)
 
-    cols = [f[0] for f in gscript.db_describe(table)['cols']]
+    cols = [f[0] for f in grass.db_describe(table)['cols']]
     if column not in cols:
-        gscript.fatal(_("Column <%s> not found in table") % column)
+	grass.fatal(_("Column <%s> not found in table") % column)
 
     if not force:
-        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
+	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
 
     if driver == "sqlite":
-        # 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)
+	#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)
     else:
-        sql = "ALTER TABLE %s DROP COLUMN %s" % (table, column)
+	sql = "ALTER TABLE %s DROP COLUMN %s" % (table, column)
 
     try:
-        gscript.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:
-        gscript.fatal(_("Cannot continue (problem deleting column)"))
+        grass.fatal(_("Cannot continue (problem deleting column)"))
 
     return 0
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     sys.exit(main())

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

@@ -72,76 +72,74 @@ 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...
-    layer = db_table if db_table else None
+    if db_table:
+	layer = db_table
+    else:
+	layer = 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 gcore
+from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
 
@@ -69,52 +69,54 @@ 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 gcore.overwrite():
-        gcore.fatal(_("File <%s> already exists") % dbffile)
+    if os.path.exists(dbffile) and not grass.overwrite():
+	grass.fatal(_("File <%s> already exists") % dbffile)
 
     if olayer:
         try:
-            gcore.run_command('v.out.ogr', quiet=True, input=input,
-                              layer=layer, output=output, format=format,
-                              type='point,line,area', olayer=olayer)
+            grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer,
+                              output=output,
+                              format=format, type='point,line,area',
+                              olayer=olayer)
         except CalledModuleError:
-            gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
+            grass.fatal(_("Module <%s> failed") % 'v.out.ogr')
 
     else:
         try:
-            gcore.run_command('v.out.ogr', quiet=True, input=input,
+            grass.run_command('v.out.ogr', quiet=True, input=input,
                               layer=layer, output=output,
                               format=format, type='point,line,area')
         except CalledModuleError:
-            gcore.fatal(_("Module <%s> failed") % 'v.out.ogr')
+            grass.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
 
-    gcore.message(_("Exported table <%s>") % outname)
+    grass.message(_("Exported table <%s>") % outname)
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.parser()
     main()
+

scripts/db.test/db.test.py

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

scripts/db.univar/db.univar.py

@@ -56,26 +56,25 @@
 #%end
 
 import sys
+import os
 import atexit
 import math
 
-import grass.script as gscript
-
+import grass.script as grass 
 
 def cleanup():
     for ext in ['', '.sort']:
-        gscript.try_remove(tmp + ext)
-
+        grass.try_remove(tmp + ext)
 
 def sortfile(infile, outfile):
     inf = file(infile, 'r')
     outf = file(outfile, 'w')
 
-    if gscript.find_program('sort', '--help'):
-        gscript.run_command('sort', flags='n', stdin=inf, stdout=outf)
+    if grass.find_program('sort', '--help'):
+        grass.run_command('sort', flags = 'n', stdin = inf, stdout = outf)
     else:
         # FIXME: we need a large-file sorting function
-        gscript.warning(_("'sort' not found: sorting in memory"))
+        grass.warning(_("'sort' not found: sorting in memory"))
         lines = inf.readlines()
         for i in range(len(lines)):
             lines[i] = float(lines[i].rstrip('\r\n'))
@@ -86,10 +85,9 @@ def sortfile(infile, outfile):
     inf.close()
     outf.close()
 
-
 def main():
     global tmp
-    tmp = gscript.tempfile()
+    tmp = grass.tempfile()
 
     extend = flags['e']
     shellstyle = flags['g']
@@ -102,22 +100,21 @@ def main():
 
     perc = [float(p) for p in perc.split(',')]
 
-    desc_table = gscript.db_describe(table, database=database, driver=driver)
+    desc_table = grass.db_describe(table, database=database, driver=driver)
     if not desc_table:
-        gscript.fatal(_("Unable to describe table <%s>") % table)
+        grass.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'):
-                gscript.fatal(_("Column <%s> is not numeric") % cname)
+                grass.fatal(_("Column <%s> is not numeric") % cname)
     if not found:
-        gscript.fatal(_("Column <%s> not found in table <%s>") % (column, table))
+        grass.fatal(_("Column <%s> not found in table <%s>") % (column, table))
 
     if not shellstyle:
-        gscript.verbose(_("Calculation for column <%s> of table <%s>..."
-                          ) % (column, table))
-        gscript.message(_("Reading column values..."))
+        grass.verbose(_("Calculation for column <%s> of table <%s>...") % (column, table))
+        grass.message(_("Reading column values..."))
 
     sql = "SELECT %s FROM %s" % (column, table)
     if where:
@@ -130,20 +127,20 @@ def main():
         driver = None
 
     tmpf = file(tmp, 'w')
-    gscript.run_command('db.select', flags='c', table=table,
-                        database=database, driver=driver, sql=sql,
-                        stdout=tmpf)
+    grass.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) == '':
-        gscript.fatal(_("Table <%s> contains no data.") % table)
+        grass.fatal(_("Table <%s> contains no data.") % table)
         tmpf.close()
 
     # calculate statistics
     if not shellstyle:
-        gscript.verbose(_("Calculating statistics..."))
+        grass.verbose(_("Calculating statistics..."))
 
     N = 0
     sum = 0.0
@@ -154,8 +151,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
@@ -166,43 +163,30 @@ def main():
     tmpf.close()
 
     if N <= 0:
-        gscript.fatal(_("No non-null values found"))
+        grass.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
@@ -210,26 +194,27 @@ 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")
@@ -255,45 +240,27 @@ 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 = gscript.parser()
+    options, flags = grass.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 gscript
+import grass.script as grass
 from grass.exceptions import CalledModuleError
 
 
 def get_extensions():
     addon_base = os.getenv('GRASS_ADDON_BASE')
     if not addon_base:
-        gscript.fatal(_("%s not defined") % "GRASS_ADDON_BASE")
+        grass.fatal(_("%s not defined") % "GRASS_ADDON_BASE")
     fXML = os.path.join(addon_base, 'modules.xml')
     if not os.path.exists(fXML):
         return []
@@ -60,56 +60,51 @@ def get_extensions():
     fo = open(fXML, 'r')
     try:
         tree = etree.fromstring(fo.read())
-    except Exception as e:
-        gscript.error(_("Unable to parse metadata file: %s") % e)
+    except StandardError as e:
+        grass.error(_("Unable to parse metadata file: %s") % e)
         fo.close()
         return []
-
+    
     fo.close()
-
-    libgis_rev = gscript.version()['libgis_revision']
+    
+    libgis_rev = grass.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 = gscript.read_command(
-            'g.extension',
-            quiet=True,
-            flags='a').splitlines()
+        extensions = grass.read_command('g.extension',
+                                        quiet = True, flags = 'a').splitlines()
     else:
         extensions = get_extensions()
-
+    
     if not extensions:
         if remove:
-            gscript.info(_("No extension found. Nothing to remove."))
+            grass.info(_("No extension found. Nothing to remove."))
         else:
-            gscript.info(
-                _("Nothing to rebuild. Rebuilding process can be forced with -f flag."))
+            grass.info(_("Nothing to rebuild. Rebuilding process can be forced with -f flag."))
         return 0
-
+    
     if remove and not flags['f']:
-        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."))
+        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."))
         return 0
-
+    
     for ext in extensions:
-        gscript.message('-' * 60)
+        grass.message('-' * 60)
         if remove:
-            gscript.message(_("Removing extension <%s>...") % ext)
+            grass.message(_("Removing extension <%s>...") % ext)
         else:
-            gscript.message(_("Reinstalling extension <%s>...") % ext)
-        gscript.message('-' * 60)
+            grass.message(_("Reinstalling extension <%s>...") % ext)
+        grass.message('-' * 60)
         if remove:
             operation = 'remove'
             operation_flags = 'f'
@@ -117,13 +112,13 @@ def main():
             operation = 'add'
             operation_flags = ''
         try:
-            gscript.run_command('g.extension', flags=operation_flags,
-                                extension=ext, operation=operation)
+            grass.run_command('g.extension', flags=operation_flags,
+                              extension=ext, operation=operation)
         except CalledModuleError:
-            gscript.error(_("Unable to process extension:%s") % ext)
+            grass.error(_("Unable to process extension:%s") % ext)
 
     return 0
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.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)
@@ -392,7 +392,6 @@ def get_toolbox_modules(url, name):
 
     return tlist
 
-
 def get_module_files(mnode):
     """Return list of module files
 
@@ -405,7 +404,6 @@ def get_module_files(mnode):
 
     return flist
 
-
 def get_module_executables(mnode):
     """Return list of module executables
 
@@ -414,16 +412,15 @@ 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
 
@@ -924,7 +921,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
@@ -933,29 +930,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
 
 
@@ -1094,7 +1091,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 \
@@ -1722,9 +1719,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

@@ -54,7 +54,6 @@ 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 \
@@ -62,68 +61,65 @@ def start_browser(entry):
         grass.fatal(_("Browser '%s' not found") % browser)
 
     if flags['o']:
-        major, minor, patch = grass.version()['version'].split('.')
-        url_path = 'http://grass.osgeo.org/grass%s%s/manuals/%s.html' % (major, minor, entry)
+        major,minor,patch = grass.version()['version'].split('.')
+        url_path = 'http://grass.osgeo.org/grass%s%s/manuals/%s.html' % (major,minor,entry)
         if urllib.urlopen(url_path).getcode() != 200:
-            url_path = 'http://grass.osgeo.org/grass%s%s/manuals/addons/%s.html' % (
-                major, minor, entry)
+            url_path = 'http://grass.osgeo.org/grass%s%s/manuals/addons/%s.html' % (major,minor,entry)
     else:
         path = os.path.join(gisbase, 'docs', 'html', entry + '.html')
         if not os.path.exists(path) and os.getenv('GRASS_ADDON_BASE'):
             path = os.path.join(os.getenv('GRASS_ADDON_BASE'), 'docs', 'html', entry + '.html')
-
+    
         if not os.path.exists(path):
             grass.fatal(_("No HTML manual page entry for '%s'") % entry)
-
+    
         url_path = 'file://' + path
-
+    
     if browser and browser not in ('xdg-open', 'start'):
         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:
         webbrowser.open(url_path)
     except:
         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'):
         path = os.path.join(os.getenv('GRASS_ADDON_BASE'), 'docs', 'man', 'man1', entry + '.1')
-
+    
     for ext in ['', '.gz', '.bz2']:
         if os.path.exists(path + ext):
             os.execlp('man', 'man', path + ext)
             grass.fatal(_("Error starting 'man' for '%s'") % path)
     grass.fatal(_("No manual page entry for '%s'") % entry)
 
-
 def main():
     global gisbase, browser, browser_name
-
+    
     if flags['i'] and flags['t']:
         grass.fatal(_("Flags -%c and -%c are mutually exclusive") % ('i', 't'))
-
+    
     special = None
     if flags['i']:
         special = 'index'
-    elif flags['t']:
+    elif flags ['t']:
         special = 'topics'
-
+    
     if flags['m']:
         start = start_man
     else:
         start = start_browser
-
-    entry = options['entry']
+    
+    entry  = options['entry']
     gisbase = os.environ['GISBASE']
     browser = os.getenv('GRASS_HTML_BROWSER', '')
-
+    
     if sys.platform == 'darwin':
         # hack for MacOSX
         browser_name = os.getenv('GRASS_HTML_BROWSER_MACOSX', '..').split('.')[2]
@@ -132,14 +128,14 @@ def main():
         browser_name = basename(browser, 'exe')
     else:
         browser_name = basename(browser)
-
+    
     # keep order!
     # first test for index...
     if special:
         start(special)
     else:
         start(entry)
-
+    
     return 0
 
 if __name__ == "__main__":

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,12 +58,11 @@ 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
-
-COLORIZE = False
+    import elementtree.ElementTree as etree # Python <= 2.4
 
+COLORIZE=False
 
 def main():
     global COLORIZE
@@ -80,8 +79,7 @@ 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):
     """
@@ -109,34 +107,30 @@ 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
@@ -146,6 +140,7 @@ def colorize(text, attrs=None, pattern=None):
     :param string pattern: text to be highlighted in input text
     :return: colored string
     """
+    
 
     if COLORIZE:
         try:
@@ -161,7 +156,6 @@ 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
 
@@ -206,11 +200,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({
@@ -223,9 +217,8 @@ 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:
@@ -234,7 +227,6 @@ 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 grass.script as gscript
-
+import os
+import string
+import grass.script as grass
 try:
     # new for python 2.6, in 2.5 it may be easy_install'd.
     import multiprocessing as mp
@@ -85,16 +85,14 @@ def get_percentile(map, percentiles):
     val2 = percentiles[1]
     values = '%s,%s' % (val1, val2)
 
-    s = gscript.read_command('r.quantile', input=map,
-                             percentiles=values, quiet=True)
+    s = grass.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,
@@ -103,16 +101,19 @@ def get_percentile_mp(map, percentiles, conn):
     output_pipe, input_pipe = conn
     input_pipe.close()
     result = get_percentile(map, percentiles)
-    gscript.debug('child (%s) (%.1f, %.1f)' % (map, result[0], result[1]))
+    grass.debug('child (%s) (%.1f, %.1f)' % (map, result[0], result[1]))
     output_pipe.send(result)
     output_pipe.close()
 
-
 def set_colors(map, v0, v1):
-    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)
+    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)
 
 
 def main():
@@ -123,7 +124,7 @@ def main():
     full = flags['f']
     preserve = flags['p']
     reset = flags['r']
-
+    
     global do_mp
 
     if flags['s']:
@@ -134,90 +135,92 @@ def main():
     # must be more than "2" ?
 
     if full:
-        for i in [red, green, blue]:
-            gscript.run_command('r.colors', map=i, color='grey', quiet=True)
-        sys.exit(0)
+	for i in [red, green, blue]:
+	    grass.run_command('r.colors', map = i, color = 'grey', quiet = True)
+	sys.exit(0)
 
     if reset:
-        for i in [red, green, blue]:
-            gscript.run_command('r.colors', map=i, color='grey255', quiet=True)
-        sys.exit(0)
+	for i in [red, green, blue]:
+	    grass.run_command('r.colors', map = i, color = 'grey255', quiet = True)
+	sys.exit(0)
+
 
     if not preserve:
         if do_mp:
-            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)
+            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)
 
     else:
-        all_max = 0
-        all_min = 999999
+	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)
 
-        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 = gscript.gisenv()['MAPSET']
+    mapset = grass.gisenv()['MAPSET']
     for i in [red, green, blue]:
-        if gscript.find_file(i)['mapset'] == mapset:
-            gscript.raster_history(i)
+        if grass.find_file(i)['mapset'] == mapset:
+            grass.raster_history(i)
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     main()

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

@@ -32,70 +32,67 @@
 #%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 = gscript.pipe_command('r.colors.out', map=map)
+    p = grass.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 gscript.raster_info(map)['max']
-
+    return grass.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)
-    msg = _('Do not forget to set region properly to cover all images.')
-    gscript.warning(msg)
+
+    grass.warning(_('Do not forget to set region properly to cover all images.'))
 
     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
 
-    gscript.message(_("Mosaicing %d images...") % count)
+    grass.message(_("Mosaicing %d images...") % count)
 
-    gscript.mapcalc("$output = " + make_expression(1, count),
-                    output=output, **parms)
+    grass.mapcalc("$output = " + make_expression(1, count),
+		  output = output, **parms)
 
-    # modify the color table:
-    p = gscript.feed_command('r.colors', map=output, rules='-')
+    #modify the color table:
+    p = grass.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()
 
-    gscript.message(_("Done. Raster map <%s> created.") % output)
+    grass.message(_("Done. Raster map <%s> created.") % output)
 
     # write cmd history:
-    gscript.raster_history(output)
+    grass.raster_history(output)
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.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 gscript
+import grass.script as grass
 from grass.exceptions import CalledModuleError
 
 
@@ -67,109 +67,103 @@ 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
-    gscript.try_remove(vrtfile)
-    gscript.try_remove(tmpfile)
-
+   #### clean up the mess
+   grass.try_remove(vrtfile)
+   grass.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 gscript.find_program('gdalinfo', '--help'):
-        gscript.fatal(_("'gdalinfo' not found, install GDAL tools first "
-                        "(http://www.gdal.org)"))
+    #### 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)"))
 
     pid = str(os.getpid())
-    tmpfile = gscript.tempfile()
+    tmpfile = grass.tempfile()
 
-    # let's go
+    ################### let's go
 
     spotdir = os.path.dirname(infile)
-    spotname = gscript.basename(infile, 'hdf')
+    spotname = grass.basename(infile, 'hdf')
 
     if rast:
-        name = rast
+	name = rast
     else:
-        name = spotname
+	name = spotname
 
-    if not gscript.overwrite() and gscript.find_file(name)['file']:
-        gscript.fatal(_("<%s> already exists. Aborting.") % name)
+    if not grass.overwrite() and grass.find_file(name)['file']:
+	grass.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'):
-        gscript.fatal(_("Please extract %s before import.") % infile)
+	grass.fatal(_("Please extract %s before import.") % infile)
 
     try:
-        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)
+	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)
     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:
-    gscript.try_remove(vrtfile)
+    grass.try_remove(vrtfile)
     create_VRT_file(projfile, vrtfile, infile)
 
-    # let's import the NDVI map...
-    gscript.message(_("Importing SPOT VGT NDVI map..."))
+    ## let's import the NDVI map...
+    grass.message(_("Importing SPOT VGT NDVI map..."))
     try:
-        gscript.run_command('r.in.gdal', input=vrtfile, output=name)
+        grass.run_command('r.in.gdal', input=vrtfile, output=name)
     except CalledModuleError:
-        gscript.fatal(_("An error occurred. Stop."))
+        grass.fatal(_("An error occurred. Stop."))
 
-    gscript.message(_("Imported SPOT VEGETATION NDVI map <%s>.") % name)
+    grass.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
@@ -179,29 +173,28 @@ def main():
 
     # clone current region
     # switch to a temporary region
-    gscript.use_temp_region()
+    grass.use_temp_region()
 
-    gscript.run_command('g.region', raster=name, quiet=True)
+    grass.run_command('g.region', raster = name, quiet = True)
 
-    gscript.message(_("Remapping digital numbers to NDVI..."))
+    grass.message(_("Remapping digital numbers to NDVI..."))
     tmpname = "%s_%s" % (name, pid)
-    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)
+    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)
 
     # write cmd history:
-    gscript.raster_history(name)
+    grass.raster_history(name)
 
-    # apply color table:
-    gscript.run_command('r.colors', map=name, color='ndvi', quiet=True)
+    #apply color table:
+    grass.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
@@ -212,7 +205,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)
     #
@@ -225,55 +218,54 @@ def main():
     # A good map threshold: >= 248
 
     if also:
-        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'
+	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'
         try:
-            gscript.run_command('r.in.gdal', input=vrtfile, output=smfile)
+            grass.run_command('r.in.gdal', input=vrtfile, output=smfile)
         except CalledModuleError:
-            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."))
+            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."))
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     atexit.register(cleanup)
     main()
+

scripts/i.oif/i.oif.py

@@ -121,6 +121,7 @@ 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],
@@ -140,7 +141,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,22 +77,20 @@
 import os
 import atexit
 from grass.script.utils import try_rmdir
-from grass.script import core as gcore
+from grass.script import core as grass
 
 
 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
 
@@ -109,12 +107,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:
-            gcore.fatal(_("Programmer error (%s)") % img_format)
+            grass.fatal(_("Programmer error (%s)") % img_format)
 
         lines += [
             "set term " + term_opts,
@@ -154,9 +152,9 @@ def draw_gnuplot(what, xlabels, output, img_format, coord_legend):
     plotf.close()
 
     if output:
-        gcore.call(['gnuplot', plotfile])
+        grass.call(['gnuplot', plotfile])
     else:
-        gcore.call(['gnuplot', '-persist', plotfile])
+        grass.call(['gnuplot', '-persist', plotfile])
 
 
 def draw_linegraph(what):
@@ -177,7 +175,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]
@@ -187,7 +185,7 @@ def draw_linegraph(what):
         colors += gp_colors
     colors = colors[0:len(what)]
 
-    gcore.run_command('d.linegraph', x_file=xfile, y_file=yfiles,
+    grass.run_command('d.linegraph', x_file=xfile, y_file=yfiles,
                       y_color=colors, title='Spectral signatures',
                       x_title='Bands', y_title='DN Value')
 
@@ -203,26 +201,26 @@ def main():
     textfile = flags['t']
 
     global tmp_dir
-    tmp_dir = gcore.tempdir()
-
+    tmp_dir = grass.tempdir()
+    
     if not group and not raster:
-        gcore.fatal(_("Either group= or raster= is required"))
+        grass.fatal(_("Either group= or raster= is required"))
 
     if group and raster:
-        gcore.fatal(_("group= and raster= are mutually exclusive"))
+        grass.fatal(_("group= and raster= are mutually exclusive"))
 
     # -t needs an output filename
     if textfile and not output:
-        gcore.fatal(_("Writing to text file requires output=filename"))
+        grass.fatal(_("Writing to text file requires output=filename"))
 
     # check if gnuplot is present
-    if gnuplot and not gcore.find_program('gnuplot', '-V'):
-        gcore.fatal(_("gnuplot required, please install first"))
+    if gnuplot and not grass.find_program('gnuplot', '-V'):
+        grass.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 = gcore.read_command('i.group', flags='g', group=group, quiet=True)
+        s = grass.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
@@ -233,10 +231,10 @@ def main():
 
     # get y-data for gnuplot-data file
     what = []
-    s = gcore.read_command('r.what', map=rastermaps, coordinates=coords,
+    s = grass.read_command('r.what', map=rastermaps, coordinates=coords,
                            null='0', quiet=True)
     if len(s) == 0:
-        gcore.fatal(_('No data returned from query'))
+        grass.fatal(_('No data returned from query'))
 
     for l in s.splitlines():
         f = l.split('|')
@@ -256,6 +254,6 @@ def main():
         draw_linegraph(what)
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.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,11 +95,10 @@ import sys
 import os
 import threading
 from grass.script.utils import separator, parse_key_val
-from grass.script import core as gcore
+from grass.script import core as grass
 
 
 class TrThread(threading.Thread):
-
     def __init__(self, ifs, inf, outf):
         threading.Thread.__init__(self)
         self.ifs = ifs
@@ -132,28 +131,28 @@ def main():
     include_header = flags['c']
 
     # check for cs2cs
-    if not gcore.find_program('cs2cs'):
-        gcore.fatal(_(
+    if not grass.find_program('cs2cs'):
+        grass.fatal(_(
             "cs2cs program not found, install PROJ.4 first: \
             http://proj.maptools.org"))
 
     # check for overenthusiasm
     if proj_in and ll_in:
-        gcore.fatal(_("Choose only one input parameter method"))
+        grass.fatal(_("Choose only one input parameter method"))
 
     if proj_out and ll_out:
-        gcore.fatal(_("Choose only one output parameter method"))
+        grass.fatal(_("Choose only one output parameter method"))
 
     if ll_in and ll_out:
-        gcore.fatal(_("Choise only one auto-projection parameter method"))
+        grass.fatal(_("Choise only one auto-projection parameter method"))
 
-    if output and not gcore.overwrite() and os.path.exists(output):
-        gcore.fatal(_("Output file already exists"))
+    if output and not grass.overwrite() and os.path.exists(output):
+        grass.fatal(_("Output file already exists"))
 
     if not coords and not input:
-        gcore.fatal(_("One of <coordinates> and <input> must be given"))
+        grass.fatal(_("One of <coordinates> and <input> must be given"))
     if coords and input:
-        gcore.fatal(_(
+        grass.fatal(_(
             "Options <coordinates> and <input> are mutually exclusive"))
 
     # parse field separator
@@ -170,59 +169,59 @@ def main():
     ofs = separator(ofs)
 
     # set up projection params
-    s = gcore.read_command("g.proj", flags='j')
+    s = grass.read_command("g.proj", flags='j')
     kv = parse_key_val(s)
     if "XY location" in kv['+proj'] and (ll_in or ll_out):
-        gcore.fatal(_("Unable to project to or from a XY location"))
+        grass.fatal(_("Unable to project to or from a XY location"))
 
     in_proj = None
 
     if ll_in:
         in_proj = "+proj=longlat +datum=WGS84"
-        gcore.verbose(
+        grass.verbose(
             "Assuming LL WGS84 as input, current projection as output ")
 
     if ll_out:
-        in_proj = gcore.read_command('g.proj', flags='jf')
+        in_proj = grass.read_command('g.proj', flags='jf')
 
     if proj_in:
         if '+' in proj_in:
             in_proj = proj_in
         else:
-            gcore.fatal(_("Invalid PROJ.4 input specification"))
+            grass.fatal(_("Invalid PROJ.4 input specification"))
 
     if not in_proj:
-        gcore.verbose("Assuming current location as input")
-        in_proj = gcore.read_command('g.proj', flags='jf')
+        grass.verbose("Assuming current location as input")
+        in_proj = grass.read_command('g.proj', flags='jf')
 
     in_proj = in_proj.strip()
-    gcore.verbose("Input parameters: '%s'" % in_proj)
+    grass.verbose("Input parameters: '%s'" % in_proj)
 
     out_proj = None
 
     if ll_out:
         out_proj = "+proj=longlat +datum=WGS84"
-        gcore.verbose(
+        grass.verbose(
             "Assuming current projection as input, LL WGS84 as output ")
 
     if ll_in:
-        out_proj = gcore.read_command('g.proj', flags='jf')
+        out_proj = grass.read_command('g.proj', flags='jf')
 
     if proj_out:
         if '+' in proj_out:
             out_proj = proj_out
         else:
-            gcore.fatal(_("Invalid PROJ.4 output specification"))
+            grass.fatal(_("Invalid PROJ.4 output specification"))
 
     if not out_proj:
-        gcore.fatal(_("Missing output projection parameters "))
+        grass.fatal(_("Missing output projection parameters "))
     out_proj = out_proj.strip()
-    gcore.verbose("Output parameters: '%s'" % out_proj)
+    grass.verbose("Output parameters: '%s'" % out_proj)
 
     # set up input file
     if coords:
         x, y = coords.split(',')
-        tmpfile = gcore.tempfile()
+        tmpfile = grass.tempfile()
         fd = open(tmpfile, "w")
         fd.write("%s%s%s\n" % (x, ifs, y))
         fd.close()
@@ -234,9 +233,9 @@ def main():
         else:
             infile = input
             if not os.path.exists(infile):
-                gcore.fatal(_("Unable to read input data"))
+                grass.fatal(_("Unable to read input data"))
             inf = file(infile)
-            gcore.debug("input file=[%s]" % infile)
+            grass.debug("input file=[%s]" % infile)
 
     # set up output file
     if not output:
@@ -245,7 +244,7 @@ def main():
     else:
         outfile = output
         outf = open(outfile, 'w')
-        gcore.debug("output file=[%s]" % outfile)
+        grass.debug("output file=[%s]" % outfile)
 
     # set up output style
     if not decimal:
@@ -264,7 +263,7 @@ def main():
     cmd = ['cs2cs'] + copyinp + outfmt + \
         in_proj.split() + ['+to'] + out_proj.split()
 
-    p = gcore.Popen(cmd, stdin=gcore.PIPE, stdout=gcore.PIPE)
+    p = grass.Popen(cmd, stdin=grass.PIPE, stdout=grass.PIPE)
 
     tr = TrThread(ifs, inf, p.stdin)
     tr.start()
@@ -277,7 +276,7 @@ def main():
                 xy, z = line.split(' ', 1)
                 x, y = xy.split('\t')
             except ValueError:
-                gcore.fatal(line)
+                grass.fatal(line)
 
             outf.write('%s%s%s%s%s\n' %
                        (x.strip(), ofs, y.strip(), ofs, z.strip()))
@@ -295,9 +294,9 @@ def main():
     p.wait()
 
     if p.returncode != 0:
-        gcore.warning(_(
+        grass.warning(_(
             "Projection transform probably failed, please investigate"))
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.parser()
     main()

scripts/r.blend/r.blend.py

@@ -40,13 +40,14 @@
 #%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 gscript
-
+import grass.script as grass
 
 def main():
     first = options['first']
@@ -54,13 +55,13 @@ def main():
     output = options['output']
     percent = options['percent']
 
-    mapset = gscript.gisenv()['MAPSET']
+    mapset = grass.gisenv()['MAPSET']
 
-    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)
+    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)
 
     percent = float(percent)
     perc_inv = 100.0 - percent
@@ -68,54 +69,47 @@ def main():
     frac1 = percent / 100.0
     frac2 = perc_inv / 100.0
 
-    gscript.message(_("Calculating the three component maps..."))
+    grass.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)
 
-    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'])
+    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'])
+
 
     if flags['c']:
-        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'])
+        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'])
     else:
-        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))
+        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))
 
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     main()

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

@@ -53,17 +53,14 @@ 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
@@ -78,13 +75,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]
 
@@ -95,8 +92,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)"
@@ -104,22 +101,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):
@@ -128,11 +125,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,21 +30,18 @@
 #% description: Force center at zero
 #%end
 
+import sys
 import os
 import atexit
-
-import grass.script as gscript
-
+import grass.script as grass
 
 def z(n):
     return mean + n * stddev
 
-
 def cleanup():
     if tmpmap:
-        gscript.run_command('g.remove', flags='f', type='raster',
-                            name=tmpmap, quiet=True)
-
+	grass.run_command('g.remove', flags = 'f', type = 'raster',
+                      name = tmpmap, quiet = True)
 
 def main():
     global tmpmap
@@ -55,89 +52,90 @@ def main():
     bands = flags['b']
 
     if not zero:
-        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"])
+	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"])
     else:
-        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)
+	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)
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     atexit.register(cleanup)
     main()

scripts/r.fillnulls/r.fillnulls.py

@@ -98,18 +98,15 @@ 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
@@ -122,63 +119,63 @@ def main():
     edge = int(options['edge'])
     segmax = int(options['segmax'])
     npmin = int(options['npmin'])
-    quiet = True  # FIXME
-
+    quiet = True # FIXME 
+    
     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)
 
     # save original region
     reg_org = grass.region()
-
+    
     # 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']
-
+        
         grass.message(_("Using RST interpolation..."))
         grass.message(_("Locating and isolating NULL areas..."))
-
+        
         # creating binary (0/1) map
         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
         # to ignore MASKed original values
         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
-
+    
         # grow identified holes by X pixels
         grass.message(_("Growing NULL areas"))
         tmp_rmaps.append(prefix + 'grown')
@@ -193,21 +190,15 @@ def main():
         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:"))
 
         # 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
         try:
             grass.run_command('r.to.vect', flags='v',
@@ -216,26 +207,20 @@ def main():
         except:
             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:
             cat_list.append(line.rstrip('\n'))
         cats_file.close()
         os.remove(cats_file_name)
-
+        
         if len(cat_list) < 1:
             grass.fatal(_("Input map has no holes. Check region settings."))
-
+        
         # GTC Hole is NULL area in a raster map
         grass.message(_("Processing %d map holes") % len(cat_list))
         first = True
@@ -253,20 +238,19 @@ def main():
             except CalledModuleError:
                 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),
+                                  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),
                                   quiet=quiet)
             except CalledModuleError:
                 grass.fatal(_("abandoned. Removing temporary maps, restoring user mask if needed:"))
-
+            
             # remove temporary map to not overfill disk
             try:
                 grass.run_command('g.remove', flags='fb', type='vector',
@@ -274,29 +258,29 @@ def main():
             except CalledModuleError:
                 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
+            
+            # If here loop is split into two, next part of loop can be run in parallel 
             # (except final result patching)
             # Downside - on large maps such approach causes large disk usage
-
+            
             # grow hole border to get it's edge area
             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:"))
-
+            
             # 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)
+            grass.mapcalc("$out = if($inp == -1, null(), $dem)", 
+                            out = holename + '_edges', inp = holename + '_grown', dem = input)
             tmp_rmaps.append(holename + '_edges')
-
+            
             # convert to points for interpolation
             tmp_vmaps.append(holename)
             try:
@@ -305,32 +289,32 @@ def main():
                                   type='point', flags='z', quiet=quiet)
             except CalledModuleError:
                 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:
                 grass.verbose(_("No points to interpolate"))
                 failed_list.append(holename)
                 continue
-
+            
             # Avoid v.surf.rst warnings
             if pointsnumber < segmax:
                 npmin = pointsnumber + 1
                 segmax = pointsnumber
-
+            
             # launch v.surf.rst
             tmp_rmaps.append(holename + '_dem')
             try:
                 grass.run_command('v.surf.rst', quiet=quiet,
                                   input=holename, elev=holename + '_dem',
-                                  tension=tension, smooth=smooth,
+                                  tension=tension, smooth=smooth, 
                                   segmax=segmax, npmin=npmin)
             except CalledModuleError:
                 # GTC Hole is NULL area in a raster map
                 grass.fatal(_("Failed to fill hole %s") % cat)
-
+            
             # v.surf.rst sometimes fails with exit code 0
             # related bug #1813
             if not grass.find_file(holename + '_dem')['file']:
@@ -342,40 +326,30 @@ 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.mapcalc("$out = if(isnull($inp), null(), $dem)",
-                              out=filling, inp=holename, dem=holename + '_dem')
+                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')
                 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:"))
-                # this map has been removed. No need for later cleanup.
-                tmp_rmaps.remove(filling + '_tmp')
-
+                    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.
+            
             # remove temporary maps to not overfill disk
             try:
                 tmp_rmaps.remove(holename)
@@ -402,28 +376,28 @@ def main():
                                   type='vector', name=holename)
             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_=0.01, 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_ = 0.01, 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_=0.01, 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_ = 0.01, flags = 'n')
 
     # restoring user's mask, if present:
     if usermask:
@@ -435,13 +409,13 @@ 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()
@@ -450,10 +424,9 @@ def main():
 
     # write cmd history:
     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,9 +72,8 @@ 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
@@ -109,7 +108,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)
 
@@ -121,10 +120,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,8 +161,7 @@ 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']
@@ -212,18 +211,14 @@ 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)
@@ -332,9 +327,7 @@ 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
 
@@ -347,9 +340,7 @@ 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,37 +129,36 @@ 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,13 +116,12 @@ 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
 
@@ -132,55 +131,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
 
@@ -189,26 +188,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
@@ -216,10 +215,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'
@@ -227,7 +226,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)
@@ -239,7 +238,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,31 +178,29 @@ 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']:
@@ -213,7 +211,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,7 +32,6 @@ 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
@@ -46,7 +45,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()
@@ -85,7 +84,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
@@ -102,10 +101,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

@@ -1,5 +1,5 @@
 """!
-@brief Preparation of parameters for drivers, which download it, and managing downloaded data.
+@brief Preparation of parameters for drivers, which download it, and managing downloaded data. 
 
 List of classes:
  - wms_base::WMSBase
@@ -26,32 +26,31 @@ 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
 
     def __del__(self):
-
+            
         # tries to remove temporary files, all files should be
         # removed before, implemented just in case of unexpected
         # stop of module
         for temp_file in self.temp_files_to_cleanup:
             grass.try_remove(temp_file)
-
+        
     def _debug(self, fn, msg):
         grass.debug("%s.%s: %s" %
                     (self.__class__.__name__, fn, msg))
-
+        
     def _initializeParameters(self, options, flags):
         self._debug("_initialize_parameters", "started")
-
+        
         # initialization of module parameters (options, flags)
         self.params['driver'] = options['driver']
         drv_info = WMSDriversInfo()
@@ -69,49 +68,46 @@ class WMSBase:
         if self.flags['o']:
             self.params['transparent'] = 'FALSE'
         else:
-            self.params['transparent'] = 'TRUE'
+            self.params['transparent'] = 'TRUE'   
 
         for key in ['password', 'username', 'urlparams']:
-            self.params[key] = options[key]
+            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']
+        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"
         else:
             self.params['proj_name'] = "SRS"
 
         # read projection info
-        self.proj_location = grass.read_command('g.proj',
-                                                flags='jf').rstrip('\n')
+        self.proj_location = grass.read_command('g.proj', 
+                                                flags ='jf').rstrip('\n')
         self.proj_location = self._modifyProj(self.proj_location)
 
         if self.params['srs'] in [3857, 900913]:
@@ -120,10 +116,10 @@ class WMSBase:
             # needed to be tested on more servers
             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')
-
+            self.proj_srs = grass.read_command('g.proj', 
+                                               flags = 'jf', 
+                                               epsg = str(GetEpsg(self.params['srs']))).rstrip('\n')
+        
         self.proj_srs = self._modifyProj(self.proj_srs)
 
         if not self.proj_srs or not self.proj_location:
@@ -135,27 +131,18 @@ class WMSBase:
         maxcols = int(options['maxcols'])
         if maxcols <= min_tile_size:
             grass.fatal(_("Maxcols must be greater than 100"))
-
+        
         maxrows = int(options['maxrows'])
         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"
-
+        
         self._debug("_initialize_parameters", "finished")
 
     def _modifyProj(self, proj):
@@ -173,34 +160,34 @@ class WMSBase:
         not_relevant_params = []
         for i_param in driver_props['ignored_params']:
 
-            if i_param in options and \
+            if options.has_key(i_param) 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._initializeParameters(options, flags)  
 
+        self.bbox     = self._computeBbox()
+        
         self.temp_map = self._download()
 
         if not self.temp_map:
@@ -209,8 +196,8 @@ class WMSBase:
         self._reprojectMap()
 
         return self.temp_warpmap
-
-    def _fetchCapabilities(self, options):
+    
+    def _fetchCapabilities(self, options): 
         """!Download capabilities from WMS server
         """
         cap_url = options['url'].strip()
@@ -225,48 +212,46 @@ class WMSBase:
         elif 'OnEarth' in options['driver']:
             cap_url += "REQUEST=GetTileService"
         else:
-            cap_url += "SERVICE=WMS&REQUEST=GetCapabilities&VERSION=" + options['wms_version']
+            cap_url += "SERVICE=WMS&REQUEST=GetCapabilities&VERSION=" + options['wms_version'] 
 
         if options['urlparams']:
             cap_url += "&" + options['urlparams']
-
+            
         grass.debug('Fetching capabilities file.\n%s' % cap_url)
 
         try:
             cap = self._fetchDataFromServer(cap_url, options['username'], options['password'])
         except (IOError, HTTPException) as e:
-            if isinstance(e, urllib2.HTTPError) and e.code == 401:
-                grass.fatal(
-                    _("Authorization failed to <%s> when fetching capabilities") %
-                    options['url'])
+            if urllib2.HTTPError == type(e) and e.code == 401:
+                grass.fatal(_("Authorization failed to <%s> when fetching capabilities") % options['url'])
             else:
                 msg = _("Unable to fetch capabilities from <%s>: %s") % (options['url'], e)
-
+                
                 if hasattr(e, 'reason'):
                     msg += _("\nReason: ") + e.reason
-
+                
                 grass.fatal(msg)
-
+        
         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 = urllib2.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 urllib2.urlopen(request)
         except ValueError as error:
             grass.fatal("%s" % error)
 
-    def GetCapabilities(self, options):
+    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
@@ -276,61 +261,61 @@ class WMSBase:
                 temp.write(cap.read())
                 temp.close()
                 return
-            except IOError as error:
+            except IOError as error: 
                 grass.fatal(_("Unabble to open file '%s'.\n%s\n" % (cap_file, error)))
-
+        
         # print to output
         cap_lines = cap.readlines()
-        for line in cap_lines:
+        for line in cap_lines: 
             print line.rstrip()
-
+        
     def _computeBbox(self):
         """!Get region extent for WMS query (bbox)
         """
         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
+        if self.proj_srs == self.proj_location: # TODO: do it better
             for bbox_item, region_item in bbox_region_items.iteritems():
                 bbox[bbox_item] = self.region[region_item]
-
+        
         # if location projection and wms query projection are
         # different, corner points of region are transformed into wms
         # projection and then bbox is created from extreme coordinates
         # of the transformed points
         else:
-            for bbox_item, region_item in bbox_region_items.iteritems():
+            for bbox_item, region_item  in bbox_region_items.iteritems():
                 bbox[bbox_item] = None
 
             temp_region = self._tempfile()
-
+            
             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"))
-            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
+                 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
             grass.try_remove(temp_region)
             if not points:
                 grass.fatal(_("Unable to determine region, %s failed") % 'm.proj')
-
+            
             points = points.splitlines()
             if len(points) != 4:
                 grass.fatal(_("Region definition: 4 points required"))
-
+            
             for point in points:
                 try:
                     point = map(float, point.split("|"))
@@ -342,33 +327,33 @@ class WMSBase:
                     bbox['maxx'] = point[0]
                     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]
-
+                    bbox['minx'] = point[0]  
+        
         self._debug("_computeBbox", "finished -> %s" % bbox)
 
         # Ordering of coordinates axis of geographic coordinate
-        # systems in WMS 1.3.0 is flipped. If  self.tile_size['flip_coords'] is
+        # systems in WMS 1.3.0 is flipped. If  self.tile_size['flip_coords'] is 
         # True, coords in bbox need to be flipped in WMS query.
 
         return bbox
 
-    def _reprojectMap(self):
+    def _reprojectMap(self): 
         """!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()
-
+            
             if int(os.getenv('GRASS_VERBOSE', '2')) <= 2:
                 nuldev = file(os.devnull, 'w+')
             else:
@@ -380,7 +365,7 @@ class WMSBase:
                 gdal_method = "bilinear"
             else:
                 gdal_method = self.params['method']
-
+            
             #"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs"
             # RGB rasters - alpha layer is added for cropping edges of projected raster
             try:
@@ -389,21 +374,21 @@ 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'))
-
+            
             if nuldev:
                 nuldev.close()
-
+            
             if ps.returncode != 0:
                 grass.fatal(_('%s failed') % 'gdalwarp')
             grass.try_remove(self.temp_map)
@@ -413,28 +398,26 @@ class WMSBase:
             self.temp_files_to_cleanup.remove(self.temp_map)
 
         return self.temp_warpmap
-
+        
     def _tempfile(self):
-        """!Create temp_file and append list self.temp_files_to_cleanup
-            with path of file
-
+        """!Create temp_file and append list self.temp_files_to_cleanup 
+            with path of file 
+     
         @return string path to temp_file
         """
         temp_file = grass.tempfile()
         if temp_file is None:
             grass.fatal(_("Unable to create temporary files"))
-
+        
         # list of created tempfiles for destructor
         self.temp_files_to_cleanup.append(temp_file)
-
+        
         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
@@ -444,13 +427,13 @@ class GRASSImporter:
         # into raster named:self.opt_output + this suffix)
         self.original_mask_suffix = "_temp_MASK"
 
-        # check names of temporary rasters, which module may create
+        # 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:
             grass.fatal(_("Please change output name, or change names of these rasters: %s, "
                           "module needs to create this temporary maps during execution.") % ",".join(maps))
@@ -464,9 +447,8 @@ class GRASSImporter:
             except CalledModuleError:
                 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']:
+            # restore original mask, if exists 
+            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,
@@ -475,25 +457,25 @@ class GRASSImporter:
                     grass.fatal(_('%s failed') % 'g.copy')
 
         # remove temporary created rasters
-        if self.cleanup_layers:
+        if self.cleanup_layers: 
             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))
-
-        # delete environmental variable which overrides region
+                                  quiet = True,
+                                  flags = 'fb',
+                                  type = 'raster',
+                                  name = ','.join(maps))
+        
+        # delete environmental variable which overrides region 
         if 'GRASS_REGION' in os.environ.keys():
             os.environ.pop('GRASS_REGION')
 
-    def ImportMapIntoGRASS(self, raster):
+    def ImportMapIntoGRASS(self, raster): 
         """!Import raster into GRASS.
         """
         # importing temp_map into GRASS
@@ -507,20 +489,20 @@ class GRASSImporter:
         # information for destructor to cleanup temp_layers, created
         # with r.in.gdal
         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,
@@ -539,8 +521,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,
@@ -553,9 +535,7 @@ class GRASSImporter:
 
         grass.message(_('<%s> created.') % self.opt_output)
 
-
 class WMSDriversInfo:
-
     def __init__(self):
         """!Provides information about driver parameters.
         """
@@ -564,16 +544,11 @@ 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.
         """
@@ -586,11 +561,12 @@ class WMSDriversInfo:
         if 'OnEarth' in driver:
             return self._OnEarthProperties()
 
+
     def _OnEarthProperties(self):
 
         props = {}
         props['ignored_flags'] = ['o']
-        props['ignored_params'] = ['bgcolor', 'styles', 'capfile_output',
+        props['ignored_params'] = ['bgcolor', 'styles', 'capfile_output', 
                                    'format', 'srs', 'wms_version']
         props['req_multiple_layers'] = False
 
@@ -619,7 +595,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
@@ -646,7 +622,8 @@ 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.
     """
@@ -656,12 +633,11 @@ def GetSRSParamVal(srs):
     else:
         return "EPSG:%d" % srs
 
-
 def GetEpsg(srs):
     """
-     @return EPSG number
+     @return EPSG number 
              If srs is CRS number, return EPSG number which corresponds to CRS number.
-    """
+    """    
     if srs == 84:
         return 4326
     if srs == 83:

scripts/r.in.wms/wms_cap_parsers.py

@@ -18,36 +18,32 @@ 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:
@@ -55,7 +51,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
         """
@@ -63,32 +59,30 @@ 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:
@@ -108,54 +102,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'))
@@ -166,7 +160,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
@@ -174,7 +168,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))
@@ -182,50 +176,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))
 
@@ -237,7 +231,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))
 
@@ -257,11 +251,9 @@ 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.
         """
@@ -272,21 +264,19 @@ 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)
@@ -330,8 +320,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:
@@ -339,12 +329,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:
@@ -356,12 +346,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
@@ -374,13 +364,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.
         """
@@ -405,7 +395,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)
@@ -443,7 +433,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
 
@@ -466,9 +456,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)
@@ -481,9 +471,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)
@@ -501,17 +491,15 @@ 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)
 
@@ -521,7 +509,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:
@@ -538,11 +526,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)
 
@@ -557,7 +545,7 @@ class OnEarthCapabilitiesTree(BaseCapabilitiesTree):
         """
         if layer.tag == 'TiledGroups':
             return True
-
+            
         name = layer.find('Name')
         if name is None or not name.text:
             return False
@@ -586,7 +574,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:
@@ -597,7 +585,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:
@@ -605,7 +593,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
@@ -620,8 +608,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=")
@@ -629,8 +617,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:
@@ -642,7 +630,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,133 +26,129 @@ 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 gdal.DCAP_CREATECOPY not in metadata or \
+        if not metadata.has_key(gdal.DCAP_CREATECOPY) 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,12 +75,11 @@ 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']
@@ -96,13 +95,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"))
@@ -113,9 +112,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']:
@@ -126,12 +125,7 @@ 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()
@@ -139,13 +133,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)
@@ -158,25 +152,23 @@ 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,7 +37,6 @@ 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,11 +40,9 @@ 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']
@@ -56,30 +54,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)
@@ -87,14 +85,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()
@@ -103,22 +101,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,37 +59,38 @@
 #%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 gscript
-
+import grass.script as grass
 
 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 = gscript.region()
+    reg = grass.region()
 
     ### test input values ###
     if abs(dip) >= 90:
-        gscript.fatal(_("dip must be between -90 and 90."))
+	grass.fatal(_("dip must be between -90 and 90."))
 
     if az < 0 or az >= 360:
-        gscript.fatal(_("azimuth must be between 0 and 360"))
+	grass.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)
 
@@ -101,28 +102,27 @@ 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"
 
-    gscript.mapcalc("$name = $type($round(x() * $kx + y() * $ky + $kz))",
-                    name=name, type=dtype, round=round, kx=kx, ky=ky, kz=kz)
+    grass.mapcalc("$name = $type($round(x() * $kx + y() * $ky + $kz))",
+		  name = name, type = dtype, round = round, kx = kx, ky = ky, kz = kz)
 
-    gscript.run_command('r.support', map=name, history='')
-    gscript.raster_history(name)
+    grass.run_command('r.support', map = name, history = '')
+    grass.raster_history(name)
 
-    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))
+    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))
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.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,17 +111,15 @@ 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 as error:
+    except CalledModuleError, 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,14 +106,13 @@
 # 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 gcore
+from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
 
@@ -159,7 +158,7 @@ def project(file, source, dest):
     errors = 0
     points = []
     try:
-        ret = gcore.read_command('m.proj',
+        ret = grass.read_command('m.proj',
                                  quiet=True,
                                  flags='d',
                                  proj_in=source['proj'],
@@ -167,10 +166,10 @@ def project(file, source, dest):
                                  sep=';',
                                  input=file)
     except CalledModuleError:
-        gcore.fatal(cs2cs + ' failed')
+        grass.fatal(cs2cs + ' failed')
 
     if not ret:
-        gcore.fatal(cs2cs + ' failed')
+        grass.fatal(cs2cs + ' failed')
 
     for line in ret.splitlines():
         if "*" in line:
@@ -239,42 +238,40 @@ def main():
     max_rows = int(options['maxrows']) - int(options['overlap'])
 
     if max_cols == 0:
-        gcore.fatal(_("It is not possibile to set 'maxcols=%s' and "
+        grass.fatal(_("It is not possibile to set 'maxcols=%s' and "
                       "'overlap=%s'. Please set maxcols>overlap" %
                       (options['maxcols'], options['overlap'])))
     elif max_rows == 0:
-        gcore.fatal(_("It is not possibile to set 'maxrows=%s' and "
+        grass.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 = gcore.read_command('g.proj',
+        dest_proj = grass.read_command('g.proj',
                                        quiet=True,
                                        flags='jf').rstrip('\n')
         if not dest_proj:
-            gcore.fatal(_('g.proj failed'))
+            grass.fatal(_('g.proj failed'))
     else:
         dest_proj = options['destproj']
-    gcore.debug("Getting destination projection -> '%s'" % dest_proj)
+    grass.debug("Getting destination projection -> '%s'" % dest_proj)
 
     # projection scale
     if not options['destscale']:
-        ret = gcore.parse_command('g.proj',
+        ret = grass.parse_command('g.proj',
                                   quiet=True,
                                   flags='j')
         if not ret:
-            gcore.fatal(_('g.proj failed'))
+            grass.fatal(_('g.proj failed'))
 
         if '+to_meter' in ret:
             dest_scale = ret['+to_meter'].strip()
         else:
-            gcore.warning(
-                _("Scale (%s) not found, assuming '1'") %
-                '+to_meter')
+            grass.warning(_("Scale (%s) not found, assuming '1'") % '+to_meter')
             dest_scale = '1'
     else:
         dest_scale = options['destscale']
-    gcore.debug('Getting destination projection scale -> %s' % dest_scale)
+    grass.debug('Getting destination projection scale -> %s' % dest_scale)
 
     # set up the projections
     srs_source = {'proj': options['sourceproj'],
@@ -282,17 +279,17 @@ def main():
     srs_dest = {'proj': dest_proj, 'scale': float(dest_scale)}
 
     if options['region']:
-        gcore.run_command('g.region',
+        grass.run_command('g.region',
                           quiet=True,
                           region=options['region'])
-    dest_bbox = gcore.region()
-    gcore.debug('Getting destination region')
+    dest_bbox = grass.region()
+    grass.debug('Getting destination region')
 
     # output field separator
     fs = separator(options['separator'])
 
     # project the destination region into the source:
-    gcore.verbose('Projecting destination region into source...')
+    grass.verbose('Projecting destination region into source...')
     dest_bbox_points = bboxToPoints(dest_bbox)
 
     dest_bbox_source_points, errors_dest = projectPoints(dest_bbox_points,
@@ -300,24 +297,24 @@ def main():
                                                          dest=srs_source)
 
     if len(dest_bbox_source_points) == 0:
-        gcore.fatal(_("There are no tiles available. Probably the output "
+        grass.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)
 
-    gcore.verbose('Projecting source bounding box into destination...')
+    grass.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']
 
-    gcore.verbose('Computing length of sides of source bounding box...')
+    grass.verbose('Computing length of sides of source bounding box...')
 
     source_bbox_dest_lengths = sideLengths(source_bbox_dest_points,
                                            x_metric, y_metric)
@@ -327,14 +324,12 @@ 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']))
@@ -347,7 +342,7 @@ def main():
     # I'm going to make the numbers all simpler and add this extra cell to
     # every tile.
 
-    gcore.message(_('Computing tiling...'))
+    grass.message(_('Computing tiling...'))
     tiles = [-1, -1]
     tile_base_size = [-1, -1]
     tiles_extra_1 = [-1, -1]
@@ -368,7 +363,7 @@ def main():
         # Add overlap to tiles (doesn't effect tileset_size
         tile_size_overlap[i] = tile_size[i] + int(options['overlap'])
 
-    gcore.verbose("There will be %d by %d tiles each %d by %d cells" %
+    grass.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]
@@ -385,21 +380,16 @@ def main():
     tile_bbox = {'w': -1, 's': -1, 'e': -1, 'n': -1}
 
     if errors_dest > 0:
-        gcore.warning(_("During computation %i tiles could not be created" %
+        grass.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,
@@ -407,24 +397,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 = gcore.parser()
+    options, flags = grass.parser()
     sys.exit(main())

scripts/r.unpack/r.unpack.py

@@ -82,8 +82,7 @@ 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()
@@ -101,37 +100,36 @@ 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,7 +22,6 @@ import sys
 from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
-
 def main():
     env = grass.gisenv()
     mapset = env['MAPSET']
@@ -30,17 +29,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,19 +50,20 @@
 #%end
 
 import sys
-import grass.script as gscript
-
+import os
+import re
+import grass.script as grass
 
 def main():
     if options['option'] == 'add':
-        num_bound = gscript.vector_info_topo(map=options['input'])['boundaries']
-        if num_bound == 0:
-            gscript.fatal(_("Input vector map contains no boundaries."))
+        num_bound = grass.vector_info_topo(map = options['input'])['boundaries']
+	if num_bound == 0:
+	    grass.fatal(_("Input vector map contains no boundaries."))
 
-        gscript.exec_command("v.category", type='area', **options)
+	grass.exec_command("v.category", type = 'area', **options)
 
     sys.exit(0)
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.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,31 +42,29 @@ 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?"))
@@ -75,13 +73,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,46 +79,44 @@ 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 = map(lambda x: x.strip().lower(), 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',
@@ -129,22 +127,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 column not in grass.vector_columns(map, layer):
+        if not grass.vector_columns(map, layer).has_key(column):
             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 gscript
+import grass.script as grass
 from grass.exceptions import CalledModuleError
 
 
@@ -47,58 +47,56 @@ def main():
     layer = options['layer']
 
     # do some paranoia tests as well:
-    f = gscript.vector_layer_db(map, layer)
-
+    f = grass.vector_layer_db(map, layer)
+    
     if not table:
-        # Removing table name connected to selected layer
-        table = f['table']
-        if not table:
-            gscript.fatal(_("No table assigned to layer <%s>") % layer)
+	# Removing table name connected to selected layer
+	table = f['table']
+	if not table:
+	    grass.fatal(_("No table assigned to layer <%s>") % layer)
     else:
-        # 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
+	# 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 
     database = f['database']
     driver = f['driver']
 
-    gscript.message(_("Removing table <%s> linked to layer <%s> of vector"
-                      " map <%s>") % (table, layer, map))
+    grass.message(_("Removing table <%s> linked to layer <%s> of vector map <%s>")
+		  % (table, layer, map)) 
 
     if not force:
-        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(_("You must use the -f (force) flag to actually remove the table. Exiting."))
+	grass.message(_("Leaving map/table unchanged."))
+	sys.exit(0)
 
-    gscript.message(_("Dropping table <%s>...") % table)
+    grass.message(_("Dropping table <%s>...") % table)
 
     try:
-        gscript.write_command('db.execute', stdin="DROP TABLE %s" % table,
-                              input='-', database=database, driver=driver)
+        grass.write_command('db.execute', stdin="DROP TABLE %s" % table,
+                            input='-', database=database, driver=driver)
     except CalledModuleError:
-        gscript.fatal(_("An error occurred while running db.execute"))
+        grass.fatal(_("An error occurred while running db.execute"))
 
-    gscript.run_command('v.db.connect', flags='d', map=map, layer=layer)
+    grass.run_command('v.db.connect', flags = 'd', map = map, layer = layer)
 
-    gscript.message(_("Current attribute table link(s):"))
+    grass.message(_("Current attribute table link(s):")) 
     # silently test first to avoid confusing error messages
     nuldev = file(os.devnull, 'w')
     try:
-        gscript.run_command('v.db.connect', flags='p', map=map, quiet=True,
-                            stdout=nuldev, stderr=nuldev)
+        grass.run_command('v.db.connect', flags='p', map=map, quiet=True,
+                          stdout=nuldev, stderr=nuldev)
     except CalledModuleError:
-        gscript.message(_("(No database links remaining)"))
+        grass.message(_("(No database links remaining)"))
     else:
-        gscript.run_command('v.db.connect', flags='p', map=map)
+        grass.run_command('v.db.connect', flags='p', map=map)
 
     # write cmd history:
-    gscript.vector_history(map)
+    grass.vector_history(map)
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.parser()
     main()

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

@@ -77,7 +77,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"))
@@ -86,7 +86,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 column not in grass.vector_columns(map, layer):
+    if not grass.vector_columns(map, layer).has_key(column):
         grass.fatal(_("Column <%s> not found in table <%s>") % (column,
                                                                 maptable))
 
@@ -154,9 +154,7 @@ 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,120 +53,107 @@ import sys
 import os
 import string
 
-import grass.script as gscript
+import grass.script as grass
 from grass.exceptions import CalledModuleError
 
 # substitute variables (gisdbase, location_name, mapset)
-
-
 def substitute_db(database):
-    gisenv = gscript.gisenv()
+    gisenv = grass.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':
         path = os.path.dirname(subst_database)
         # check if destination directory exists
         if not os.path.isdir(path):
             os.makedirs(path)
-
-    if subst_database in gscript.read_command('db.databases', quiet=True,
-                                              driver=driver).splitlines():
+    
+    if subst_database in grass.read_command('db.databases', quiet = True,
+                                      driver = driver).splitlines():
         return False
 
-    gscript.info(_("Target database doesn't exist, "
-                   "creating a new database using <%s> driver...") % driver)
+    grass.info(_("Target database doesn't exist, "
+                 "creating a new database using <%s> driver...") % driver)
     try:
-        gscript.run_command('db.createdb', driver=driver,
-                            database=subst_database)
+        grass.run_command('db.createdb', driver = driver,
+                          database = subst_database)
     except CalledModuleError:
-        gscript.fatal(_("Unable to create database <%s> by driver <%s>") %
-                      (subst_database, driver))
-
+        grass.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 gscript.read_command('db.tables', quiet=True,
-                                        driver=to_driver,
-                                        database=to_database,
-                                        stderr=nuldev).splitlines():
+    if to_table in grass.read_command('db.tables', quiet = True,
+                                      driver = to_driver,
+                                      database = to_database,
+                                      stderr = nuldev).splitlines():
         return False
-
-    gscript.info("Copying table <%s> to target database..." % to_table)
+    
+    grass.info("Copying table <%s> to target database..." % to_table)
     try:
-        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)
+        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)
     except CalledModuleError:
-        gscript.fatal(_("Unable to copy table <%s>") % from_table)
-
+        grass.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:
-        gscript.run_command('v.db.connect', flags='d', quiet=True, map=vector,
-                            layer=layer, table=table)
+        grass.run_command('v.db.connect', flags = 'd', quiet = True, map = vector,
+			          layer = layer, table = table)
     except CalledModuleError:
-        gscript.warning(_("Unable to disconnect table <%s> from vector <%s>") %
-                        (table, vector))
+        grass.warning(_("Unable to disconnect table <%s> from vector <%s>") % (table, vector))
     # drop table
     try:
-        gscript.run_command('db.droptable', quiet=True, flags='f',
-                            driver=driver, database=database,
-                            table=table)
+        grass.run_command('db.droptable', quiet = True, flags = 'f',
+                          driver = driver, database = database,
+                          table = table)
     except CalledModuleError:
-        gscript.fatal(_("Unable to drop table <%s>") % table)
-
+        grass.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
 
-    gscript.info(_("Creating index <%s>...") % index_name)
+    grass.info(_("Creating index <%s>...") % index_name)
     try:
-        gscript.run_command('db.execute', quiet=True, driver=driver,
-                            database=database,
-                            sql="create unique index %s on %s(%s)" %
-                                (index_name, table, key))
+        grass.run_command('db.execute', quiet = True,
+                          driver = driver, database = database,
+                          sql = "create unique index %s on %s(%s)" % (index_name, table, key))
     except CalledModuleError:
-        gscript.warning(_("Unable to create index <%s>") % index_name)
-
+        grass.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 = gscript.db_connection()
+    default_connection = grass.db_connection()
     if options['new_driver']:
         new_driver = options['new_driver']
     else:
@@ -181,105 +168,93 @@ 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:
-        gscript.fatal(_("Old and new database connection is identical. "
-                        "Nothing to do."))
-
-    mapset = gscript.gisenv()['MAPSET']
-
-    vectors = gscript.list_grouped('vect')[mapset]
+	grass.fatal(_("Old and new database connection is identical. Nothing to do."))
+    
+    mapset = grass.gisenv()['MAPSET']
+        
+    vectors = grass.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:
         vect = "%s@%s" % (vect, mapset)
         i += 1
-        gscript.message(_("%s\nReconnecting vector map <%s> "
-                          "(%d of %d)...\n%s") %
-                        ('-' * 80, vect, i, num_vectors, '-' * 80))
-        for f in gscript.vector_db(vect, stderr=nuldev).itervalues():
+	grass.message(_("%s\nReconnecting vector map <%s> (%d of %d)...\n%s") % \
+                          ('-' * 80, vect, i, num_vectors, '-' * 80))
+        for f in grass.vector_db(vect, stderr = nuldev).itervalues():
             layer = f['layer']
             schema_table = f['table']
             key = f['key']
             database = f['database']
             driver = f['driver']
-
+            
             # split schema.table
             if '.' in schema_table:
                 schema, table = schema_table.split('.', 1)
             else:
                 schema = ''
                 table = schema_table
-
+            
             if new_schema:
                 new_schema_table = "%s.%s" % (new_schema, table)
             else:
                 new_schema_table = 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))
+            
+            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))
 
             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:
-                gscript.verbose(_("Reconnecting layer %d...") % layer)
-
+                grass.verbose(_("Reconnecting layer %d...") % layer)
+                                          
                 if flags['c']:
                     # check if table exists in new database
                     copy_tab(driver, database, schema_table,
                              new_driver, new_database, new_schema_table)
-
+                
                 # 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:
-                    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)
+                    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)
                 except CalledModuleError:
-                    gscript.warning(_("Unable to connect table <%s> to vector "
-                                      "<%s> on layer <%s>") %
-                                    (table, vect, str(layer)))
+                    grass.warning(_("Unable to connect table <%s> to vector <%s> on layer <%s>") %
+				  (table, vect, str(layer)))
 
             else:
-                if database != new_database_subst:
-                    gscript.warning(_("Layer <%d> will not be reconnected "
-                                      "because database or schema do not "
-                                      "match.") % layer)
-
+		if database != new_database_subst:
+		    grass.warning(_("Layer <%d> will not be reconnected because "
+				    "database or schema do not match.") % layer)
+	
     return 0
 
 if __name__ == "__main__":
-    options, flags = gscript.parser()
+    options, flags = grass.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,7 +43,6 @@ import sys
 import os
 import grass.script as grass
 
-
 def main():
     map = options['map']
     layer = options['layer']
@@ -51,7 +50,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)
@@ -70,14 +69,10 @@ 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
@@ -98,10 +93,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)
@@ -109,10 +104,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,49 +53,50 @@
 
 import sys
 import os
-import grass.script as gscript
+import grass.script as grass
 from grass.exceptions import CalledModuleError
 
-
 def main():
     global tmp
-    tmp = gscript.tempfile()
+    tmp = grass.tempfile()
 
     vector = options['map']
     layer = options['layer']
     column = options['column']
     where = options['where']
     perc = options['percentile']
+    extend = flags['e']
+    shellstyle = flags['g']
 
-    if not gscript.find_file(vector, element='vector')['file']:
-        gscript.fatal(_("Vector map <%s> not found") % vector)
+    if not grass.find_file(vector, element='vector')['file']:
+        grass.fatal(_("Vector map <%s> not found") % vector)
 
     try:
-        fi = gscript.vector_db(vector, stderr=nuldev)[int(layer)]
+        fi = grass.vector_db(vector, stderr = nuldev)[int(layer)]
     except KeyError:
-        gscript.fatal(_("No attribute table linked to layer <%s>") % layer)
-
+        grass.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:
-        gscript.run_command('db.univar', table=table, column=column,
-                            database=database, driver=driver,
-                            perc=perc, where=where, flags=passflags)
+        grass.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 = gscript.parser()
+    options, flags = grass.parser()
     nuldev = file(os.devnull, 'w')
     main()

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

@@ -54,7 +54,6 @@ import sys
 import os
 import grass.script as grass
 
-
 def main():
     vector = options['map']
     layer = options['layer']
@@ -62,19 +61,18 @@ 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']
@@ -115,7 +113,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,10 +43,7 @@ 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
@@ -56,45 +53,44 @@ 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 as e:
+        except CalledModuleError, 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,25 +206,21 @@ 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 gcore
+from grass.script import core as grass
 from grass.exceptions import CalledModuleError
 
 
@@ -54,115 +54,113 @@ def main():
 
     e00tmp = str(os.getpid())
 
-    # 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 avcimport
+    if not grass.find_program('avcimport'):
+	grass.fatal(_("'avcimport' 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 for e00conv
+    if not grass.find_program('e00conv'):
+	grass.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']:
-        gcore.fatal(_('Must specify one of "point", "line", or "area".'))
+    if type not in ['point','line','area']:
+	grass.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'):
-        gcore.message(_("Found that E00 file is split into pieces (.e01, ...)."
-                        " Merging..."))
-        merging = True
+	grass.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 = gcore.tempfile()
+    #make a temporary directory
+    tmpdir = grass.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+')
 
-    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"))
+    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"))
     else:
-        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:
+	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:
     name = name.replace('-', '_')
 
-    # let's import...
-    gcore.message(_("Importing %ss...") % type)
+    ## let's import...
+    grass.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:
-        gcore.run_command('v.in.ogr', flags='o', input=e00shortname,
+        grass.run_command('v.in.ogr', flags='o', input=e00shortname,
                           layer=layer[type], type=itype[type],
                           output=name)
     except CalledModuleError:
-        gcore.fatal(_("An error occurred while running v.in.ogr"))
+        grass.fatal(_("An error occurred while running v.in.ogr"))
 
-    gcore.message(_("Imported <%s> vector map <%s>.") % (type, name))
+    grass.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
-    gcore.message(_("Done."))
+	
+    #### end
+    grass.message(_("Done."))
 
     # write cmd history:
     gvect.vector_history(name)
 
 if __name__ == "__main__":
-    options, flags = gcore.parser()
+    options, flags = grass.parser()
     main()
+

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

@@ -37,12 +37,11 @@
 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':
@@ -56,8 +55,7 @@ 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)
@@ -89,54 +87,55 @@ 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)
@@ -144,3 +143,4 @@ def main():
 if __name__ == "__main__":
     options, flags = grass.parser()
     main()
+

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

@@ -41,11 +41,9 @@ 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
 
@@ -59,9 +57,11 @@ def main():
     else:
         do3D = ''
 
+
     tmp = grass.tempfile()
 
-    # set up input file
+
+    #### set up input file
     if options['input'] == '-':
         infile = None
         inf = sys.stdin
@@ -71,6 +71,7 @@ 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')
@@ -98,7 +99,8 @@ 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] == '#':
@@ -109,8 +111,9 @@ 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__":

scripts/v.in.mapgen/v.in.mapgen.py

@@ -34,7 +34,7 @@
 #%end
 #%flag
 #% key: z
-#% description: Create a 3D vector points map from 3 column Matlab data
+#% description: Create a 3D vector points map from 3 column Matlab data 
 #%end
 #%option G_OPT_F_INPUT
 #% description: Name of input file in Mapgen/Matlab format
@@ -59,7 +59,6 @@ def cleanup():
     try_remove(tmp)
     try_remove(tmp + '.dig')
 
-
 def main():
     global tmp
 
@@ -90,32 +89,32 @@ def main():
 
     tmp = grass.tempfile()
 
-    # create ascii vector file
+    #### create ascii vector file
     inf = file(infile)
     outf = file(tmp, 'w')
 
     grass.message(_("Importing data..."))
-    cat = 1
+    cat = 1   
     if matlab:
-        # HB:  OLD v.in.mapgen.sh Matlab import command follows.
-        # I have no idea what it's all about, so "new" matlab format will be
-        # a series of x y with "nan nan" breaking lines. (as NOAA provides)
-        # Old command:
+        ## HB:  OLD v.in.mapgen.sh Matlab import command follows.
+        ##    I have no idea what it's all about, so "new" matlab format will be
+        ##    a series of x y with "nan nan" breaking lines. (as NOAA provides)
+        ##  Old command:
         #  tac $infile | $AWK 'BEGIN { FS="," ; R=0 }
         #    $1~/\d*/   { printf("L %d\n", R) }
         #    $1~/   .*/ { printf(" %lf %lf\n", $2, $1) ; ++R }
         #    $1~/END/   { }' | tac > "$TMP"
 
-        # matlab format.
+        ## matlab format.
         points = []
-
+ 
         for line in inf:
             f = line.split()
             if f[0].lower() == 'nan':
                 if points != []:
                     outf.write("L %d 1\n" % len(points))
                     for point in points:
-                        outf.write(" %.15g %.15g %.15g\n" % tuple(map(float, point)))
+                        outf.write(" %.15g %.15g %.15g\n" % tuple(map(float,point)))
                     outf.write(" 1 %d\n" % cat)
                     cat += 1
                 points = []
@@ -123,7 +122,7 @@ def main():
                 if len(f) == 2:
                     f.append('0')
                 points.append(f)
-
+        
         if points != []:
             outf.write("L %d 1\n" % len(points))
             for point in points:
@@ -132,36 +131,36 @@ def main():
                 except ValueError:
                     grass.fatal(_("An error occurred on line '%s', exiting.") % line.strip())
             outf.write(" 1 %d\n" % cat)
-            cat += 1
+            cat += 1       
     else:
-        # mapgen format.
+        ## mapgen format.
         points = []
         for line in inf:
             if line[0] == '#':
                 if points != []:
                     outf.write("L %d 1\n" % len(points))
                     for point in points:
-                        outf.write(" %.15g %.15g\n" % tuple(map(float, point)))
+                        outf.write(" %.15g %.15g\n" % tuple(map(float,point)))
                     outf.write(" 1 %d\n" % cat)
                     cat += 1
                 points = []
             else:
                 points.append(line.rstrip('\r\n').split('\t'))
-
+        
         if points != []:
             outf.write("L %d 1\n" % len(points))
             for point in points:
-                outf.write(" %.15g %.15g\n" % tuple(map(float, point)))
+                outf.write(" %.15g %.15g\n" % tuple(map(float,point)))
             outf.write(" 1 %d\n" % cat)
             cat += 1
     outf.close()
     inf.close()
 
-    # create digit header
+    #### create digit header
     digfile = tmp + '.dig'
     outf = file(digfile, 'w')
-    t = string.Template(
-        """ORGANIZATION: GRASSroots organization
+    t = string.Template(\
+"""ORGANIZATION: GRASSroots organization
 DIGIT DATE:   $date
 DIGIT NAME:   $user@$host
 MAP NAME:     $name
@@ -176,12 +175,12 @@ VERTI:
     year = time.strftime("%Y")
     user = os.getenv('USERNAME') or os.getenv('LOGNAME')
     host = os.getenv('COMPUTERNAME') or os.uname()[1]
-
-    s = t.substitute(prog=prog, name=name, date=date, year=year,
-                     user=user, host=host)
+    
+    s = t.substitute(prog = prog, name = name, date = date, year = year,
+                     user = user, host = host)
     outf.write(s)
-
-    # process points list to ascii vector file (merge in vertices)
+    
+    #### process points list to ascii vector file (merge in vertices)
     inf = file(tmp)
     shutil.copyfileobj(inf, outf)
     inf.close()
@@ -189,13 +188,13 @@ VERTI:
     outf.close()
 
     if not name:
-        # if no name for vector file given, cat to stdout
+        #### if no name for vector file given, cat to stdout
         inf = file(digfile)
         shutil.copyfileobj(inf, sys.stdout)
         inf.close()
     else:
-        # import to binary vector file
-        grass.message(_("Importing with v.in.ascii..."))
+        #### import to binary vector file
+        grass.message(_("Importing with v.in.ascii...")) 
         try:
             grass.run_command('v.in.ascii', flags=do3D, input=digfile,
                               output=name, format='standard')
@@ -206,3 +205,4 @@ if __name__ == "__main__":
     options, flags = grass.parser()
     atexit.register(cleanup)
     main()
+

scripts/v.in.wfs/v.in.wfs.py

@@ -64,7 +64,7 @@
 #%end
 #%flag
 #% key: l
-# todo #% description: List available layers and exit
+#todo #% description: List available layers and exit
 #% description: Download server capabilities to 'wms_capabilities.xml' in the current directory and exit
 #% suppress_required: yes
 #%end
@@ -80,7 +80,6 @@ from grass.script.utils import try_remove
 from grass.script import core as grass
 import urllib
 
-
 def main():
     out = options['output']
     wfs_url = options['url']
@@ -105,7 +104,7 @@ def main():
             grass.fatal('Features begin with index "1"')
 
     if flags['r']:
-        bbox = grass.read_command("g.region", flags='w').split('=')[1]
+        bbox = grass.read_command("g.region", flags = 'w').split('=')[1]
         wfs_url += '&BBOX=' + bbox
 
     if flags['l']:
@@ -120,10 +119,10 @@ def main():
     inf = urllib.urlopen(wfs_url)
     outf = file(tmpxml, 'wb')
     while True:
-        s = inf.read()
-        if not s:
-            break
-        outf.write(s)
+	s = inf.read()
+	if not s:
+	    break
+	outf.write(s)
     inf.close()
     outf.close()
 
@@ -136,6 +135,7 @@ def main():
         try_remove(tmpxml)
         sys.exit(0)
 
+
     grass.message(_("Importing data..."))
     try:
         grass.run_command('v.in.ogr', flags='o', input=tmpxml, output=out)

scripts/v.krige/v.krige.py

@@ -15,7 +15,7 @@ License (>=v2). Read the file COPYING that comes with GRASS
 for details.
 """
 
-# g.parser information
+## g.parser information
 
 #%module
 #% description: Performs ordinary or block kriging for vector maps.
@@ -96,26 +96,27 @@ for details.
 #% description: If omitted, will be <input name>_kriging.var
 #% required : no
 #%end
-from __future__ import print_function
-import os
-import sys
 
-# i18N
-import gettext
+import os, sys
+from tempfile import gettempdir
+import time
+import thread
 
-if "GISBASE" not in os.environ:
-    print("You must be in GRASS GIS to run this program.")
+if not os.environ.has_key("GISBASE"):
+    print "You must be in GRASS GIS to run this program."
     sys.exit(1)
 
-gettext.install('grasswxpy', os.path.join(os.getenv("GISBASE"), 'locale'))
+### i18N
+import gettext
+gettext.install('grasswxpy', os.path.join(os.getenv("GISBASE"), 'locale'), unicode = True)
 
-# dependencies to be checked once, as they are quite time-consuming. cfr. grass.parser.
+### dependencies to be checked once, as they are quite time-consuming. cfr. grass.parser.
 # GRASS binding
 try:
     import grass.script as grass
 except ImportError:
     sys.exit(_("No GRASS-python library found"))
-
+    
 # move other checks in functions, as R?
 
 # globals
@@ -127,15 +128,12 @@ except ImportError:
 #~ robjects = None
 #~ rinterface = None
 
-# classes in alphabetical order. methods in logical order :)
-
-# <2.5 class definition, without () - please test
-
+#classes in alphabetical order. methods in logical order :)
 
+# <2.5 class definition, without () - please test 
 class Controller:
     """ Executes analysis. For the moment, only with gstat functions."""
     # moved here the global variables
-
     def __init__(self):
         #~ self.Command = None
         self.InputData = None
@@ -143,24 +141,24 @@ class Controller:
         #~ VariogramFunction = None
         #~ robjects = None
         #~ rinterface = None
-
+    
     def ImportMap(self, map, column):
         """ Imports GRASS map as SpatialPointsDataFrame and adds x/y columns to attribute table.
         Checks for NULL values in the provided column and exits if they are present."""
 
         #@NOTE: new way with R - as it doesn't alter original data
-        Rpointmap = robjects.r.readVECT(map, type='point')
+        Rpointmap = robjects.r.readVECT(map, type =  'point')
         # checks if x,y columns are present in dataframe. If they do are present, but with different names,
         # they'll be duplicated.
-        if "x" not in robjects.r.names(Rpointmap):
+        if "x" not in robjects.r.names(Rpointmap): 
             # extract coordinates with S4 method
             coordinatesPreDF = robjects.r['as.data.frame'](robjects.r.coordinates(Rpointmap))
-            coordinatesDF = robjects.r['data.frame'](x=coordinatesPreDF.rx('coords.x1')[0],
-                                                     y=coordinatesPreDF.rx('coords.x2')[0])
+            coordinatesDF = robjects.r['data.frame'](x = coordinatesPreDF.rx('coords.x1')[0],
+                                                     y = coordinatesPreDF.rx('coords.x2')[0])
             # match coordinates with data slot of SpatialPointsDataFrame - maptools function
             # match is done on row.names
             Rpointmap = robjects.r.spCbind(Rpointmap, coordinatesDF)
-
+            
         # GRASS checks for null values in the chosen column. R can hardly handle column as a variable,
         # looks for a hardcoded string.
         cols = grass.vector_columns(map=map, layer=1)
@@ -168,101 +166,95 @@ class Controller:
                                         map=map,
                                         column=column,
                                         type='point',
-                                        parse=(grass.parse_key_val,
-                                               {'sep': ': '}
-                                               )
+                                        parse = (grass.parse_key_val,
+                                                 {'sep':': '}
+                                                 )
                                         )['number of NULL attributes'])
-        if nulls > 0:
-            grass.fatal(
-                _("%d NULL value(s) in the selected column - unable to perform kriging.") %
-                nulls)
+        if nulls > 0: 
+            grass.fatal(_("%d NULL value(s) in the selected column - unable to perform kriging.") % nulls)
         return Rpointmap
-
+    
     def CreateGrid(self, inputdata):
         Region = grass.region()
         Grid = robjects.r.gmeta2grd()
 
         # addition of coordinates columns into dataframe.
         coordinatesDF = robjects.r['as.data.frame'](robjects.r.coordinates(Grid))
-        data = robjects.r['data.frame'](x=coordinatesDF.rx('s1')[0],
-                                        y=coordinatesDF.rx('s2')[0],
-                                        k=robjects.r.rep(1, Region['cols'] * Region['rows']))
-        GridPredicted = robjects.r.SpatialGridDataFrame(
-            Grid, data, proj4string=robjects.r.CRS(
-                robjects.r.proj4string(inputdata)))
+        data = robjects.r['data.frame'](x = coordinatesDF.rx('s1')[0],
+                                        y = coordinatesDF.rx('s2')[0],
+                                        k = robjects.r.rep(1, Region['cols']*Region['rows']))
+        GridPredicted = robjects.r.SpatialGridDataFrame(Grid,
+                                                        data,
+                                                        proj4string =  robjects.r.CRS(robjects.r.proj4string(inputdata)))
         return GridPredicted
-
+    
     def ComposeFormula(self, column, isblock):
         if isblock is True:
             predictor = 'x+y'
         else:
             predictor = '1'
-        print(column + "~" + predictor)
+        print column + "~" + predictor
         Formula = robjects.Formula(column + "~" + predictor)
         return Formula
-
-    def FitVariogram(self, formula, inputdata, sill, nugget, range, kappa, model=''):
+    
+    def FitVariogram(self, formula, inputdata, sill, nugget, range, kappa, model = ''):
         """ Fits variogram either automagically either specifying all parameters.
         Returns a list containing data and model variograms. """
-
+        
         Variograms = {}
-
+        
         if model is '':
             robjects.r.require('automap')
             DottedParams = {}
             #print (nugget.r_repr(), sill, range)
             DottedParams['fix.values'] = robjects.r.c(nugget, range, sill)
-
-            if not isinstance(kappa, float):
+            
+            if not type(kappa) == float:
                 # autofit gives strange results if kappa is NA
                 VariogramModel = robjects.r.autofitVariogram(formula, inputdata, **DottedParams)
             else:
-                VariogramModel = robjects.r.autofitVariogram(
-                    formula, inputdata, kappa=kappa, **DottedParams)
-            # print robjects.r.warnings()
+                VariogramModel = robjects.r.autofitVariogram(formula, inputdata, kappa=kappa, **DottedParams)
+            #print robjects.r.warnings()
             Variograms['datavariogram'] = VariogramModel.rx('exp_var')[0]
             Variograms['variogrammodel'] = VariogramModel.rx('var_model')[0]
-            # obtain the model name. *Too* complicated to get the string instead of
-            # level, unlike R does.
-            VariogramAsDF = robjects.r['as.data.frame'](
-                VariogramModel.rx('var_model')[0])  # force conversion
+            # obtain the model name. *Too* complicated to get the string instead of level, unlike R does.
+            VariogramAsDF = robjects.r['as.data.frame'](VariogramModel.rx('var_model')[0]) # force conversion
             ModelDF = VariogramAsDF.rx('model')[0]
             Variograms['model'] = ModelDF.levels[ModelDF[1] - 1]
         else:
             DataVariogram = robjects.r['variogram'](formula, inputdata)
             VariogramModel = robjects.r['fit.variogram'](DataVariogram,
-                                                         model=robjects.r.vgm(psill=sill,
-                                                                              model=model,
-                                                                              nugget=nugget,
-                                                                              range=range,
-                                                                              kappa=kappa))
+                                                         model = robjects.r.vgm(psill = sill,
+                                                                                model = model,
+                                                                                nugget = nugget,
+                                                                                range = range,
+                                                                                kappa = kappa))
             Variograms['datavariogram'] = DataVariogram
             Variograms['variogrammodel'] = VariogramModel
             Variograms['model'] = model
         return Variograms
-
+    
     def DoKriging(self, formula, inputdata, grid, model, block):
-        DottedParams = {'debug.level': -1}  # let krige() print percentage status
-        if block is not '':  # @FIXME(anne): but it's a string!! and krige accepts it!!
+        DottedParams = {'debug.level': -1} # let krige() print percentage status
+        if block is not '': #@FIXME(anne): but it's a string!! and krige accepts it!!
             DottedParams['block'] = block
-        # print DottedParams
+        #print DottedParams
         KrigingResult = robjects.r.krige(formula, inputdata, grid, model, **DottedParams)
         return KrigingResult
-
+ 
     def ExportMap(self, map, column, name, overwrite, command, variograms):
         # add kriging parameters to raster map history
-        robjects.r.writeRAST(map, vname=name, zcol=column, overwrite=overwrite)
+        robjects.r.writeRAST(map, vname = name, zcol = column, overwrite = overwrite)
         grass.run_command('r.support',
-                          map=name,
-                          title='Kriging output',
-                          history='Issued from command v.krige ' + command)
-        if command.find(
-                'model') is -1:  # if the command has no model option, add automap chosen model
-            grass.run_command('r.support',
-                              map=name,
-                              history='Model chosen by automatic fitting: ' + variograms['model'])
-
-    def Run(self, input, column, output, package, sill, nugget, range, kappa, logger,
+                          map = name,
+                          title = 'Kriging output',
+                          history = 'Issued from command v.krige ' + command)
+        if command.find('model') is -1: # if the command has no model option, add automap chosen model
+                    grass.run_command('r.support',
+                                      map = name,
+                                      history = 'Model chosen by automatic fitting: ' + variograms['model'])
+        
+    def Run(self, input, column, output, package, sill, nugget, range, kappa, logger, \
             overwrite, model, block, output_var, command, **kwargs):
         """ Wrapper for all functions above. """
 
@@ -275,9 +267,9 @@ class Controller:
         # and from here over, InputData refers to the global variable
         #print(robjects.r.slot(InputData, 'data').names)
         logger.message(_("Data successfully imported."))
-
+        
         GridPredicted = self.CreateGrid(self.InputData)
-
+        
         logger.message(_("Fitting variogram..."))
 
         if block is not '':
@@ -286,93 +278,87 @@ class Controller:
             self.predictor = '1'
         if self.Variogram is None:
             self.Variogram = self.FitVariogram(robjects.Formula(column + "~" + self.predictor),
-                                               self.InputData,
-                                               model=model,
-                                               sill=sill,
-                                               nugget=nugget,
-                                               range=range,
-                                               kappa=kappa)
+                                          self.InputData,
+                                          model = model,
+                                          sill = sill,
+                                          nugget = nugget,
+                                          range = range,
+                                          kappa = kappa)
         logger.message(_("Variogram fitting complete."))
-
+        
         logger.message(_("Kriging..."))
-        KrigingResult = self.DoKriging(
-            robjects.Formula(
-                column + "~" + self.predictor),
-            self.InputData,
-            GridPredicted,
-            self.Variogram['variogrammodel'],
-            block)  # using global ones
+        KrigingResult = self.DoKriging(robjects.Formula(column + "~" + self.predictor), self.InputData,
+                 GridPredicted, self.Variogram['variogrammodel'], block) # using global ones
         logger.message(_("Kriging complete."))
-
-        self.ExportMap(map=KrigingResult,
+        
+        self.ExportMap(map = KrigingResult,
                        column='var1.pred',
-                       name=output,
-                       overwrite=overwrite,
-                       command=command,
-                       variograms=self.Variogram)
+                       name = output,
+                       overwrite = overwrite,
+                       command = command,
+                       variograms = self.Variogram)
         if output_var is not '':
-            self.ExportMap(map=KrigingResult,
+            self.ExportMap(map = KrigingResult,
                            column='var1.var',
-                           name=output_var,
-                           overwrite=overwrite,
-                           command=command,
-                           variograms=self.Variogram)
-
-
-def main(argv=None):
+                           name = output_var,
+                           overwrite = overwrite,
+                           command = command,
+                           variograms = self.Variogram)
+        
+def main(argv = None):
     """ Main. Calls either GUI or CLI, depending on arguments provided. """
     #@FIXME: solve this double ifelse. the control should not be done twice.
-
+    
     controller = Controller()
-
+    
     if argv is None:
         importR()
-        argv = sys.argv[1:]  # stripping first item, the full name of this script
+        argv = sys.argv[1:] # stripping first item, the full name of this script
         # wxGUI call
         if not os.getenv("GRASS_WXBUNDLED"):
             from core import globalvar
             globalvar.CheckForWx()
         from modules import vkrige as GUI
-
+        
         import wx
-
+        
         app = wx.App()
-        KrigingFrame = GUI.KrigingModule(parent=None,
-                                         Rinstance=robjects,
-                                         controller=controller)
+        KrigingFrame = GUI.KrigingModule(parent = None,
+                                         Rinstance = robjects,
+                                         controller = controller)
         KrigingFrame.Centre()
         KrigingFrame.Show()
         app.MainLoop()
-
+        
     else:
-        # CLI
+        #CLI
         options, flags = argv
-
+        
         #@TODO: Work on verbosity. Sometimes it's too verbose (R), sometimes not enough.
-        if grass.find_file(options['input'], element='vector')['fullname'] is '':
-            grass.fatal(_("Vector map <%s> not found") % options['input'])
-
+        if grass.find_file(options['input'], element = 'vector')['fullname'] is '':
+            grass.fatal(_("Vector map <%s> not found") % options['input'] )
+        
         #@TODO: elaborate input string, if contains mapset or not.. thanks again to Bob for testing on 64bit.
-
+        
         # create output map name, if not specified
         if options['output'] is '':
-            try:  # to strip mapset name from fullname. Ugh.
+            try: # to strip mapset name from fullname. Ugh.
                 options['input'] = options['input'].split("@")[0]
             except:
                 pass
             options['output'] = options['input'] + '_kriging'
 
         # check for output map with same name. g.parser can't handle this, afaik.
-        if grass.find_file(options['output'], element='cell')['fullname'] \
-           and os.getenv("GRASS_OVERWRITE") is None:
+        if grass.find_file(options['output'], element = 'cell')['fullname'] \
+           and os.getenv("GRASS_OVERWRITE") == None:
             grass.fatal(_("option: <output>: Raster map already exists."))
 
         if options['output_var'] is not '' \
-           and (grass.find_file(options['output_var'], element='cell')['fullname']
-                and os.getenv("GRASS_OVERWRITE") is None):
+           and (grass.find_file(options['output_var'], element = 'cell')['fullname'] \
+           and os.getenv("GRASS_OVERWRITE") == None):
             grass.fatal(_("option: <output>: Variance raster map already exists."))
 
-        importR()
+        importR()        
         if options['model'] is '':
             try:
                 robjects.r.require("automap")
@@ -380,20 +366,19 @@ def main(argv=None):
                 grass.fatal(_("R package automap is missing, no variogram autofit available."))
         else:
             if options['sill'] is '' or options['nugget'] is '' or options['range'] is '':
-                grass.fatal(
-                    _("You have specified model, but forgot at least one of sill, nugget and range."))
-
+                grass.fatal(_("You have specified model, but forgot at least one of sill, nugget and range."))
+        
         #@TODO: let GRASS remount its commandstring. Until then, keep that 4 lines below.
-        # print grass.write_command(argv)
+        #print grass.write_command(argv)
         command = ""
         notnulloptions = {}
         for k, v in options.items():
             if v is not '':
                 notnulloptions[k] = v
         command = command.join("%s=%s " % (k, v) for k, v in notnulloptions.items())
-
+        
         # re-cast integers from strings, as parser() cast everything to string.
-        for each in ("sill", "nugget", "range", "kappa"):
+        for each in ("sill","nugget","range","kappa"):
             if options[each] is not '':
                 if each == "kappa":
                     options[each] = float(options[each])
@@ -401,24 +386,23 @@ def main(argv=None):
                     options[each] = int(options[each])
             else:
                 options[each] = robjects.r('''NA''')
-
+        
         #controller = Controller()
-        controller.Run(input=options['input'],
-                       column=options['column'],
-                       output=options['output'],
-                       overwrite=os.getenv("GRASS_OVERWRITE") == 1,
-                       package=options['package'],
-                       model=options['model'],
-                       block=options['block'],
-                       sill=options['sill'],
-                       nugget=options['nugget'],
-                       range=options['range'],
-                       kappa=options['kappa'],
-                       output_var=options['output_var'],
-                       command=command,
-                       logger=grass)
-
-
+        controller.Run(input = options['input'],
+                       column = options['column'],
+                       output = options['output'],
+                       overwrite = os.getenv("GRASS_OVERWRITE") == 1,
+                       package = options['package'],
+                       model = options['model'],
+                       block = options['block'],
+                       sill = options['sill'],
+                       nugget = options['nugget'],
+                       range = options['range'],
+                       kappa = options['kappa'],
+                       output_var = options['output_var'],
+                       command = command,
+                       logger = grass)
+    
 def importR():
     # R
     # unuseful since rpy2 will complain adequately.
@@ -427,31 +411,31 @@ def importR():
     #    grass.find_program('R')
     # except:
     #    sys.exit(_("R is not installed. Install it and re-run, or modify environment variables."))
-
+    
     # rpy2
     global robjects
     global rinterface
     grass.message(_('Loading dependencies, please wait...'))
     try:
         import rpy2.robjects as robjects
-        import rpy2.rinterface as rinterface  # to speed up kriging? for plots.
+        import rpy2.rinterface as rinterface #to speed up kriging? for plots.
     except ImportError:
         # ok for other OSes?
         grass.fatal(_("Python module 'Rpy2' not found. Please install it and re-run v.krige."))
-
+        
     # R packages check. Will create one error message after check of all packages.
     missingPackagesList = []
     for each in ["rgeos", "gstat", "rgrass7", "maptools"]:
-        if not robjects.r.require(each, quietly=True)[0]:
+        if not robjects.r.require(each, quietly = True)[0]:
             missingPackagesList.append(each)
     if missingPackagesList:
         errorString = _("R package(s) ") + \
-            ", ".join(map(str, missingPackagesList)) + \
-            _(" missing. Install it/them and re-run v.krige.")
+                      ", ".join(map(str, missingPackagesList)) + \
+                      _(" missing. Install it/them and re-run v.krige.")
         grass.fatal(errorString)
-
+    
 if __name__ == '__main__':
     if len(sys.argv) > 1:
-        sys.exit(main(argv=grass.parser()))
+        sys.exit(main(argv = grass.parser()))
     else:
         main()

scripts/v.pack/v.pack.py

@@ -43,38 +43,36 @@ from grass.script.utils import try_rmdir, try_remove
 from grass.script import core as grass
 from grass.script import vector as vector
 
-
 def cleanup():
     try_rmdir(basedir)
 
-
 def main():
     infile = options['input']
     compression_off = flags['c']
-
+    
     global basedir
     basedir = grass.tempdir()
-
+    
     # check if vector map exists
-    gfile = grass.find_file(infile, element='vector')
+    gfile = grass.find_file(infile, element = 'vector')
     if not gfile['name']:
         grass.fatal(_("Vector map <%s> not found") % infile)
-
+    
     # check if input vector map is in the native format
     if vector.vector_info(gfile['fullname'])['format'] != 'native':
-        grass.fatal(_("Unable to pack vector map <%s>. Only native format supported.") %
-                    gfile['fullname'])
-
+        grass.fatal(_("Unable to pack vector map <%s>. Only native format supported.") % \
+                        gfile['fullname'])
+    
     # split the name if there is the mapset name
     if infile.find('@'):
         infile = infile.split('@')[0]
-
+    
     # output name
     if options['output']:
         outfile = options['output']
     else:
         outfile = infile + '.pack'
-
+    
     # check if exists the output file
     if os.path.exists(outfile):
         if os.getenv('GRASS_OVERWRITE'):
@@ -82,18 +80,18 @@ def main():
             try_remove(outfile)
         else:
             grass.fatal(_("option <%s>: <%s> exists.") % ("output", outfile))
-
+    
     # prepare for packing
     grass.verbose(_("Packing <%s>...") % (gfile['fullname']))
-
-    # write tar file, optional compression
+    
+    # write tar file, optional compression 
     if compression_off:
-        tar = tarfile.open(name=outfile, mode='w:')
+        tar = tarfile.open(name = outfile, mode = 'w:')
     else:
-        tar = tarfile.open(name=outfile, mode='w:gz')
+        tar = tarfile.open(name = outfile, mode = 'w:gz')
     tar.add(gfile['file'], infile)
-
-    # check if exist a db connection for the vector
+    
+    # check if exist a db connection for the vector 
     db_vect = vector.vector_db(gfile['fullname'])
     if not db_vect:
         grass.verbose(_('There is not database connected with vector map <%s>') % gfile['fullname'])
@@ -101,14 +99,14 @@ def main():
         # for each layer connection save a table in sqlite database
         sqlitedb = os.path.join(basedir, 'db.sqlite')
         for i, dbconn in db_vect.iteritems():
-            grass.run_command('db.copy', from_driver=dbconn['driver'],
-                              from_database=dbconn['database'],
-                              from_table=dbconn['table'],
-                              to_driver='sqlite', to_database=sqlitedb,
-                              to_table=dbconn['table'])
+            grass.run_command('db.copy', from_driver = dbconn['driver'], 
+                              from_database = dbconn['database'],
+                              from_table =  dbconn['table'], 
+                              to_driver = 'sqlite', to_database = sqlitedb, 
+                              to_table = dbconn['table'])
         tar.add(sqlitedb, 'db.sqlite')
-
-    # add to the tar file the PROJ files to check when unpack file
+    
+    # add to the tar file the PROJ files to check when unpack file    
     gisenv = grass.gisenv()
     for support in ['INFO', 'UNITS', 'EPSG']:
         path = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'],
@@ -116,9 +114,9 @@ def main():
         if os.path.exists(path):
             tar.add(path, 'PROJ_' + support)
     tar.close()
-
+    
     grass.message(_("Pack file <%s> created") % os.path.join(os.getcwd(), outfile))
-
+            
 if __name__ == "__main__":
     options, flags = grass.parser()
     atexit.register(cleanup)

scripts/v.rast.stats/testsuite/test_v_rast_stats.py

@@ -5,7 +5,6 @@
 from grass.gunittest.case import TestCase
 from grass.gunittest.gmodules import SimpleModule
 
-
 class TestRastStats(TestCase):
 
     @classmethod
@@ -37,20 +36,19 @@ class TestRastStats(TestCase):
 
     def test_1(self):
         # Output of v.rast.stats
-        univar_string = """cat|value|label|a_minimum|a_maximum|a_sum
+        univar_string="""cat|value|label|a_minimum|a_maximum|a_sum
 1|1||102|209|265905
 2|2||121|280|1281195
 """
-
-        self.assertModule("v.rast.stats", map="zone_map", raster="map_a",
-                          method=["minimum", "maximum", "sum"], flags="c",
+        
+        self.assertModule("v.rast.stats",  map="zone_map", raster="map_a",
+                          method=["minimum","maximum","sum"], flags="c",
                           column_prefix="a")
         v_db_select = SimpleModule("v.db.select", map="zone_map")
-
-        self.runModule(v_db_select)
+        
+        self.runModule(v_db_select)        
         self.assertLooksLike(univar_string, v_db_select.outputs.stdout)
 
-
 class TestRastStatsFails(TestCase):
 
     def test_error_handling_a(self):
@@ -62,7 +60,7 @@ class TestRastStatsFails(TestCase):
         # No raster map
         self.assertModuleFail("v.rast.stats", map="zone_map",
                               column_prefix="a")
-
+        
     def test_error_handling_d(self):
         # No column_prefix
         self.assertModuleFail("v.rast.stats", map="zone_map", raster="map_b")
@@ -70,3 +68,5 @@ class TestRastStatsFails(TestCase):
 if __name__ == '__main__':
     from grass.gunittest.main import test
     test()
+
+

scripts/v.rast.stats/v.rast.stats.py

@@ -79,7 +79,7 @@ def cleanup():
 def main():
     global tmp, sqltmp, tmpname, nuldev, vector, rastertmp
     rastertmp = False
-    # setup temporary files
+    #### setup temporary files
     tmp = grass.tempfile()
     sqltmp = tmp + ".sql"
     # we need a random name
@@ -146,15 +146,13 @@ def main():
     try:
         fi = grass.vector_db(map=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.'))
     # we need this for non-DBF driver:
     dbfdriver = fi['driver'] == 'dbf'
 
     # Find out which table is linked to the vector map on the given layer
     if not fi['table']:
-        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.'))
 
     # replaced by user choiche
     #basecols = ['n', 'min', 'max', 'range', 'mean', 'stddev', 'variance', 'cf_var', 'sum']
@@ -208,7 +206,7 @@ def main():
         if currcolumn in grass.vector_columns(vector, layer).keys():
             if not flags['c']:
                 grass.fatal((_("Cannot create column <%s> (already present). ") % currcolumn) +
-                            _("Use -c flag to update values in this column."))
+                             _("Use -c flag to update values in this column."))
         else:
             if i == "n":
                 coltype = "INTEGER"
@@ -279,9 +277,7 @@ def main():
                          " of vector map <{vector}>."
                          ).format(raster=raster, vector=vector)))
     except CalledModuleError:
-        grass.warning(
-            _("Failed to upload statistics to attribute table of vector map <%s>.") %
-            vector)
+        grass.warning(_("Failed to upload statistics to attribute table of vector map <%s>.") % vector)
         exitcode = 1
 
     sys.exit(exitcode)

scripts/v.report/v.report.py

@@ -47,7 +47,6 @@ import sys
 import os
 import grass.script as grass
 
-
 def uniq(l):
     result = []
     last = None
@@ -57,7 +56,6 @@ def uniq(l):
             last = i
     return result
 
-
 def main():
     mapname = options['map']
     option = options['option']
@@ -77,13 +75,13 @@ def main():
         colnames = ['cat']
 
     if option == 'coor':
-        columns = ['dummy1', 'dummy2', 'dummy3']
-        extracolnames = ['x', 'y', 'z']
+        columns = ['dummy1','dummy2','dummy3']
+        extracolnames = ['x','y','z']
     else:
         columns = ['dummy1']
         extracolnames = [option]
 
-    if units in ['p', 'percent']:
+    if units in ['p','percent']:
         unitsp = 'meters'
     elif units:
         unitsp = units
@@ -92,7 +90,7 @@ def main():
 
     # NOTE: we suppress -1 cat and 0 cat
     if isConnection:
-        p = grass.pipe_command('v.db.select', quiet=True, flags='c', map=mapname, layer=layer)
+        p = grass.pipe_command('v.db.select', quiet = True, flags='c', map = mapname, layer = layer)
         records1 = []
         for line in p.stdout:
             cols = line.rstrip('\r\n').split('|')
@@ -102,23 +100,23 @@ def main():
         p.wait()
         if p.returncode != 0:
             sys.exit(1)
-
+        
         records1.sort()
 
         if len(records1) == 0:
             try:
-                f = grass.vector_db(map=mapname)[int(layer)]
+                f = grass.vector_db(map = mapname)[int(layer)]
                 grass.fatal(_("There is a table connected to input vector map '%s', but"
                               "there are no categories present in the key column '%s'. Consider using"
                               "v.to.db to correct this.") % (mapname, f['key']))
             except KeyError:
                 pass
 
-        # fetch the requested attribute sorted by cat:
-        p = grass.pipe_command('v.to.db', flags='p',
-                               quiet=True,
-                               map=mapname, option=option, columns=columns,
-                               layer=layer, units=unitsp)
+        #fetch the requested attribute sorted by cat:
+        p = grass.pipe_command('v.to.db', flags = 'p',
+                               quiet = True,
+                               map = mapname, option = option, columns = columns,
+                               layer = layer, units = unitsp)
         records2 = []
         for line in p.stdout:
             fields = line.rstrip('\r\n').split('|')
@@ -128,7 +126,7 @@ def main():
         p.wait()
         records2.sort()
 
-        # make pre-table
+        #make pre-table
         # len(records1) may not be the same as len(records2) because
         # v.db.select can return attributes that are not linked to features.
         records3 = []
@@ -136,7 +134,7 @@ def main():
             records3.append(filter(lambda r1: r1[0] == r2[0], records1)[0] + r2[1:])
     else:
         records1 = []
-        p = grass.pipe_command('v.category', inp=mapname, layer=layer, option='print')
+        p = grass.pipe_command('v.category', inp = mapname, layer = layer, option = 'print')
         for line in p.stdout:
             field = int(line.rstrip())
             if field > 0:
@@ -145,10 +143,10 @@ def main():
         records1.sort()
         records1 = uniq(records1)
 
-        # make pre-table
-        p = grass.pipe_command('v.to.db', flags='p',
-                               map=mapname, option=option, columns=columns,
-                               layer=layer, units=unitsp)
+        #make pre-table
+        p = grass.pipe_command('v.to.db', flags = 'p',
+                               map = mapname, option = option, columns = columns,
+                               layer = layer, units = unitsp)
         records3 = []
         for line in p.stdout:
             fields = line.split('|')
@@ -161,11 +159,11 @@ def main():
     # print table header
     sys.stdout.write('|'.join(colnames + extracolnames) + '\n')
 
-    # make and print the table:
+    #make and print the table:
     numcols = len(colnames) + len(extracolnames)
 
     # calculate percents if requested
-    if units != '' and units in ['p', 'percent']:
+    if units != '' and units in ['p','percent']:
         # calculate total area value
         areatot = 0
         for r in records3:
@@ -178,12 +176,12 @@ def main():
     # sort results
     if options['sort']:
         if options['sort'] == 'asc':
-            records3.sort(key=lambda r: r[-1])
+            records3.sort(key = lambda r: r[-1])
         else:
-            records3.sort(key=lambda r: r[-1], reverse=True)
-
+            records3.sort(key = lambda r: r[-1], reverse = True)
+    
     for r in records3:
-        sys.stdout.write('|'.join(map(str, r)) + '\n')
+        sys.stdout.write('|'.join(map(str,r)) + '\n')
 
 if __name__ == "__main__":
     options, flags = grass.parser()

scripts/v.unpack/v.unpack.py

@@ -116,8 +116,7 @@ def main():
     skip_projection_check = False
     if not os.path.exists(os.path.join(tmp_dir, 'PROJ_INFO')):
         if os.path.exists(loc_proj):
-            grass.fatal(
-                _("PROJ_INFO file is missing, unpack vector map in XY (unprojected) location."))
+            grass.fatal(_("PROJ_INFO file is missing, unpack vector map in XY (unprojected) location."))
         skip_projection_check = True  # XY location
 
     if not skip_projection_check:
@@ -125,14 +124,14 @@ def main():
         if not grass.compare_key_value_text_files(filename_a=os.path.join(tmp_dir, 'PROJ_INFO'),
                                                   filename_b=loc_proj, proj=True):
             diff_result_1 = diff_files(os.path.join(tmp_dir, 'PROJ_INFO'),
-                                       loc_proj)
-
+                                             loc_proj)
+    
         if not grass.compare_key_value_text_files(filename_a=os.path.join(tmp_dir, 'PROJ_UNITS'),
                                                   filename_b=loc_proj_units,
                                                   units=True):
             diff_result_2 = diff_files(os.path.join(tmp_dir, 'PROJ_UNITS'),
-                                       loc_proj_units)
-
+                                             loc_proj_units)
+    
         if diff_result_1 or diff_result_2:
             if flags['o']:
                 grass.warning(_("Projection information does not match. Proceeding..."))
@@ -168,7 +167,7 @@ def main():
         # check if dbf or sqlite directory exists
         if dbconn['driver'] == 'dbf' and not os.path.exists(os.path.join(mset_dir, 'dbf')):
             os.mkdir(os.path.join(mset_dir, 'dbf'))
-        elif dbconn['driver'] == 'sqlite' and not os.path.exists(os.path.join(mset_dir, 'sqlite')):
+	elif dbconn['driver'] == 'sqlite' and not os.path.exists(os.path.join(mset_dir, 'sqlite')):
             os.mkdir(os.path.join(mset_dir, 'sqlite'))
         # for each old connection
         for t in dbnlist:

scripts/v.what.strds/testsuite/test_what_strds.py

@@ -21,12 +21,12 @@ class TestWhatStrds(TestCase):
         """Initiate the temporal GIS and set the region
         """
         cls.use_temp_region()
-        cls.runModule("g.region", s=0, n=80, w=0, e=120, b=0, t=50,
-                      res=10, res3=10)
-        cls.runModule("r.mapcalc", expression="a_1 = 100", overwrite=True)
-        cls.runModule("r.mapcalc", expression="a_2 = 200", overwrite=True)
-        cls.runModule("r.mapcalc", expression="a_3 = 300", overwrite=True)
-        cls.runModule("r.mapcalc", expression="a_4 = 400", overwrite=True)
+        cls.runModule("g.region",  s=0,  n=80,  w=0,  e=120,  b=0,  t=50,
+                      res=10,  res3=10)
+        cls.runModule("r.mapcalc", expression="a_1 = 100",  overwrite=True)
+        cls.runModule("r.mapcalc", expression="a_2 = 200",  overwrite=True)
+        cls.runModule("r.mapcalc", expression="a_3 = 300",  overwrite=True)
+        cls.runModule("r.mapcalc", expression="a_4 = 400",  overwrite=True)
 
         cls.runModule("v.random", output="points", npoints=3, seed=1,
                       overwrite=True)

scripts/v.what.strds/v.what.strds.py

@@ -60,7 +60,6 @@ from grass.exceptions import CalledModuleError
 
 
 class Sample(object):
-
     def __init__(self, start=None, end=None, raster_names=None,
                  strds_name=None):
         self.start = start
@@ -152,9 +151,9 @@ def main():
                               "datasets must be equal\n<%(a)s> of type "
                               "%(type_a)s do not match <%(b)s> of type "
                               "%(type_b)s" % {"a": first_strds.get_id(),
-                                              "type_a": first_strds.get_temporal_type(),
-                                              "b": dataset.get_id(),
-                                              "type_b": dataset.get_temporal_type()}))
+                               "type_a": first_strds.get_temporal_type(),
+                               "b": dataset.get_id(),
+                               "type_b": dataset.get_temporal_type()}))
 
         mapmatrizes = tgis.sample_stds_by_stds_topology("strds", "strds",
                                                         strds_names,

scripts/wxpyimgview/wxpyimgview.py

@@ -16,7 +16,7 @@
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
 #
-# /
+#############################################################################/
 
 #%module
 #% description: Views BMP images from the PNG driver.
@@ -43,7 +43,7 @@ import grass.script as grass
 
 if __name__ == "__main__":
     options, flags = grass.parser()
-    image = options['image']
+    image   = options['image']
     percent = options['percent']
     python = os.getenv('GRASS_PYTHON', 'python')
     gisbase = os.environ['GISBASE']

scripts/wxpyimgview/wxpyimgview_gui.py

@@ -16,7 +16,7 @@
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
 #
-# /
+#############################################################################/
 
 #%module
 #% description: Views BMP images from the PNG driver.
@@ -46,127 +46,124 @@ import wxversion
 wxversion.select('2.8')
 import wx
 
-
 class Frame(wx.Frame):
     title = "Image Viewer"
 
     def __init__(self, app, size):
-        self.app = app
-        wx.Frame.__init__(self, None, title=Frame.title, size=size)
-        self.Create()
+	self.app = app
+	wx.Frame.__init__(self, None, title = Frame.title, size = size)
+	self.Create()
 
     def Create(self):
-        self.Bind(wx.EVT_ERASE_BACKGROUND, self.erase)
-        self.Bind(wx.EVT_PAINT, self.redraw)
+	self.Bind(wx.EVT_ERASE_BACKGROUND, self.erase)
+	self.Bind(wx.EVT_PAINT, self.redraw)
 
-        self.Bind(wx.EVT_TIMER, self.tick, id=1)
-        self.timer = wx.Timer(self, 1)
-        self.timer.Start(100, True)
+	self.Bind(wx.EVT_TIMER, self.tick, id = 1)
+	self.timer = wx.Timer(self, 1)
+	self.timer.Start(100, True)
 
-        # Python doesn't receive signals while wx is waiting for an event
-        self.Bind(wx.EVT_TIMER, self.dummy, id=2)
-        self.ticker = wx.Timer(self, 2)
-        self.ticker.Start(100, False)
+	# Python doesn't receive signals while wx is waiting for an event
+	self.Bind(wx.EVT_TIMER, self.dummy, id = 2)
+	self.ticker = wx.Timer(self, 2)
+	self.ticker.Start(100, False)
 
     def erase(self, ev):
-        ev.GetDC()
+	ev.GetDC();
 
     def draw(self):
-        app = self.app
-        size = self.GetSize()
-        x0 = (size.GetWidth() - app.i_width) / 2
-        y0 = (size.GetHeight() - app.i_height) / 2
-        dc = wx.PaintDC(self)
-        data = app.imgbuf.reshape((app.i_height, app.i_width, 4))
-        data = data[::, ::, 2::-1]
-        fn = getattr(data, "tobytes", getattr(data, "tostring"))
-        image = wx.ImageFromData(app.i_width, app.i_height, fn())
-        dc.DrawBitmap(wx.BitmapFromImage(image), x0, y0, False)
+	app = self.app
+	size = self.GetSize()
+	x0 = (size.GetWidth()  - app.i_width) / 2
+	y0 = (size.GetHeight() - app.i_height) / 2
+	dc = wx.PaintDC(self)
+	data = app.imgbuf.reshape((app.i_height, app.i_width, 4))
+	data = data[::,::,2::-1]
+	fn = getattr(data, "tobytes", getattr(data, "tostring"))
+	image = wx.ImageFromData(app.i_width, app.i_height, fn())
+	dc.DrawBitmap(wx.BitmapFromImage(image), x0, y0, False)
 
     def redraw(self, ev):
-        if self.app.fraction > 0.001:
-            t0 = time.time()
-            self.draw()
-            t1 = time.time()
+	if self.app.fraction > 0.001:
+	    t0 = time.time()
+	    self.draw()
+	    t1 = time.time()
 
-            last = t1 - t0
-            delay = last / self.app.fraction
-            self.timer.Start(int(delay * 1000), True)
-        else:
-            self.draw()
+	    last = t1 - t0
+	    delay = last / self.app.fraction
+	    self.timer.Start(int(delay * 1000), True)
+	else:
+	    self.draw()
 
     def tick(self, ev):
-        self.Refresh()
+	self.Refresh()
 
     def dummy(self, ev):
-        pass
-
+	pass
 
 class Application(wx.App):
-
     def __init__(self):
-        self.image = sys.argv[1]
-        self.fraction = int(sys.argv[2]) / 100.0
-        self.HEADER_SIZE = 64
-        wx.App.__init__(self)
+	self.image = sys.argv[1]
+	self.fraction = int(sys.argv[2]) / 100.0
+	self.HEADER_SIZE = 64
+	wx.App.__init__(self)
 
     def read_bmp_header(self, header):
-        magic, bmfh, bmih = struct.unpack("2s12s40s10x", header)
+	magic, bmfh, bmih = struct.unpack("2s12s40s10x", header)
 
-        if magic != 'BM':
-            raise SyntaxError("Invalid magic number")
+	if magic != 'BM':
+	    raise SyntaxError("Invalid magic number")
 
-        size, res1, res2, hsize = struct.unpack("<IHHI", bmfh)
+	size, res1, res2, hsize = struct.unpack("<IHHI", bmfh)
 
-        if hsize != self.HEADER_SIZE:
-            raise SyntaxError("Invalid file header size")
+	if hsize != self.HEADER_SIZE:
+	    raise SyntaxError("Invalid file header size")
 
-        hsize, width, height, planes, bpp, compression, imsize, xppm, yppm, cused, cimp = \
-            struct.unpack("<IiiHHIIiiII", bmih)
+	hsize, width, height, planes, bpp, compression, imsize, xppm, yppm, cused, cimp = \
+	       struct.unpack("<IiiHHIIiiII", bmih)
 
-        if hsize != 40:
-            raise SyntaxError("Invalid info header size")
+	if hsize != 40:
+	    raise SyntaxError("Invalid info header size")
 
-        self.i_width = width
-        self.i_height = -height
+	self.i_width = width
+	self.i_height = -height
 
-        if planes != 1:
-            raise SyntaxError("Planar data not supported")
-        if bpp != 32:
-            raise SyntaxError("Only 32-BPP images supported")
-        if compression != 0:
-            raise SyntaxError("Compression not supported")
-        if imsize != self.i_width * self.i_height * 4:
-            raise SyntaxError("Invalid image data size")
-        if size != self.HEADER_SIZE + self.i_width * self.i_height * 4:
-            raise SyntaxError("Invalid image size")
+	if planes != 1:
+	    raise SyntaxError("Planar data not supported")
+	if bpp != 32:
+	    raise SyntaxError("Only 32-BPP images supported")
+	if compression != 0:
+	    raise SyntaxError("Compression not supported")
+	if imsize != self.i_width * self.i_height * 4:
+	    raise SyntaxError("Invalid image data size")
+	if size != self.HEADER_SIZE + self.i_width * self.i_height * 4:
+	    raise SyntaxError("Invalid image size")
 
     def map_file(self):
-        f = open(self.image, 'r')
+	f = open(self.image, 'r')
 
-        header = f.read(self.HEADER_SIZE)
-        self.read_bmp_header(header)
+	header = f.read(self.HEADER_SIZE)
+	self.read_bmp_header(header)
 
-        self.imgbuf = numpy.memmap(f, mode='r', offset=self.HEADER_SIZE)
+	self.imgbuf = numpy.memmap(f, mode = 'r', offset = self.HEADER_SIZE)
 
     def signal_handler(self, sig, frame):
-        wx.CallAfter(self.mainwin.Refresh)
+	wx.CallAfter(self.mainwin.Refresh);
 
     def set_handler(self):
-        if 'SIGUSR1' in dir(signal):
-            signal.signal(signal.SIGUSR1, self.signal_handler)
+	if 'SIGUSR1' in dir(signal):
+	    signal.signal(signal.SIGUSR1, self.signal_handler)
 
     def OnInit(self):
-        self.map_file()
+	self.map_file()
 
-        size = wx.Size(self.i_width, self.i_height)
-        self.mainwin = Frame(self, size)
-        self.mainwin.Show()
-        self.SetTopWindow(self.mainwin)
+	size = wx.Size(self.i_width, self.i_height)
+	self.mainwin = Frame(self, size)
+	self.mainwin.Show()
+	self.SetTopWindow(self.mainwin)
 
-        self.set_handler()
+	self.set_handler()
 
-        return True
+	return True
 
 if __name__ == "__main__":
     app = Application()