Run these demo scripts through reindent.py to give them 4-space indents. I've…

Run these demo scripts through reindent.py to give them 4-space indents.  I've verified that their output is unchanged.

Demo/classes/Dbm.py

@@ -6,61 +6,61 @@
 
 class Dbm:
 
-	def __init__(self, filename, mode, perm):
-		import dbm
-		self.db = dbm.open(filename, mode, perm)
+    def __init__(self, filename, mode, perm):
+        import dbm
+        self.db = dbm.open(filename, mode, perm)
 
-	def __repr__(self):
-		s = ''
-		for key in self.keys():
-			t = `key` + ': ' + `self[key]`
-			if s: t = ', ' + t
-			s = s + t
-		return '{' + s + '}'
+    def __repr__(self):
+        s = ''
+        for key in self.keys():
+            t = `key` + ': ' + `self[key]`
+            if s: t = ', ' + t
+            s = s + t
+        return '{' + s + '}'
 
-	def __len__(self):
-		return len(self.db)
+    def __len__(self):
+        return len(self.db)
 
-	def __getitem__(self, key):
-		return eval(self.db[`key`])
+    def __getitem__(self, key):
+        return eval(self.db[`key`])
 
-	def __setitem__(self, key, value):
-		self.db[`key`] = `value`
+    def __setitem__(self, key, value):
+        self.db[`key`] = `value`
 
-	def __delitem__(self, key):
-		del self.db[`key`]
+    def __delitem__(self, key):
+        del self.db[`key`]
 
-	def keys(self):
-		res = []
-		for key in self.db.keys():
-			res.append(eval(key))
-		return res
+    def keys(self):
+        res = []
+        for key in self.db.keys():
+            res.append(eval(key))
+        return res
 
-	def has_key(self, key):
-		return self.db.has_key(`key`)
+    def has_key(self, key):
+        return self.db.has_key(`key`)
 
 
 def test():
-	d = Dbm('@dbm', 'rw', 0600)
-	print d
-	while 1:
-		try:
-			key = input('key: ')
-			if d.has_key(key):
-				value = d[key]
-				print 'currently:', value
-			value = input('value: ')
-			if value == None:
-				del d[key]
-			else:
-				d[key] = value
-		except KeyboardInterrupt:
-			print ''
-			print d
-		except EOFError:
-			print '[eof]'
-			break
-	print d
+    d = Dbm('@dbm', 'rw', 0600)
+    print d
+    while 1:
+        try:
+            key = input('key: ')
+            if d.has_key(key):
+                value = d[key]
+                print 'currently:', value
+            value = input('value: ')
+            if value == None:
+                del d[key]
+            else:
+                d[key] = value
+        except KeyboardInterrupt:
+            print ''
+            print d
+        except EOFError:
+            print '[eof]'
+            break
+    print d
 
 
 test()

Demo/classes/Range.py

@@ -7,17 +7,17 @@
 # Wrapper function to emulate the complicated range() arguments
 
 def range(*a):
-	if len(a) == 1:
-		start, stop, step = 0, a[0], 1
-	elif len(a) == 2:
-		start, stop = a
-		step = 1
-	elif len(a) == 3:
-		start, stop, step = a
-	else:
-		raise TypeError, 'range() needs 1-3 arguments'
-	return Range(start, stop, step)
-	
+    if len(a) == 1:
+        start, stop, step = 0, a[0], 1
+    elif len(a) == 2:
+        start, stop = a
+        step = 1
+    elif len(a) == 3:
+        start, stop, step = a
+    else:
+        raise TypeError, 'range() needs 1-3 arguments'
+    return Range(start, stop, step)
+
 
 # Class implementing a range object.
 # To the user the instances feel like immutable sequences
@@ -25,47 +25,47 @@ def range(*a):
 
 class Range:
 
