=== modified file 'Doc/includes/mp_benchmarks.py'
--- Doc/includes/mp_benchmarks.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_benchmarks.py	2008-07-07 16:06:55 +0000
@@ -2,7 +2,7 @@
 # Simple benchmarks for the multiprocessing package
 #
 
-import time, sys, multiprocessing, threading, Queue, gc
+import time, sys, multiprocessing, threading, queue, gc
 
 if sys.platform == 'win32':
     _timer = time.clock
@@ -20,7 +20,7 @@
     c.notify()
     c.release()
 
-    for i in xrange(iterations):
+    for i in range(iterations):
         q.put(a)
 
     q.put('STOP')
@@ -48,8 +48,8 @@
 
         p.join()
 
-    print iterations, 'objects passed through the queue in', elapsed, 'seconds'
-    print 'average number/sec:', iterations/elapsed
+    print(iterations, 'objects passed through the queue in', elapsed, 'seconds')
+    print('average number/sec:', iterations/elapsed)
 
 
 #### TEST_PIPESPEED
@@ -60,7 +60,7 @@
     cond.notify()
     cond.release()
 
-    for i in xrange(iterations):
+    for i in range(iterations):
         c.send(a)
 
     c.send('STOP')
@@ -90,8 +90,8 @@
         elapsed = _timer() - t
         p.join()
 
-    print iterations, 'objects passed through connection in',elapsed,'seconds'
-    print 'average number/sec:', iterations/elapsed
+    print(iterations, 'objects passed through connection in',elapsed,'seconds')
+    print('average number/sec:', iterations/elapsed)
 
 
 #### TEST_SEQSPEED
@@ -105,13 +105,13 @@
 
         t = _timer()
 
-        for i in xrange(iterations):
+        for i in range(iterations):
             a = seq[5]
 
         elapsed = _timer()-t
 
-    print iterations, 'iterations in', elapsed, 'seconds'
-    print 'average number/sec:', iterations/elapsed
+    print(iterations, 'iterations in', elapsed, 'seconds')
+    print('average number/sec:', iterations/elapsed)
 
 
 #### TEST_LOCK
@@ -125,14 +125,14 @@
 
         t = _timer()
 
-        for i in xrange(iterations):
+        for i in range(iterations):
             l.acquire()
             l.release()
 
         elapsed = _timer()-t
 
-    print iterations, 'iterations in', elapsed, 'seconds'
-    print 'average number/sec:', iterations/elapsed
+    print(iterations, 'iterations in', elapsed, 'seconds')
+    print('average number/sec:', iterations/elapsed)
 
 
 #### TEST_CONDITION
@@ -141,7 +141,7 @@
     c.acquire()
     c.notify()
 
-    for i in xrange(N):
+    for i in range(N):
         c.wait()
         c.notify()
 
@@ -162,7 +162,7 @@
 
         t = _timer()
 
-        for i in xrange(iterations):
+        for i in range(iterations):
             c.notify()
             c.wait()
 
@@ -171,8 +171,8 @@
         c.release()
         p.join()
 
-    print iterations * 2, 'waits in', elapsed, 'seconds'
-    print 'average number/sec:', iterations * 2 / elapsed
+    print(iterations * 2, 'waits in', elapsed, 'seconds')
+    print('average number/sec:', iterations * 2 / elapsed)
 
 ####
 
@@ -181,51 +181,52 @@
 
     gc.disable()
 
