diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index 2df4123..8813d3c 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -32,6 +32,7 @@
 # Changes and improvements suggested by Steve Majewski.
 # Modified by Jack to work on the mac.
 # Modified by Siebren to support docstrings and PASV.
+# Modified by Phil Schwartz to add storbinary and storlines callbacks.
 #
 
 import os
@@ -313,7 +314,7 @@
         expected size may be None if it could not be determined.
 
         Optional `rest' argument can be a string that is sent as the
-        argument to a RESTART command.  This is essentially a server
+        argument to a REST command.  This is essentially a server
         marker used to tell the server to skip over any data up to the
         given marker.
         """
@@ -376,14 +377,18 @@
         return resp
 
     def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
-        """Retrieve data in binary mode.
+        """Retrieve data in binary mode.  A new port is created for you.
 
-        `cmd' is a RETR command.  `callback' is a callback function is
-        called for each block.  No more than `blocksize' number of
-        bytes will be read from the socket.  Optional `rest' is passed
-        to transfercmd().
+        Args:
+          cmd: A RETR command.
+          callback: A single parameter callable to be called on each
+                    block of data read.
+          blocksize: The maximum number of bytes to read from the
+                     socket at one time.  [default: 8192]
+          rest: Passed to transfercmd().  [default: None]
 
-        A new port is created for you.  Return the response code.
+        Returns:
+          The response code.
         """
         self.voidcmd('TYPE I')
         conn = self.transfercmd(cmd, rest)
@@ -396,11 +401,17 @@
         return self.voidresp()
 
     def retrlines(self, cmd, callback = None):
-        '''Retrieve data in line mode.
-        The argument is a RETR or LIST command.
-        The callback function (2nd argument) is called for each line,
-        with trailing CRLF stripped.  This creates a new port for you.
-        print_line() is the default callback.'''
+        """Retrieve data in line mode.  A new port is created for you.
+
+        Args:
+          cmd: A RETR, LIST, NLST, or MLSD command.
+          callback: An optional single parameter callable that is called
+                    for each line with the trailing CRLF stripped.
+                    [default: print_line()]
+
+        Returns:
+          The response code.
+        """
         if callback is None: callback = print_line
         resp = self.sendcmd('TYPE A')
         conn = self.transfercmd(cmd)
@@ -419,19 +430,42 @@
         conn.close()
         return self.voidresp()
 
-    def storbinary(self, cmd, fp, blocksize=8192):
-        '''Store a file in binary mode.'''
+    def storbinary(self, cmd, fp, blocksize=8192, callback=None):
+        """Store a file in binary mode.  A new port is created for you.
+
+        Args:
+          cmd: A STOR command.
+          fp: A file-like object with a read(num_bytes) method.
+          blocksize: The maximum data size to read from fp and send over
+                     the connection at once.  [default: 8192]
+          callback: An optional single parameter callable that is called on
+                    on each block of data after it is sent.  [default: None]
+
+        Returns:
+          The response code.
+        """
         self.voidcmd('TYPE I')
         conn = self.transfercmd(cmd)
         while 1:
             buf = fp.read(blocksize)
             if not buf: break
             conn.sendall(buf)
+            if callback: callback(buf)
         conn.close()
         return self.voidresp()
 
-    def storlines(self, cmd, fp):
-        '''Store a file in line mode.'''
+    def storlines(self, cmd, fp, callback=None):
+        """Store a file in line mode.  A new port is created for you.
+
+        Args:
+          cmd: A STOR command.
+          fp: A file-like object with a readline() method.
+          callback: An optional single parameter callable that is called on
+                    on each line after it is sent.  [default: None]
+
+        Returns:
+          The response code.
+        """
         self.voidcmd('TYPE A')
         conn = self.transfercmd(cmd)
         while 1:
@@ -441,6 +475,7 @@
                 if buf[-1] in CRLF: buf = buf[:-1]
                 buf = buf + CRLF
             conn.sendall(buf)
+            if callback: callback(buf)
         conn.close()
         return self.voidresp()
 
@@ -505,7 +540,7 @@
 
     def size(self, filename):
         '''Retrieve the size of a file.'''
-        # Note that the RFC doesn't say anything about 'SIZE'
+        # The SIZE command is defined in RFC-3659
         resp = self.sendcmd('SIZE ' + filename)
         if resp[:3] == '213':
             s = resp[3:].strip()
diff --git a/Lib/pprint.py b/Lib/pprint.py
index 6449868..09b4a9f 100644
--- a/Lib/pprint.py
+++ b/Lib/pprint.py
@@ -159,11 +159,24 @@
                 write('}')
                 return
 
-            if (issubclass(typ, list) and r is list.__repr__) or \
-               (issubclass(typ, tuple) and r is tuple.__repr__):
+            if ((issubclass(typ, list) and r is list.__repr__) or
+                (issubclass(typ, tuple) and r is tuple.__repr__) or
+                (issubclass(typ, set) and r is set.__repr__) or
+                (issubclass(typ, frozenset) and r is frozenset.__repr__)
+               ):
                 if issubclass(typ, list):
                     write('[')
                     endchar = ']'
+                elif issubclass(typ, set):
+                    write('{')
+                    endchar = '}'
+                    object = sorted(object)
+                    indent += 4
+                elif issubclass(typ, frozenset):
+                    write('frozenset([')
+                    endchar = '])'
+                    object = sorted(object)
+                    indent += 9
                 else:
                     write('(')
                     endchar = ')'
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index d5fb91b..0542fa5 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -1055,9 +1055,11 @@
             if visiblename(key, all):
                 data.append((key, value))
 
+        modpkgs = []
+        modpkgs_names = set()
         if hasattr(object, '__path__'):
-            modpkgs = []
             for importer, modname, ispkg in pkgutil.iter_modules(object.__path__):
+                modpkgs_names.add(modname)
                 if ispkg:
                     modpkgs.append(modname + ' (package)')
                 else:
@@ -1067,6 +1069,16 @@
             result = result + self.section(
                 'PACKAGE CONTENTS', '\n'.join(modpkgs))
 
+        # Detect submodules as sometimes created by C extensions
+        submodules = []
+        for key, value in inspect.getmembers(object, inspect.ismodule):
+            if value.__name__.startswith(name + '.') and key not in modpkgs_names:
+                submodules.append(key)
+        if submodules:
+            submodules.sort()
+            result = result + self.section(
+                'SUBMODULES', join(submodules, '\n'))
+
         if classes:
             classlist = [value for key, value in classes]
             contents = [self.formattree(
diff --git a/Lib/site.py b/Lib/site.py
index 56af90e..fc68317 100644
--- a/Lib/site.py
+++ b/Lib/site.py
@@ -96,6 +96,8 @@
     (especially for Guido :-)"""
     from distutils.util import get_platform
     s = "build/lib.%s-%.3s" % (get_platform(), sys.version)