-	# initialization -- should be called only by range() above
-	def __init__(self, start, stop, step):
-		if step == 0:
-			raise ValueError, 'range() called with zero step'
-		self.start = start
-		self.stop = stop
-		self.step = step
-		self.len = max(0, int((self.stop - self.start) / self.step))
+    # initialization -- should be called only by range() above
+    def __init__(self, start, stop, step):
+        if step == 0:
+            raise ValueError, 'range() called with zero step'
+        self.start = start
+        self.stop = stop
+        self.step = step
+        self.len = max(0, int((self.stop - self.start) / self.step))
 
-	# implement `x` and is also used by print x
-	def __repr__(self):
-		return 'range' + `self.start, self.stop, self.step`
+    # implement `x` and is also used by print x
+    def __repr__(self):
+        return 'range' + `self.start, self.stop, self.step`
 
-	# implement len(x)
-	def __len__(self):
-		return self.len
+    # implement len(x)
+    def __len__(self):
+        return self.len
 
-	# implement x[i]
-	def __getitem__(self, i):
-		if 0 <= i < self.len:
-			return self.start + self.step * i
-		else:
-			raise IndexError, 'range[i] index out of range'
+    # implement x[i]
+    def __getitem__(self, i):
+        if 0 <= i < self.len:
+            return self.start + self.step * i
+        else:
+            raise IndexError, 'range[i] index out of range'
 
 
 # Small test program
 
 def test():
-	import time, __builtin__
-	print range(10), range(-10, 10), range(0, 10, 2)
-	for i in range(100, -100, -10): print i,
-	print
-	t1 = time.time()
-	for i in range(1000):
-		pass
-	t2 = time.time()
-	for i in __builtin__.range(1000):
-		pass
-	t3 = time.time()
-	print t2-t1, 'sec (class)'
-	print t3-t2, 'sec (built-in)'
+    import time, __builtin__
+    print range(10), range(-10, 10), range(0, 10, 2)
+    for i in range(100, -100, -10): print i,
+    print
+    t1 = time.time()
+    for i in range(1000):
+        pass
+    t2 = time.time()
+    for i in __builtin__.range(1000):
+        pass
+    t3 = time.time()
+    print t2-t1, 'sec (class)'
+    print t3-t2, 'sec (built-in)'
 
 
 test()

Demo/classes/Rev.py

@@ -5,13 +5,13 @@
 #
 # >>> for c in Rev( 'Hello World!' ) : sys.stdout.write( c )
 # ... else: sys.stdout.write( '\n' )
-# ... 
+# ...
 # !dlroW olleH
 #
 # The .forw is so you can use anonymous sequences in __init__, and still
-# keep a reference the forward sequence. ) 
+# keep a reference the forward sequence. )
 # If you give it a non-anonymous mutable sequence, the reverse sequence
-# will track the updated values. ( but not reassignment! - another 
+# will track the updated values. ( but not reassignment! - another
 # good reason to use anonymous values in creating the sequence to avoid
 # confusion. Maybe it should be change to copy input sequence to break
 # the connection completely ? )
@@ -19,14 +19,14 @@
 # >>> nnn = range( 0, 3 )
 # >>> rnn = Rev( nnn )
 # >>> for n in rnn: print n
-# ... 
+# ...
 # 2
 # 1
 # 0
-# >>> for n in range( 4, 6 ): nnn.append( n )	# update nnn
-# ... 
-# >>> for n in rnn: print n	# prints reversed updated values
-# ... 
+# >>> for n in range( 4, 6 ): nnn.append( n )   # update nnn
+# ...
+# >>> for n in rnn: print n     # prints reversed updated values
+# ...
 # 5
 # 4
 # 2
@@ -35,55 +35,55 @@
 # >>> nnn = nnn[1:-1]
 # >>> nnn
 # [1, 2, 4]
-# >>> for n in rnn: print n	# prints reversed values of old nnn
-# ... 
+# >>> for n in rnn: print n     # prints reversed values of old nnn
+# ...
 # 5
 # 4
 # 2
 # 1
 # 0
-# >>> 
+# >>>
 #
 # WH = Rev( 'Hello World!' )
 # print WH.forw, WH.back
 # nnn = Rev( range( 1, 10 ) )
 # print nnn.forw
 # print nnn
-# 
+#
 # produces output:
-# 
+#
 # Hello World! !dlroW olleH
 # [1, 2, 3, 4, 5, 6, 7, 8, 9]
 # [9, 8, 7, 6, 5, 4, 3, 2, 1]
-# 
-# >>>rrr = Rev( nnn ) 
+#
+# >>>rrr = Rev( nnn )
 # >>>rrr
-# <1, 2, 3, 4, 5, 6, 7, 8, 9>	
+# <1, 2, 3, 4, 5, 6, 7, 8, 9>
 
 from string import joinfields
 class Rev:
-	def __init__( self, seq ):
-		self.forw = seq
-		self.back = self
-	def __len__( self ):
-		return len( self.forw )
-	def __getitem__( self, j ):
-		return self.forw[ -( j + 1 ) ]
-	def __repr__( self ):
-		seq = self.forw
-		if type(seq) == type( [] ) : 
-			wrap = '[]'
-			sep = ', '
-		elif type(seq) == type( () ) : 
-			wrap = '()'
-			sep = ', '
-		elif type(seq) == type( '' ) : 
-			wrap = ''
-			sep = ''
-		else: 
-			wrap = '<>'
-			sep = ', ' 
-		outstrs = []
-		for item in self.back :
-			outstrs.append( str( item ) )
-		return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:]
+    def __init__( self, seq ):
+        self.forw = seq
+        self.back = self
+    def __len__( self ):
+        return len( self.forw )
+    def __getitem__( self, j ):
+        return self.forw[ -( j + 1 ) ]
+    def __repr__( self ):
+        seq = self.forw
+        if type(seq) == type( [] ) :
+            wrap = '[]'
+            sep = ', '
+        elif type(seq) == type( () ) :
+            wrap = '()'
+            sep = ', '
+        elif type(seq) == type( '' ) :
+            wrap = ''
+            sep = ''
+        else:
+            wrap = '<>'
+            sep = ', '
+        outstrs = []
+        for item in self.back :
+            outstrs.append( str( item ) )
+        return wrap[:1] + joinfields( outstrs, sep ) + wrap[-1:]

Demo/classes/Vec.py

@@ -2,63 +2,63 @@
 
 
 def vec(*v):
-	return apply(Vec, v)
+    return apply(Vec, v)
 
 
 class Vec:
 
-	def __init__(self, *v):
-		self.v = []
-		for x in v:
-			self.v.append(x)
+    def __init__(self, *v):
+        self.v = []
+        for x in v:
+            self.v.append(x)
 
 
-	def fromlist(self, v):
-		self.v = []
-		if type(v) <> type([]):
-			raise TypeError
-		self.v = v[:]
-		return self
+    def fromlist(self, v):
+        self.v = []
+        if type(v) <> type([]):
+            raise TypeError
+        self.v = v[:]
+        return self
 
 
-	def __repr__(self):
-		return 'vec(' + `self.v`[1:-1] + ')'
+    def __repr__(self):
+        return 'vec(' + `self.v`[1:-1] + ')'
 
-	def __len__(self):
-		return len(self.v)
+    def __len__(self):
+        return len(self.v)
 
-	def __getitem__(self, i):
-		return self.v[i]
+    def __getitem__(self, i):
+        return self.v[i]
 
-	def __add__(a, b):
-		# Element-wise addition
-		v = []
-		for i in range(len(a)):
-			v.append(a[i] + b[i])
-		return Vec().fromlist(v)
+    def __add__(a, b):
+        # Element-wise addition
+        v = []
+        for i in range(len(a)):
+            v.append(a[i] + b[i])
+        return Vec().fromlist(v)
 
-	def __sub__(a, b):
-		# Element-wise subtraction
-		v = []
-		for i in range(len(a)):
-			v.append(a[i] - b[i])
-		return Vec().fromlist(v)
+    def __sub__(a, b):
+        # Element-wise subtraction
+        v = []
+        for i in range(len(a)):
+            v.append(a[i] - b[i])
+        return Vec().fromlist(v)
 
