Whitespace normalization.

Lib/reconvert.py

@@ -61,7 +61,7 @@ XXX To be done...
 
 
 import regex
-from regex_syntax import * # RE_* 
+from regex_syntax import * # RE_*
 
 # Default translation table
 mastertable = {

Lib/regex_syntax.py

@@ -33,9 +33,9 @@ RE_NEWLINE_OR = 16
 #   their special meaning regardless of the surrounding context.
 # 1 means that special characters may act as normal characters in some
 #   contexts.  Specifically, this applies to:
-#	^ - only special at the beginning, or after ( or |
-#	$ - only special at the end, or before ) or |
-#	*, +, ? - only special when not after the beginning, (, or |
+#       ^ - only special at the beginning, or after ( or |
+#       $ - only special at the end, or before ) or |
+#       *, +, ? - only special when not after the beginning, (, or |
 RE_CONTEXT_INDEP_OPS = 32
 
 # ANSI sequences (\n etc) and \xhh

Lib/regsub.py

@@ -12,7 +12,7 @@ splitx(str, pat, maxsplit): split string using pattern as delimiter plus
 
 import warnings
 warnings.warn("the regsub module is deprecated; please use re.sub()",
-	      DeprecationWarning)
+              DeprecationWarning)
 
 # Ignore further deprecation warnings about this module
 warnings.filterwarnings("ignore", "", DeprecationWarning, __name__)
@@ -27,12 +27,12 @@ import regex
 # compiled pattern.
 
 def sub(pat, repl, str):
-	prog = compile(pat)
-	if prog.search(str) >= 0:
-		regs = prog.regs
-		a, b = regs[0]
-		str = str[:a] + expand(repl, regs, str) + str[b:]
-	return str
+    prog = compile(pat)
+    if prog.search(str) >= 0:
+        regs = prog.regs
+        a, b = regs[0]
+        str = str[:a] + expand(repl, regs, str) + str[b:]
+    return str
 
 
 # Replace all (non-overlapping) occurrences of pattern pat in string
@@ -41,23 +41,23 @@ def sub(pat, repl, str):
 # a previous match, so e.g. gsub('', '-', 'abc') returns '-a-b-c-'.
 
 def gsub(pat, repl, str):
-	prog = compile(pat)
-	new = ''
-	start = 0
-	first = 1
-	while prog.search(str, start) >= 0:
-		regs = prog.regs
-		a, b = regs[0]
-		if a == b == start and not first:
-			if start >= len(str) or prog.search(str, start+1) < 0:
-				break
-			regs = prog.regs
-			a, b = regs[0]
-		new = new + str[start:a] + expand(repl, regs, str)
-		start = b
-		first = 0
-	new = new + str[start:]
-	return new
+    prog = compile(pat)
+    new = ''
+    start = 0
+    first = 1
+    while prog.search(str, start) >= 0:
+        regs = prog.regs
+        a, b = regs[0]
+        if a == b == start and not first:
+            if start >= len(str) or prog.search(str, start+1) < 0:
+                break
+            regs = prog.regs
+            a, b = regs[0]
+        new = new + str[start:a] + expand(repl, regs, str)
+        start = b
+        first = 0
+    new = new + str[start:]
+    return new
 
 
 # Split string str in fields separated by delimiters matching pattern
@@ -66,7 +66,7 @@ def gsub(pat, repl, str):
 # The optional 3rd argument sets the number of splits that are performed.
 
 def split(str, pat, maxsplit = 0):
-	return intsplit(str, pat, maxsplit, 0)
+    return intsplit(str, pat, maxsplit, 0)
 
 # Split string str in fields separated by delimiters matching pattern
 # pat.  Only non-empty matches for the pattern are considered, so e.g.
@@ -76,42 +76,42 @@ def split(str, pat, maxsplit = 0):
 
 
 def splitx(str, pat, maxsplit = 0):
-	return intsplit(str, pat, maxsplit, 1)
-	
+    return intsplit(str, pat, maxsplit, 1)
+
 # Internal function used to implement split() and splitx().
 
 def intsplit(str, pat, maxsplit, retain):