-    print '\n\t######## testing Queue.Queue\n'
-    test_queuespeed(threading.Thread, Queue.Queue(),
+    print('\n\t######## testing queue.Queue\n')
+    test_queuespeed(threading.Thread, queue.Queue(),
                     threading.Condition())
-    print '\n\t######## testing multiprocessing.Queue\n'
+    print('\n\t######## testing multiprocessing.Queue\n')
     test_queuespeed(multiprocessing.Process, multiprocessing.Queue(),
                     multiprocessing.Condition())
-    print '\n\t######## testing Queue managed by server process\n'
+    print('\n\t######## testing Queue managed by server process\n')
     test_queuespeed(multiprocessing.Process, manager.Queue(),
                     manager.Condition())
-    print '\n\t######## testing multiprocessing.Pipe\n'
+    print('\n\t######## testing multiprocessing.Pipe\n')
     test_pipespeed()
 
-    print
+    print()
 
-    print '\n\t######## testing list\n'
+    print('\n\t######## testing list\n')
     test_seqspeed(range(10))
-    print '\n\t######## testing list managed by server process\n'
+    print('\n\t######## testing list managed by server process\n')
     test_seqspeed(manager.list(range(10)))
-    print '\n\t######## testing Array("i", ..., lock=False)\n'
-    test_seqspeed(multiprocessing.Array('i', range(10), lock=False))
-    print '\n\t######## testing Array("i", ..., lock=True)\n'
-    test_seqspeed(multiprocessing.Array('i', range(10), lock=True))
-
-    print
-
-    print '\n\t######## testing threading.Lock\n'
+    print('\n\t######## testing Array("i", ..., lock=None)\n')
+    test_seqspeed(multiprocessing.Array('i', range(10), lock=None))
+    print('\n\t######## testing Array("i", ..., lock=multiprocessing.Lock())\n')
+    test_seqspeed(multiprocessing.Array('i', range(10), lock=multiprocessing.Lock()))
+    
+
+    print()
+
+    print('\n\t######## testing threading.Lock\n')
     test_lockspeed(threading.Lock())
-    print '\n\t######## testing threading.RLock\n'
+    print('\n\t######## testing threading.RLock\n')
     test_lockspeed(threading.RLock())
-    print '\n\t######## testing multiprocessing.Lock\n'
+    print('\n\t######## testing multiprocessing.Lock\n')
     test_lockspeed(multiprocessing.Lock())
-    print '\n\t######## testing multiprocessing.RLock\n'
+    print('\n\t######## testing multiprocessing.RLock\n')
     test_lockspeed(multiprocessing.RLock())
-    print '\n\t######## testing lock managed by server process\n'
+    print('\n\t######## testing lock managed by server process\n')
     test_lockspeed(manager.Lock())
-    print '\n\t######## testing rlock managed by server process\n'
+    print('\n\t######## testing rlock managed by server process\n')
     test_lockspeed(manager.RLock())
 
-    print
+    print()
 
-    print '\n\t######## testing threading.Condition\n'
+    print('\n\t######## testing threading.Condition\n')
     test_conditionspeed(threading.Thread, threading.Condition())
-    print '\n\t######## testing multiprocessing.Condition\n'
+    print('\n\t######## testing multiprocessing.Condition\n')
     test_conditionspeed(multiprocessing.Process, multiprocessing.Condition())
-    print '\n\t######## testing condition managed by a server process\n'
+    print('\n\t######## testing condition managed by a server process\n')
     test_conditionspeed(multiprocessing.Process, manager.Condition())
 
     gc.enable()

=== modified file 'Doc/includes/mp_distributing.py'
--- Doc/includes/mp_distributing.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_distributing.py	2008-07-07 16:04:33 +0000
@@ -4,8 +4,6 @@
 # Depends on `multiprocessing` package -- tested with `processing-0.60`
 #
 
-__all__ = ['Cluster', 'Host', 'get_logger', 'current_process']
-
 #
 # Imports
 #
@@ -17,27 +15,19 @@
 import subprocess
 import logging
 import itertools
-import Queue
-
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-
-from multiprocessing import Process, current_process, cpu_count
+import queue
+import pickle
+
+from multiprocessing import Process, current_process, cpu_count, freeze_support
 from multiprocessing import util, managers, connection, forking, pool
 
 #
 # Logging
 #
 
-def get_logger():
-    return _logger
-
 _logger = logging.getLogger('distributing')
 _logger.propogate = 0
 
-util.fix_up_logger(_logger)
 _formatter = logging.Formatter(util.DEFAULT_LOGGING_FORMAT)
 _handler = logging.StreamHandler()
 _handler.setFormatter(_formatter)
@@ -52,7 +42,7 @@
 
 try:
     slot_count = cpu_count()
-except NotImplemented:
+except NotImplementedError:
     slot_count = 1
 
 #
@@ -231,7 +221,7 @@
 # Queue subclass used by distributed pool
 #
 
-class SettableQueue(Queue.Queue):
+class SettableQueue(queue.Queue):
     def empty(self):
         return not self.queue
     def full(self):
@@ -309,7 +299,7 @@
 tf = tarfile.open(fileobj=sys.stdin, mode='r|gz')
 for ti in tf:
     tf.extract(ti)
-print tempdir
+print(tempdir)
 "'''
 
 def copy_to_remote_temporary_directory(host, files):
@@ -332,6 +322,7 @@
     # get data from parent over stdin
     data = pickle.load(sys.stdin)
     sys.stdin.close()
+   
 
     # set some stuff
     _logger.setLevel(data['dist_log_level'])
@@ -360,3 +351,7 @@
     # start host manager
     debug('remote host manager starting in %s', data['dir'])
     server.serve_forever()
+    
+if __name__ == '__main__':
+    freeze_support()
+    main()

=== modified file 'Doc/includes/mp_newtype.py'
--- Doc/includes/mp_newtype.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_newtype.py	2008-07-07 14:04:59 +0000
@@ -11,15 +11,15 @@
 
 class Foo(object):
     def f(self):
-        print 'you called Foo.f()'
+        print('you called Foo.f()')
     def g(self):
-        print 'you called Foo.g()'
+        print('you called Foo.g()')
     def _h(self):
-        print 'you called Foo._h()'
+        print('you called Foo._h()')
 
 # A simple generator function
 def baz():
-    for i in xrange(10):
+    for i in range(10):
         yield i*i
 
 # Proxy type for generator objects
@@ -59,7 +59,7 @@
     manager = MyManager()
     manager.start()
 
-    print '-' * 20
+    print('-' * 20)
 
     f1 = manager.Foo1()
     f1.f()
@@ -67,7 +67,7 @@
     assert not hasattr(f1, '_h')
     assert sorted(f1._exposed_) == sorted(['f', 'g'])
 
-    print '-' * 20
+    print('-' * 20)
 
     f2 = manager.Foo2()
     f2.g()
@@ -75,21 +75,20 @@
     assert not hasattr(f2, 'f')
     assert sorted(f2._exposed_) == sorted(['g', '_h'])
 
-    print '-' * 20
+    print('-' * 20)
 
     it = manager.baz()
     for i in it:
-        print '<%d>' % i,
-    print
+        print('<%d>' % i, end='')
+    print()
 
-    print '-' * 20
+    print('-' * 20)
 
     op = manager.operator()
-    print 'op.add(23, 45) =', op.add(23, 45)
-    print 'op.pow(2, 94) =', op.pow(2, 94)
-    print 'op.getslice(range(10), 2, 6) =', op.getslice(range(10), 2, 6)
-    print 'op.repeat(range(5), 3) =', op.repeat(range(5), 3)
-    print 'op._exposed_ =', op._exposed_
+    print('op.add(23, 45) =', op.add(23, 45))
+    print('op.pow(2, 94) =', op.pow(2, 94))
+    print('op.repeat(list(range(5)), 3) =', op.repeat(list(range(5)), 3))
+    print('op._exposed_ =', op._exposed_)
 
 ##
 

=== modified file 'Doc/includes/mp_pool.py'
--- Doc/includes/mp_pool.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_pool.py	2008-07-07 16:15:27 +0000
@@ -43,17 +43,17 @@
 #
 
 def test():
-    print 'cpu_count() = %d\n' % multiprocessing.cpu_count()
+    print('cpu_count() = %d\n' % multiprocessing.cpu_count())
 
     #
     # Create pool
     #
 
     PROCESSES = 4
-    print 'Creating pool with %d processes\n' % PROCESSES
+    print('Creating pool with %d processes\n' % PROCESSES)
     pool = multiprocessing.Pool(PROCESSES)
-    print 'pool = %s' % pool
-    print
+    print('pool = %s' % pool)
+    print()
 
     #
     # Tests
@@ -66,72 +66,73 @@
     imap_it = pool.imap(calculatestar, TASKS)
     imap_unordered_it = pool.imap_unordered(calculatestar, TASKS)
 
-    print 'Ordered results using pool.apply_async():'
+    print('Ordered results using pool.apply_async():')
     for r in results:
-        print '\t', r.get()
-    print
+        print('\t', r.get())
+    print()
 
-    print 'Ordered results using pool.imap():'
+    print('Ordered results using pool.imap():')
     for x in imap_it:
-        print '\t', x
-    print
+        print('\t', x)
+    print()
 
-    print 'Unordered results using pool.imap_unordered():'
+    print('Unordered results using pool.imap_unordered():')
     for x in imap_unordered_it:
-        print '\t', x
-    print
+        print('\t', x)
+    print()
 
-    print 'Ordered results using pool.map() --- will block till complete:'
+    print('Ordered results using pool.map() --- will block till complete:')
     for x in pool.map(calculatestar, TASKS):
-        print '\t', x
-    print
+        print('\t', x)
+    print()
 
     #
     # Simple benchmarks
     #
 
     N = 100000
-    print 'def pow3(x): return x**3'
-
-    t = time.time()
-    A = map(pow3, xrange(N))
-    print '\tmap(pow3, xrange(%d)):\n\t\t%s seconds' % \
-          (N, time.time() - t)
-
-    t = time.time()
-    B = pool.map(pow3, xrange(N))
-    print '\tpool.map(pow3, xrange(%d)):\n\t\t%s seconds' % \
-          (N, time.time() - t)
-
-    t = time.time()
-    C = list(pool.imap(pow3, xrange(N), chunksize=N//8))
-    print '\tlist(pool.imap(pow3, xrange(%d), chunksize=%d)):\n\t\t%s' \
-          ' seconds' % (N, N//8, time.time() - t)
+    print('def pow3(x): return x**3')
+
+    t = time.time()
+    A = list(map(pow3, range(N)))
+    print('\tmap(pow3, range(%d)):\n\t\t%s seconds' % \
+          (N, time.time() - t))
+
+    t = time.time()
+    B = pool.map(pow3, range(N))
+    print('\tpool.map(pow3, range(%d)):\n\t\t%s seconds' % \
+          (N, time.time() - t))
+
+    t = time.time()
+    C = list(pool.imap(pow3, range(N), chunksize=N//8))
+    print('\tlist(pool.imap(pow3, range(%d), chunksize=%d)):\n\t\t%s' \
+          ' seconds' % (N, N//8, time.time() - t))
 
     assert A == B == C, (len(A), len(B), len(C))
-    print
+    print()
 
     L = [None] * 1000000
-    print 'def noop(x): pass'
-    print 'L = [None] * 1000000'
+    print('def noop(x): pass')
+    print('L = [None] * 1000000')
 
     t = time.time()
-    A = map(noop, L)
-    print '\tmap(noop, L):\n\t\t%s seconds' % \
-          (time.time() - t)
+    A = list(map(noop, L))
+    print('\tmap(noop, L):\n\t\t%s seconds' % \
+          (time.time() - t))
 
     t = time.time()
     B = pool.map(noop, L)
-    print '\tpool.map(noop, L):\n\t\t%s seconds' % \
-          (time.time() - t)
+    print('\tpool.map(noop, L):\n\t\t%s seconds' % \
+          (time.time() - t))
 
     t = time.time()
     C = list(pool.imap(noop, L, chunksize=len(L)//8))
-    print '\tlist(pool.imap(noop, L, chunksize=%d)):\n\t\t%s seconds' % \
-          (len(L)//8, time.time() - t)
+    print('\tlist(pool.imap(noop, L, chunksize=%d)):\n\t\t%s seconds' % \
+          (len(L)//8, time.time() - t))
 
     assert A == B == C, (len(A), len(B), len(C))
-    print
+    print()
+    
 
     del A, B, C, L
 
@@ -139,33 +140,33 @@
     # Test error handling
     #
 
-    print 'Testing error handling:'
-
-    try:
-        print pool.apply(f, (5,))
-    except ZeroDivisionError:
-        print '\tGot ZeroDivisionError as expected from pool.apply()'
-    else:
-        raise AssertionError, 'expected ZeroDivisionError'
-
-    try:
-        print pool.map(f, range(10))
-    except ZeroDivisionError:
-        print '\tGot ZeroDivisionError as expected from pool.map()'
-    else:
-        raise AssertionError, 'expected ZeroDivisionError'
-
-    try:
-        print list(pool.imap(f, range(10)))
-    except ZeroDivisionError:
-        print '\tGot ZeroDivisionError as expected from list(pool.imap())'
-    else:
-        raise AssertionError, 'expected ZeroDivisionError'
+    print('Testing error handling:')
+
+    try:
+        print(pool.apply(f, (5,)))
+    except ZeroDivisionError:
+        print('\tGot ZeroDivisionError as expected from pool.apply()')
+    else:
+        raise AssertionError('expected ZeroDivisionError')
+
+    try:
+        print(pool.map(f, range(10)))
+    except ZeroDivisionError:
+        print('\tGot ZeroDivisionError as expected from pool.map()')
+    else:
+        raise AssertionError('expected ZeroDivisionError')
+
+    try:
+        print(list(pool.imap(f, range(10))))
+    except ZeroDivisionError:
+        print('\tGot ZeroDivisionError as expected from list(pool.imap())')
+    else:
+        raise AssertionError('expected ZeroDivisionError')
 
     it = pool.imap(f, range(10))
     for i in range(10):
         try:
-            x = it.next()
+            x = next(it)
         except ZeroDivisionError:
             if i == 5:
                 pass
@@ -173,17 +174,17 @@
             break
         else:
             if i == 5:
-                raise AssertionError, 'expected ZeroDivisionError'
+                raise AssertionError('expected ZeroDivisionError')
 
     assert i == 9
-    print '\tGot ZeroDivisionError as expected from IMapIterator.next()'
-    print
+    print('\tGot ZeroDivisionError as expected from IMapIterator.__next__()')
+    print()
 
     #
     # Testing timeouts
     #
 
-    print 'Testing ApplyResult.get() with timeout:',
+    print('Testing ApplyResult.get() with timeout:',)
     res = pool.apply_async(calculate, TASKS[0])
     while 1:
         sys.stdout.flush()
@@ -192,15 +193,15 @@
             break
         except multiprocessing.TimeoutError:
             sys.stdout.write('.')
-    print
-    print
+    print()
+    print()
 
-    print 'Testing IMapIterator.next() with timeout:',
+    print('Testing IMapIterator.__next__() with timeout:', end='')
     it = pool.imap(calculatestar, TASKS)
     while 1:
         sys.stdout.flush()
         try:
-            sys.stdout.write('\n\t%s' % it.next(0.02))
+            sys.stdout.write('\n\t%s' % it.__next__(0.02))
         except StopIteration:
             break
         except multiprocessing.TimeoutError:
@@ -212,7 +213,7 @@
     # Testing callback
     #
 
-    print 'Testing callback:'
+    print('Testing callback:')
 
     A = []
     B = [56, 0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
@@ -224,9 +225,9 @@
     r.wait()
 
     if A == B:
-        print '\tcallbacks succeeded\n'
+        print('\tcallbacks succeeded\n')
     else:
-        print '\t*** callbacks failed\n\t\t%s != %s\n' % (A, B)
+        print('\t*** callbacks failed\n\t\t%s != %s\n' % (A, B))
 
     #
     # Check there are no outstanding tasks
@@ -238,7 +239,7 @@
     # Check close() methods
     #
 
-    print 'Testing close():'
+    print('Testing close():')
 
     for worker in pool._pool:
         assert worker.is_alive()
@@ -252,13 +253,13 @@
     for worker in pool._pool:
         assert not worker.is_alive()
 
-    print '\tclose() succeeded\n'
+    print('\tclose() succeeded\n')
 
     #
     # Check terminate() method
     #
 
-    print 'Testing terminate():'
+    print('Testing terminate():')
 
     pool = multiprocessing.Pool(2)
     DELTA = 0.1
@@ -270,13 +271,13 @@
     for worker in pool._pool:
         assert not worker.is_alive()
 
-    print '\tterminate() succeeded\n'
+    print('\tterminate() succeeded\n')
 
     #
     # Check garbage collection
     #
 
-    print 'Testing garbage collection:'
+    print('Testing garbage collection:')
 
     pool = multiprocessing.Pool(2)
     DELTA = 0.1
@@ -291,7 +292,7 @@
     for worker in processes:
         assert not worker.is_alive()
 
-    print '\tgarbage collection succeeded\n'
+    print('\tgarbage collection succeeded\n')
 
 
 if __name__ == '__main__':
@@ -300,12 +301,12 @@
     assert len(sys.argv) in (1, 2)
 
     if len(sys.argv) == 1 or sys.argv[1] == 'processes':
-        print ' Using processes '.center(79, '-')
+        print(' Using processes '.center(79, '-'))
     elif sys.argv[1] == 'threads':
-        print ' Using threads '.center(79, '-')
+        print(' Using threads '.center(79, '-'))
         import multiprocessing.dummy as multiprocessing
     else:
-        print 'Usage:\n\t%s [processes | threads]' % sys.argv[0]
+        print('Usage:\n\t%s [processes | threads]' % sys.argv[0])
         raise SystemExit(2)
 
     test()

=== modified file 'Doc/includes/mp_synchronize.py'
--- Doc/includes/mp_synchronize.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_synchronize.py	2008-07-07 16:34:39 +0000
@@ -2,8 +2,10 @@
 # A test file for the `multiprocessing` package
 #
 
-import time, sys, random
-from Queue import Empty
+import time
+import sys
+import random
+from queue import Empty
 
 import multiprocessing               # may get overwritten
 
@@ -15,7 +17,7 @@
     time.sleep(random.random()*4)
 
     mutex.acquire()
-    print '\n\t\t\t' + str(multiprocessing.current_process()) + ' has finished'
+    print('\n\t\t\t' + str(multiprocessing.current_process()) + ' has finished')
     running.value -= 1
     mutex.release()
 
@@ -31,12 +33,12 @@
     while running.value > 0:
         time.sleep(0.08)
         mutex.acquire()
-        print running.value,
+        print(running.value, end='')
         sys.stdout.flush()
         mutex.release()
 
-    print
-    print 'No more running processes'
+    print()
+    print('No more running processes')
 
 
 #### TEST_QUEUE
@@ -57,22 +59,23 @@
     while o != 'STOP':
         try:
             o = q.get(timeout=0.3)
-            print o,
-            sys.stdout.flush()
         except Empty:
-            print 'TIMEOUT'
-
-    print
+            print('TIMEOUT')
+        print(o, end='')
+        sys.stdout.flush()
+
+
+    print()
 
 
 #### TEST_CONDITION
 
 def condition_func(cond):
     cond.acquire()
-    print '\t' + str(cond)
+    print('\t' + str(cond))
     time.sleep(2)
-    print '\tchild is notifying'
-    print '\t' + str(cond)
+    print('\tchild is notifying')
+    print('\t' + str(cond))
     cond.notify()
     cond.release()
 
@@ -80,26 +83,26 @@
     cond = multiprocessing.Condition()
 
     p = multiprocessing.Process(target=condition_func, args=(cond,))
-    print cond
+    print(cond)
 
     cond.acquire()
-    print cond
+    print(cond)
     cond.acquire()
-    print cond
+    print(cond)
 
     p.start()
 
-    print 'main is waiting'
+    print('main is waiting')
     cond.wait()
-    print 'main has woken up'
+    print('main has woken up')
 
-    print cond
+    print(cond)
     cond.release()
-    print cond
+    print(cond)
     cond.release()
 
     p.join()
-    print cond
+    print(cond)
 
 
 #### TEST_SEMAPHORE
@@ -109,7 +112,7 @@
 
     mutex.acquire()
     running.value += 1
-    print running.value, 'tasks are running'
+    print(running.value, 'tasks are running')
     mutex.release()
 
     random.seed()
@@ -117,7 +120,7 @@
 
     mutex.acquire()
     running.value -= 1
-    print '%s has finished' % multiprocessing.current_process()
+    print('%s has finished' % multiprocessing.current_process())
     mutex.release()
 
     sema.release()
@@ -143,30 +146,30 @@
 #### TEST_JOIN_TIMEOUT
 
 def join_timeout_func():
-    print '\tchild sleeping'
+    print('\tchild sleeping')
     time.sleep(5.5)
-    print '\n\tchild terminating'
+    print('\n\tchild terminating')
 
 def test_join_timeout():
     p = multiprocessing.Process(target=join_timeout_func)
     p.start()
 
-    print 'waiting for process to finish'
+    print('waiting for process to finish')
 
     while 1:
         p.join(timeout=1)
         if not p.is_alive():
             break
-        print '.',
+        print('.', end='')
         sys.stdout.flush()
 
 
 #### TEST_EVENT
 
 def event_func(event):
-    print '\t%r is waiting' % multiprocessing.current_process()
+    print('\t%r is waiting' % multiprocessing.current_process())
     event.wait()
-    print '\t%r has woken up' % multiprocessing.current_process()
+    print('\t%r has woken up' % multiprocessing.current_process())
 
 def test_event():
     event = multiprocessing.Event()
@@ -177,10 +180,10 @@
     for p in processes:
         p.start()
 
-    print 'main is sleeping'
+    print('main is sleeping')
     time.sleep(2)
 
-    print 'main is setting event'
+    print('main is setting event')
     event.set()
 
     for p in processes:
@@ -200,7 +203,7 @@
         sa = list(shared_arrays[i][:])
         assert a == sa
 
-    print 'Tests passed'
+    print('Tests passed')
 
 def test_sharedvalues():
     values = [
@@ -209,9 +212,9 @@
         ('d', 1.25)
         ]
     arrays = [
-        ('i', range(100)),
+        ('i', list(range(100))),
         ('d', [0.25 * i for i in range(100)]),
-        ('H', range(1000))
+        ('H', list(range(1000)))
         ]
 
     shared_values = [multiprocessing.Value(id, v) for id, v in values]
@@ -233,20 +236,19 @@
     global multiprocessing
 
     multiprocessing = namespace
-
-    for func in [ test_value, test_queue, test_condition,
-                  test_semaphore, test_join_timeout, test_event,
-                  test_sharedvalues ]:
-
-        print '\n\t######## %s\n' % func.__name__
+    
+    funcs = [test_value, test_queue, test_condition, test_semaphore,
+             test_join_timeout, test_event, test_sharedvalues]
+    for func in funcs:
+        print('\n\t######## %s\n' % func.__name__)
         func()
 
     ignore = multiprocessing.active_children()      # cleanup any old processes
     if hasattr(multiprocessing, '_debug_info'):
         info = multiprocessing._debug_info()
         if info:
-            print info
-            raise ValueError, 'there should be no positive refcounts left'
+            print(info)
+            raise ValueError('there should be no positive refcounts left')
 
 
 if __name__ == '__main__':
@@ -255,19 +257,19 @@
     assert len(sys.argv) in (1, 2)
 
     if len(sys.argv) == 1 or sys.argv[1] == 'processes':
-        print ' Using processes '.center(79, '-')
+        print(' Using processes '.center(79, '-'))
         namespace = multiprocessing
     elif sys.argv[1] == 'manager':
-        print ' Using processes and a manager '.center(79, '-')
+        print(' Using processes and a manager '.center(79, '-'))
         namespace = multiprocessing.Manager()
         namespace.Process = multiprocessing.Process
         namespace.current_process = multiprocessing.current_process
         namespace.active_children = multiprocessing.active_children
     elif sys.argv[1] == 'threads':
-        print ' Using threads '.center(79, '-')
+        print(' Using threads '.center(79, '-'))
         import multiprocessing.dummy as namespace
     else:
-        print 'Usage:\n\t%s [processes | manager | threads]' % sys.argv[0]
-        raise SystemExit, 2
+        print('Usage:\n\t%s [processes | manager | threads]' % sys.argv[0])
+        raise SystemExit(2)
 
     test(namespace)

=== modified file 'Doc/includes/mp_webserver.py'
--- Doc/includes/mp_webserver.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_webserver.py	2008-07-07 18:28:21 +0000
@@ -13,8 +13,7 @@
 import sys
 
 from multiprocessing import Process, current_process, freeze_support
-from BaseHTTPServer import HTTPServer
-from SimpleHTTPServer import SimpleHTTPRequestHandler
+from http.server import SimpleHTTPRequestHandler, HTTPServer
 
 if sys.platform == 'win32':
     import multiprocessing.reduction    # make sockets pickable/inheritable
@@ -54,9 +53,9 @@
     ADDRESS = ('localhost', 8000)
     NUMBER_OF_PROCESSES = 4
 
-    print 'Serving at http://%s:%d using %d worker processes' % \
-          (ADDRESS[0], ADDRESS[1], NUMBER_OF_PROCESSES)
-    print 'To exit press Ctrl-' + ['C', 'Break'][sys.platform=='win32']
+    print('Serving at http://%s:%d using %d worker processes' % \
+          (ADDRESS[0], ADDRESS[1], NUMBER_OF_PROCESSES))
+    print('To exit press Ctrl-' + ['C', 'Break'][sys.platform=='win32'])
 
     os.chdir(DIR)
     runpool(ADDRESS, NUMBER_OF_PROCESSES)

=== modified file 'Doc/includes/mp_workers.py'
--- Doc/includes/mp_workers.py	2008-06-13 22:53:14 +0000
+++ Doc/includes/mp_workers.py	2008-07-07 14:04:59 +0000
@@ -65,9 +65,9 @@
         Process(target=worker, args=(task_queue, done_queue)).start()
 
     # Get and print results
-    print 'Unordered results:'
+    print('Unordered results:')
     for i in range(len(TASKS1)):
-        print '\t', done_queue.get()
+        print('\t', done_queue.get())
 
     # Add more tasks using `put()`
     for task in TASKS2:
@@ -75,7 +75,7 @@
 
     # Get and print some more results
     for i in range(len(TASKS2)):
-        print '\t', done_queue.get()
+        print('\t', done_queue.get())
 
     # Tell child processes to stop
     for i in range(NUMBER_OF_PROCESSES):