+    if hasattr(sys, 'gettotalrefcount'):
+        s += '-pydebug'
     s = os.path.join(os.path.dirname(sys.path[-1]), s)
     sys.path.append(s)
 
diff --git a/Lib/test/pydocfodder.py b/Lib/test/pydocfodder.py
index 0ae013b..2530320 100644
--- a/Lib/test/pydocfodder.py
+++ b/Lib/test/pydocfodder.py
@@ -1,5 +1,7 @@
 """Something just to look at via pydoc."""
 
+import types
+
 class A_classic:
     "A classic class."
     def A_method(self):
@@ -208,3 +210,7 @@
             del inst.desc[self.attr]
 
     x = property(get_desc('x'), set_desc('x'), del_desc('x'), 'prop x')
+
+
+submodule = types.ModuleType(__name__ + '.submodule',
+    """A submodule, which should appear in its parent's summary""")
diff --git a/Lib/test/test_grp.py b/Lib/test/test_grp.py
index 24b3f00..fb607f0 100755
--- a/Lib/test/test_grp.py
+++ b/Lib/test/test_grp.py
@@ -25,6 +25,9 @@
         for e in entries:
             self.check_value(e)
 
+        if len(entries) > 1000:  # Huge group file (NIS?) -- skip the rest
+            return
+
         for e in entries:
             e2 = grp.getgrgid(e.gr_gid)
             self.check_value(e2)
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index 5bf7eb0..f6ee371 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -419,6 +419,13 @@
             except OSError:
                 pass
 
+    def test_subclass(self):
+        class anon_mmap(mmap.mmap):
+            def __new__(klass, *args, **kwargs):
+                return mmap.mmap.__new__(klass, -1, *args, **kwargs)
+        anon_mmap(PAGESIZE)
+
+
 def test_main():
     run_unittest(MmapTests)
 
diff --git a/Lib/test/test_pwd.py b/Lib/test/test_pwd.py
index 358b8b3..19187a3 100644
--- a/Lib/test/test_pwd.py
+++ b/Lib/test/test_pwd.py
@@ -35,6 +35,9 @@
             entriesbyname.setdefault(e.pw_name, []).append(e)
             entriesbyuid.setdefault(e.pw_uid, []).append(e)
 