-	def __mul__(self, scalar):
-		# Multiply by scalar
-		v = []
-		for i in range(len(self.v)):
-			v.append(self.v[i]*scalar)
-		return Vec().fromlist(v)
+    def __mul__(self, scalar):
+        # Multiply by scalar
+        v = []
+        for i in range(len(self.v)):
+            v.append(self.v[i]*scalar)
+        return Vec().fromlist(v)
 
 
 
 def test():
-	a = vec(1, 2, 3)
-	b = vec(3, 2, 1)
-	print a
-	print b
-	print a+b
-	print a*3.0
+    a = vec(1, 2, 3)
+    b = vec(3, 2, 1)
+    print a
+    print b
+    print a+b
+    print a*3.0
 
 test()

Demo/comparisons/regextest.py

 #! /usr/bin/env python
 
 # 1)  Regular Expressions Test
-# 
-#     Read a file of (extended per egrep) regular expressions (one per line), 
+#
+#     Read a file of (extended per egrep) regular expressions (one per line),
 #     and apply those to all files whose names are listed on the command line.
 #     Basically, an 'egrep -f' simulator.  Test it with 20 "vt100" patterns
 #     against a five /etc/termcap files.  Tests using more elaborate patters
 #     would also be interesting.  Your code should not break if given hundreds
-#     of regular expressions or binary files to scan.  
+#     of regular expressions or binary files to scan.
 
 # This implementation:
 # - combines all patterns into a single one using ( ... | ... | ... )
@@ -24,27 +24,27 @@ from regex_syntax import *
 regex.set_syntax(RE_SYNTAX_EGREP)
 
 def main():
-	pats = map(chomp, sys.stdin.readlines())
-	bigpat = '(' + string.joinfields(pats, '|') + ')'
-	prog = regex.compile(bigpat)
-	
-	for file in sys.argv[1:]:
-		try:
-			fp = open(file, 'r')
-		except IOError, msg:
-			print "%s: %s" % (file, msg)
-			continue
-		lineno = 0
-		while 1:
-			line = fp.readline()
-			if not line:
-				break
-			lineno = lineno + 1
-			if prog.search(line) >= 0:
-				print "%s:%s:%s" % (file, lineno, line),
+    pats = map(chomp, sys.stdin.readlines())
+    bigpat = '(' + string.joinfields(pats, '|') + ')'
+    prog = regex.compile(bigpat)
+
+    for file in sys.argv[1:]:
+        try:
+            fp = open(file, 'r')
+        except IOError, msg:
+            print "%s: %s" % (file, msg)
+            continue
+        lineno = 0
+        while 1:
+            line = fp.readline()
+            if not line:
+                break
+            lineno = lineno + 1
+            if prog.search(line) >= 0:
+                print "%s:%s:%s" % (file, lineno, line),
 
 def chomp(s):
-	if s[-1:] == '\n': return s[:-1]
-	else: return s
+    if s[-1:] == '\n': return s[:-1]
+    else: return s
 
 main()

Demo/comparisons/sortingtest.py

 #! /usr/bin/env python
 
 # 2)  Sorting Test
-# 
+#
 #     Sort an input file that consists of lines like this
-# 
+#
 #         var1=23 other=14 ditto=23 fred=2
-# 
+#
 #     such that each output line is sorted WRT to the number.  Order
 #     of output lines does not change.  Resolve collisions using the
 #     variable name.   e.g.
-# 
-#         fred=2 other=14 ditto=23 var1=23 
-# 
+#
+#         fred=2 other=14 ditto=23 var1=23
+#
 #     Lines may be up to several kilobytes in length and contain
 #     zillions of variables.
 
@@ -28,23 +28,23 @@ import string
 import sys
 
 def main():