-	prog = compile(pat)
-	res = []
-	start = next = 0
-	splitcount = 0
-	while prog.search(str, next) >= 0:
-		regs = prog.regs
-		a, b = regs[0]
-		if a == b:
-			next = next + 1
-			if next >= len(str):
-				break
-		else:
-			res.append(str[start:a])
-			if retain:
-				res.append(str[a:b])
-			start = next = b
-			splitcount = splitcount + 1
-			if (maxsplit and (splitcount >= maxsplit)):
-			    break
-	res.append(str[start:])
-	return res
+    prog = compile(pat)
+    res = []
+    start = next = 0
+    splitcount = 0
+    while prog.search(str, next) >= 0:
+        regs = prog.regs
+        a, b = regs[0]
+        if a == b:
+            next = next + 1
+            if next >= len(str):
+                break
+        else:
+            res.append(str[start:a])
+            if retain:
+                res.append(str[a:b])
+            start = next = b
+            splitcount = splitcount + 1
+            if (maxsplit and (splitcount >= maxsplit)):
+                break
+    res.append(str[start:])
+    return res
 
 
 # Capitalize words split using a pattern
 
 def capwords(str, pat='[^a-zA-Z0-9_]+'):
-	import string
-	words = splitx(str, pat)
-	for i in range(0, len(words), 2):
-		words[i] = string.capitalize(words[i])
-	return string.joinfields(words, "")
+    import string
+    words = splitx(str, pat)
+    for i in range(0, len(words), 2):
+        words[i] = string.capitalize(words[i])
+    return string.joinfields(words, "")
 
 
 # Internal subroutines:
@@ -131,19 +131,19 @@ def capwords(str, pat='[^a-zA-Z0-9_]+'):
 cache = {}
 
 def compile(pat):
-	if type(pat) != type(''):
-		return pat		# Assume it is a compiled regex
-	key = (pat, regex.get_syntax())
-	if cache.has_key(key):
-		prog = cache[key]	# Get it from the cache
-	else:
-		prog = cache[key] = regex.compile(pat)
-	return prog
+    if type(pat) != type(''):
+        return pat              # Assume it is a compiled regex
+    key = (pat, regex.get_syntax())
+    if cache.has_key(key):
+        prog = cache[key]       # Get it from the cache
+    else:
+        prog = cache[key] = regex.compile(pat)
+    return prog
 
 
 def clear_cache():
-	global cache
-	cache = {}
+    global cache
+    cache = {}
 
 
 # Expand \digit in the replacement.
@@ -153,46 +153,46 @@ def clear_cache():
 # the \ and the following character are both copied).
 
 def expand(repl, regs, str):
-	if '\\' not in repl:
-		return repl
-	new = ''
-	i = 0
-	ord0 = ord('0')
-	while i < len(repl):
-		c = repl[i]; i = i+1
-		if c != '\\' or i >= len(repl):
-			new = new + c
-		else:
-			c = repl[i]; i = i+1
-			if '0' <= c <= '9':
-				a, b = regs[ord(c)-ord0]
-				new = new + str[a:b]
-			elif c == '\\':
-				new = new + c
-			else:
-				new = new + '\\' + c
-	return new
+    if '\\' not in repl:
+        return repl
+    new = ''
+    i = 0
+    ord0 = ord('0')
+    while i < len(repl):
+        c = repl[i]; i = i+1
+        if c != '\\' or i >= len(repl):
+            new = new + c
+        else:
+            c = repl[i]; i = i+1
+            if '0' <= c <= '9':
+                a, b = regs[ord(c)-ord0]
+                new = new + str[a:b]
+            elif c == '\\':
+                new = new + c
+            else:
+                new = new + '\\' + c
+    return new
 
 
 # Test program, reads sequences "pat repl str" from stdin.
 # Optional argument specifies pattern used to split lines.
 
 def test():
-	import sys
-	if sys.argv[1:]:
-		delpat = sys.argv[1]
-	else:
-		delpat = '[ \t\n]+'
-	while 1:
-		if sys.stdin.isatty(): sys.stderr.write('--> ')
-		line = sys.stdin.readline()
-		if not line: break
-		if line[-1] == '\n': line = line[:-1]
-		fields = split(line, delpat)
-		if len(fields) != 3:
-			print 'Sorry, not three fields'
-			print 'split:', `fields`
-			continue
-		[pat, repl, str] = split(line, delpat)
-		print 'sub :', `sub(pat, repl, str)`
-		print 'gsub:', `gsub(pat, repl, str)`
+    import sys
+    if sys.argv[1:]:
+        delpat = sys.argv[1]
+    else:
+        delpat = '[ \t\n]+'
+    while 1:
+        if sys.stdin.isatty(): sys.stderr.write('--> ')
+        line = sys.stdin.readline()
+        if not line: break
+        if line[-1] == '\n': line = line[:-1]
+        fields = split(line, delpat)
+        if len(fields) != 3:
+            print 'Sorry, not three fields'
+            print 'split:', `fields`
+            continue
+        [pat, repl, str] = split(line, delpat)
+        print 'sub :', `sub(pat, repl, str)`
+        print 'gsub:', `gsub(pat, repl, str)`