+        if len(entries) > 1000:  # Huge passwd file (NIS?) -- skip the rest
+            return
+
         # check whether the entry returned by getpwuid()
         # for each uid is among those from getpwall() for this uid
         for e in entries:
diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py
index 93d7bfb..27b4b70 100644
--- a/Lib/test/test_structmembers.py
+++ b/Lib/test/test_structmembers.py
@@ -8,52 +8,59 @@
 import warnings, unittest, sys
 from test import test_support
 
-ts=test_structmembersType(1,2,3,4,5,6,7,8,9.99999,10.1010101010)
+ts=test_structmembersType(False, 1, 2, 3, 4, 5, 6, 7, 8,
+                          9.99999, 10.1010101010)
 
 class ReadWriteTests(unittest.TestCase):
     def test_types(self):
-        ts.T_BYTE=CHAR_MAX
+        ts.T_BOOL = True
+        self.assertEquals(ts.T_BOOL, True)
+        ts.T_BOOL = False
+        self.assertEquals(ts.T_BOOL, False)
+        self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1)
+
+        ts.T_BYTE = CHAR_MAX
         self.assertEquals(ts.T_BYTE, CHAR_MAX)
-        ts.T_BYTE=CHAR_MIN
+        ts.T_BYTE = CHAR_MIN
         self.assertEquals(ts.T_BYTE, CHAR_MIN)
-        ts.T_UBYTE=UCHAR_MAX
+        ts.T_UBYTE = UCHAR_MAX
         self.assertEquals(ts.T_UBYTE, UCHAR_MAX)
 
-        ts.T_SHORT=SHRT_MAX
+        ts.T_SHORT = SHRT_MAX
         self.assertEquals(ts.T_SHORT, SHRT_MAX)
-        ts.T_SHORT=SHRT_MIN
+        ts.T_SHORT = SHRT_MIN
         self.assertEquals(ts.T_SHORT, SHRT_MIN)
-        ts.T_USHORT=USHRT_MAX
+        ts.T_USHORT = USHRT_MAX
         self.assertEquals(ts.T_USHORT, USHRT_MAX)
 
-        ts.T_INT=INT_MAX
+        ts.T_INT = INT_MAX
         self.assertEquals(ts.T_INT, INT_MAX)
-        ts.T_INT=INT_MIN
+        ts.T_INT = INT_MIN
         self.assertEquals(ts.T_INT, INT_MIN)
-        ts.T_UINT=UINT_MAX
+        ts.T_UINT = UINT_MAX
         self.assertEquals(ts.T_UINT, UINT_MAX)
 
-        ts.T_LONG=LONG_MAX
+        ts.T_LONG = LONG_MAX
         self.assertEquals(ts.T_LONG, LONG_MAX)
-        ts.T_LONG=LONG_MIN
+        ts.T_LONG = LONG_MIN
         self.assertEquals(ts.T_LONG, LONG_MIN)
-        ts.T_ULONG=ULONG_MAX
+        ts.T_ULONG = ULONG_MAX
         self.assertEquals(ts.T_ULONG, ULONG_MAX)
 
         ## T_LONGLONG and T_ULONGLONG may not be present on some platforms
         if hasattr(ts, 'T_LONGLONG'):
-            ts.T_LONGLONG=LLONG_MAX
+            ts.T_LONGLONG = LLONG_MAX
             self.assertEquals(ts.T_LONGLONG, LLONG_MAX)
-            ts.T_LONGLONG=LLONG_MIN
+            ts.T_LONGLONG = LLONG_MIN
             self.assertEquals(ts.T_LONGLONG, LLONG_MIN)
 
-            ts.T_ULONGLONG=ULLONG_MAX
+            ts.T_ULONGLONG = ULLONG_MAX
             self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX)
 
             ## make sure these will accept a plain int as well as a long
-            ts.T_LONGLONG=3
+            ts.T_LONGLONG = 3
             self.assertEquals(ts.T_LONGLONG, 3)
-            ts.T_ULONGLONG=4
+            ts.T_ULONGLONG = 4
             self.assertEquals(ts.T_ULONGLONG, 4)
 
 
@@ -63,32 +70,32 @@
 
     def test_byte_max(self):
         with test_support.catch_warning() as w:
-            ts.T_BYTE=CHAR_MAX+1
+            ts.T_BYTE = CHAR_MAX+1
             self.has_warned(w)
 
     def test_byte_min(self):
         with test_support.catch_warning() as w:
-            ts.T_BYTE=CHAR_MIN-1
+            ts.T_BYTE = CHAR_MIN-1
             self.has_warned(w)
 
     def test_ubyte_max(self):
         with test_support.catch_warning() as w:
-            ts.T_UBYTE=UCHAR_MAX+1
+            ts.T_UBYTE = UCHAR_MAX+1
             self.has_warned(w)
 
     def test_short_max(self):
         with test_support.catch_warning() as w:
-            ts.T_SHORT=SHRT_MAX+1
+            ts.T_SHORT = SHRT_MAX+1
             self.has_warned(w)
 
     def test_short_min(self):
         with test_support.catch_warning() as w:
-            ts.T_SHORT=SHRT_MIN-1
+            ts.T_SHORT = SHRT_MIN-1
             self.has_warned(w)
 
     def test_ushort_max(self):
         with test_support.catch_warning() as w:
-            ts.T_USHORT=USHRT_MAX+1
+            ts.T_USHORT = USHRT_MAX+1
             self.has_warned(w)
 
 
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 5dd3aea..1ce5950 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -236,6 +236,24 @@
             """])
         self.assertEqual(rc, 42)
 
+    def test_enumerate_after_join(self):
+        # Try hard to trigger #1703448: a thread is still returned in
+        # threading.enumerate() after it has been join()ed.
+        enum = threading.enumerate
+        old_interval = sys.getcheckinterval()
+        sys.setcheckinterval(1)
+        try:
+            for i in range(1, 1000):
+                t = threading.Thread(target=lambda: None)
+                t.start()
+                t.join()
+                l = enum()
+                self.assertFalse(t in l,
+                    "#1703448 triggered after %d trials: %s" % (i, l))
+        finally:
+            sys.setcheckinterval(old_interval)
+
+
 class ThreadingExceptionTests(unittest.TestCase):
     # A RuntimeError should be raised if Thread.start() is called
     # multiple times.
diff --git a/Lib/threading.py b/Lib/threading.py
index ce95e40..9bd112d 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -346,27 +346,18 @@
         return self._flag
 
     def set(self):
-        self._cond.acquire()
-        try:
+        with self._cond:
             self._flag = True
             self._cond.notifyAll()
-        finally:
-            self._cond.release()
 
     def clear(self):
-        self._cond.acquire()
-        try:
+        with self._cond:
             self._flag = False
-        finally:
-            self._cond.release()
 
     def wait(self, timeout=None):
-        self._cond.acquire()
-        try:
+        with self._cond:
             if not self._flag:
                 self._cond.wait(timeout)
-        finally:
-            self._cond.release()
 
 # Helper to generate new thread names
 _counter = 0
@@ -523,17 +514,19 @@
                 if __debug__:
                     self._note("%s.__bootstrap(): normal return", self)
         finally:
-            self._stop()
-            try:
-                self._delete()
-            except:
-                pass
+            with _active_limbo_lock:
+                self._stop()
+                try:
+                    # We don't call self.__delete() because it also
+                    # grabs _active_limbo_lock.
+                    del _active[_get_ident()]
+                except:
+                    pass
 
     def _stop(self):
-        self._block.acquire()
-        self._stopped = True
-        self._block.notifyAll()
-        self._block.release()
+        with self._block:
+            self._stopped = True
+            self._block.notifyAll()
 
     def _delete(self):
         "Remove current thread from the dict of currently running threads."
@@ -559,15 +552,12 @@
         # since it isn't if dummy_threading is *not* being used then don't
         # hide the exception.
 
-        _active_limbo_lock.acquire()
-        try:
+        with _active_limbo_lock:
             try:
                 del _active[_get_ident()]
             except KeyError:
                 if 'dummy_threading' not in _sys.modules:
                     raise
-        finally:
-            _active_limbo_lock.release()
 
     def join(self, timeout=None):
         if not self._initialized:
@@ -580,8 +570,7 @@
         if __debug__:
             if not self._stopped:
                 self._note("%s.join(): waiting until thread stops", self)
-        self._block.acquire()
-        try:
+        with self._block:
             if timeout is None:
                 while not self._stopped:
                     self._block.wait()
@@ -599,8 +588,6 @@
                 else:
                     if __debug__:
                         self._note("%s.join(): thread stopped", self)
-        finally:
-            self._block.release()
 
     def getName(self):
         assert self._initialized, "Thread.__init__() not called"