-	prog = regex.compile('^\(.*\)=\([-+]?[0-9]+\)')
-	def makekey(item, prog=prog):
-		if prog.match(item) >= 0:
-			var, num = prog.group(1, 2)
-			return string.atoi(num), var
-		else:
-			# Bad input -- pretend it's a var with value 0
-			return 0, item
-	while 1:
-		line = sys.stdin.readline()
-		if not line:
-			break
-		items = string.split(line)
-		items = map(makekey, items)
-		items.sort()
-		for num, var in items:
-			print "%s=%s" % (var, num),
-		print
+    prog = regex.compile('^\(.*\)=\([-+]?[0-9]+\)')
+    def makekey(item, prog=prog):
+        if prog.match(item) >= 0:
+            var, num = prog.group(1, 2)
+            return string.atoi(num), var
+        else:
+            # Bad input -- pretend it's a var with value 0
+            return 0, item
+    while 1:
+        line = sys.stdin.readline()
+        if not line:
+            break
+        items = string.split(line)
+        items = map(makekey, items)
+        items.sort()
+        for num, var in items:
+            print "%s=%s" % (var, num),
+        print
 
 main()

Demo/comparisons/systemtest.py

 #! /usr/bin/env python
 
 # 3)  System Test
-# 
+#
 #     Given a list of directories, report any bogus symbolic links contained
 #     anywhere in those subtrees.  A bogus symbolic link is one that cannot
 #     be resolved because it points to a nonexistent or otherwise
@@ -21,54 +21,54 @@ import sys
 from stat import *
 
 def main():
-	try:
-		# Note: can't test for presence of lstat -- it's always there
-		dummy = os.readlink
-	except AttributeError:
-		print "This system doesn't have symbolic links"
-		sys.exit(0)
-	if sys.argv[1:]:
-		prefix = sys.argv[1]
-	else:
-		prefix = ''
-	if prefix:
-		os.chdir(prefix)
-		if prefix[-1:] != '/': prefix = prefix + '/'
-		reportboguslinks(prefix)
-	else:
-		reportboguslinks('')
+    try:
+        # Note: can't test for presence of lstat -- it's always there
+        dummy = os.readlink
+    except AttributeError:
+        print "This system doesn't have symbolic links"
+        sys.exit(0)
+    if sys.argv[1:]:
+        prefix = sys.argv[1]
+    else:
+        prefix = ''
+    if prefix:
+        os.chdir(prefix)
+        if prefix[-1:] != '/': prefix = prefix + '/'
+        reportboguslinks(prefix)
+    else:
+        reportboguslinks('')
 
 def reportboguslinks(prefix):
-	try:
-		names = os.listdir('.')
-	except os.error, msg:
-		print "%s%s: can't list: %s" % (prefix, '.', msg)
-		return
-	names.sort()
-	for name in names:
-		if name == os.curdir or name == os.pardir:
-			continue
-		try:
-			mode = os.lstat(name)[ST_MODE]
-		except os.error:
-			print "%s%s: can't stat: %s" % (prefix, name, msg)
-			continue
-		if S_ISLNK(mode):
-			try:
-				os.stat(name)
-			except os.error:
-				print "%s%s -> %s" % \
-				      (prefix, name, os.readlink(name))
-		elif S_ISDIR(mode):
-			try:
-				os.chdir(name)
-			except os.error, msg:
-				print "%s%s: can't chdir: %s" % \
-				      (prefix, name, msg)
-				continue
-			try:
-				reportboguslinks(prefix + name + '/')
-			finally:
-				os.chdir('..')
+    try:
+        names = os.listdir('.')
+    except os.error, msg:
+        print "%s%s: can't list: %s" % (prefix, '.', msg)
+        return
+    names.sort()
+    for name in names:
+        if name == os.curdir or name == os.pardir:
+            continue
+        try:
+            mode = os.lstat(name)[ST_MODE]
+        except os.error:
+            print "%s%s: can't stat: %s" % (prefix, name, msg)
+            continue
+        if S_ISLNK(mode):
+            try:
+                os.stat(name)
+            except os.error:
+                print "%s%s -> %s" % \
+                      (prefix, name, os.readlink(name))
+        elif S_ISDIR(mode):
+            try:
+                os.chdir(name)
+            except os.error, msg:
+                print "%s%s: can't chdir: %s" % \
+                      (prefix, name, msg)
+                continue
+            try:
+                reportboguslinks(prefix + name + '/')
+            finally:
+                os.chdir('..')
 
 main()