Lib/repr.py

@@ -3,93 +3,93 @@
 import string
 
 class Repr:
-	def __init__(self):
-		self.maxlevel = 6
-		self.maxtuple = 6
-		self.maxlist = 6
-		self.maxdict = 4
-		self.maxstring = 30
-		self.maxlong = 40
-		self.maxother = 20
-	def repr(self, x):
-		return self.repr1(x, self.maxlevel)
-	def repr1(self, x, level):
-		typename = `type(x)`[7:-2] # "<type '......'>"
-		if ' ' in typename:
-			parts = string.split(typename)
-			typename = string.joinfields(parts, '_')
-		if hasattr(self, 'repr_' + typename):
-			return getattr(self, 'repr_' + typename)(x, level)
-		else:
-			s = `x`
-			if len(s) > self.maxother:
-				i = max(0, (self.maxother-3)/2)
-				j = max(0, self.maxother-3-i)
-				s = s[:i] + '...' + s[len(s)-j:]
-			return s
-	def repr_tuple(self, x, level):
-		n = len(x)
-		if n == 0: return '()'
-		if level <= 0: return '(...)'
-		s = ''
-		for i in range(min(n, self.maxtuple)):
-			if s: s = s + ', '
-			s = s + self.repr1(x[i], level-1)
-		if n > self.maxtuple: s = s + ', ...'
-		elif n == 1: s = s + ','
-		return '(' + s + ')'
-	def repr_list(self, x, level):
-		n = len(x)
-		if n == 0: return '[]'
-		if level <= 0: return '[...]'
-		s = ''
-		for i in range(min(n, self.maxlist)):
-			if s: s = s + ', '
-			s = s + self.repr1(x[i], level-1)
-		if n > self.maxlist: s = s + ', ...'
-		return '[' + s + ']'
-	def repr_dictionary(self, x, level):
-		n = len(x)
-		if n == 0: return '{}'
-		if level <= 0: return '{...}'
-		s = ''
-		keys = x.keys()
-		keys.sort()
-		for i in range(min(n, self.maxdict)):
-			if s: s = s + ', '
-			key = keys[i]
-			s = s + self.repr1(key, level-1)
-			s = s + ': ' + self.repr1(x[key], level-1)
-		if n > self.maxdict: s = s + ', ...'
-		return '{' + s + '}'
-	def repr_string(self, x, level):
-		s = `x[:self.maxstring]`
-		if len(s) > self.maxstring:
-			i = max(0, (self.maxstring-3)/2)
-			j = max(0, self.maxstring-3-i)
-			s = `x[:i] + x[len(x)-j:]`
-			s = s[:i] + '...' + s[len(s)-j:]
-		return s
-	def repr_long_int(self, x, level):
-		s = `x` # XXX Hope this isn't too slow...
-		if len(s) > self.maxlong:
-			i = max(0, (self.maxlong-3)/2)
-			j = max(0, self.maxlong-3-i)
-			s = s[:i] + '...' + s[len(s)-j:]
-		return s
-	def repr_instance(self, x, level):
-		try:
-			s = `x`
-			# Bugs in x.__repr__() can cause arbitrary
-			# exceptions -- then make up something
-		except:
-			return '<' + x.__class__.__name__ + ' instance at ' + \
-				  hex(id(x))[2:] + '>'
-		if len(s) > self.maxstring:
-			i = max(0, (self.maxstring-3)/2)
-			j = max(0, self.maxstring-3-i)
-			s = s[:i] + '...' + s[len(s)-j:]
-		return s
+    def __init__(self):
+        self.maxlevel = 6
+        self.maxtuple = 6
+        self.maxlist = 6
+        self.maxdict = 4
+        self.maxstring = 30
+        self.maxlong = 40
+        self.maxother = 20
+    def repr(self, x):
+        return self.repr1(x, self.maxlevel)
+    def repr1(self, x, level):
+        typename = `type(x)`[7:-2] # "<type '......'>"
+        if ' ' in typename:
+            parts = string.split(typename)
+            typename = string.joinfields(parts, '_')
+        if hasattr(self, 'repr_' + typename):
+            return getattr(self, 'repr_' + typename)(x, level)
+        else:
+            s = `x`
+            if len(s) > self.maxother:
+                i = max(0, (self.maxother-3)/2)
+                j = max(0, self.maxother-3-i)
+                s = s[:i] + '...' + s[len(s)-j:]
+            return s
+    def repr_tuple(self, x, level):
+        n = len(x)
+        if n == 0: return '()'
+        if level <= 0: return '(...)'
+        s = ''
+        for i in range(min(n, self.maxtuple)):
+            if s: s = s + ', '
+            s = s + self.repr1(x[i], level-1)
+        if n > self.maxtuple: s = s + ', ...'
+        elif n == 1: s = s + ','
+        return '(' + s + ')'
+    def repr_list(self, x, level):
+        n = len(x)
+        if n == 0: return '[]'
+        if level <= 0: return '[...]'
+        s = ''
+        for i in range(min(n, self.maxlist)):
+            if s: s = s + ', '
+            s = s + self.repr1(x[i], level-1)
+        if n > self.maxlist: s = s + ', ...'
+        return '[' + s + ']'
+    def repr_dictionary(self, x, level):
+        n = len(x)
+        if n == 0: return '{}'
+        if level <= 0: return '{...}'
+        s = ''
+        keys = x.keys()
+        keys.sort()
+        for i in range(min(n, self.maxdict)):
+            if s: s = s + ', '
+            key = keys[i]
+            s = s + self.repr1(key, level-1)
+            s = s + ': ' + self.repr1(x[key], level-1)
+        if n > self.maxdict: s = s + ', ...'
+        return '{' + s + '}'
+    def repr_string(self, x, level):
+        s = `x[:self.maxstring]`
+        if len(s) > self.maxstring:
+            i = max(0, (self.maxstring-3)/2)
+            j = max(0, self.maxstring-3-i)
+            s = `x[:i] + x[len(x)-j:]`
+            s = s[:i] + '...' + s[len(s)-j:]
+        return s
+    def repr_long_int(self, x, level):
+        s = `x` # XXX Hope this isn't too slow...
+        if len(s) > self.maxlong:
+            i = max(0, (self.maxlong-3)/2)
+            j = max(0, self.maxlong-3-i)
+            s = s[:i] + '...' + s[len(s)-j:]
+        return s
+    def repr_instance(self, x, level):
+        try:
+            s = `x`
+            # Bugs in x.__repr__() can cause arbitrary
+            # exceptions -- then make up something
+        except:
+            return '<' + x.__class__.__name__ + ' instance at ' + \
+                      hex(id(x))[2:] + '>'
+        if len(s) > self.maxstring:
+            i = max(0, (self.maxstring-3)/2)
+            j = max(0, self.maxstring-3-i)
+            s = s[:i] + '...' + s[len(s)-j:]
+        return s
 
 aRepr = Repr()
 repr = aRepr.repr

Lib/rexec.py

@@ -278,7 +278,7 @@ class RExec(ihooks._Verbose):
 
     def r_unload(self, m):
         return self.importer.unload(m)
-    
+
     # The s_* methods are similar but also swap std{in,out,err}
 
     def make_delegate_files(self):
@@ -309,7 +309,7 @@ class RExec(ihooks._Verbose):
         self.restricted_stdin = s.stdin
         self.restricted_stdout = s.stdout
         self.restricted_stderr = s.stderr
-        
+
 
     def save_files(self):
         self.save_stdin = sys.stdin
@@ -320,7 +320,7 @@ class RExec(ihooks._Verbose):
         sys.stdin = self.save_stdin
         sys.stdout = self.save_stdout
         sys.stderr = self.save_stderr
-    
+
     def s_apply(self, func, args=(), kw=None):
         self.save_files()
         try:
@@ -331,27 +331,27 @@ class RExec(ihooks._Verbose):
                 r = apply(func, args)
         finally:
             self.restore_files()
-    
+
     def s_exec(self, *args):
         self.s_apply(self.r_exec, args)
-    
+
     def s_eval(self, *args):
         self.s_apply(self.r_eval, args)
-    
+
     def s_execfile(self, *args):
         self.s_apply(self.r_execfile, args)
-    
+
     def s_import(self, *args):
         self.s_apply(self.r_import, args)
-    
+
     def s_reload(self, *args):
         self.s_apply(self.r_reload, args)
-    
+
     def s_unload(self, *args):
         self.s_apply(self.r_unload, args)
-    
+
     # Restricted open(...)
-    
+
     def r_open(self, file, mode='r', buf=-1):
         if mode not in ('r', 'rb'):
             raise IOError, "can't open files for writing in restricted mode"