diff -r dde10d04b60f Doc/library/pkgutil.rst
--- a/Doc/library/pkgutil.rst	Sat Jul 24 04:24:55 2010 +0200
+++ b/Doc/library/pkgutil.rst	Sat Jul 24 21:58:24 2010 -0700
@@ -8,6 +8,23 @@
 This module provides functions to manipulate packages:
 
 
+.. class:: ImpImporter
+
+   :pep:`302` Importer that wraps Python's "classic" import algorithm.
+
+   :class:`ImpImporter(dirname)` produces a :pep:`302` importer that
+   searches that directory. :class:`ImpImporter(None)` produces a
+   :pep:`302` importer that searches the current ``sys.path``, plus
+   any modules that are frozen or built-in.
+
+   Note that ImpImporter does not currently support being used by
+   placement on ``sys.meta_path``.
+   
+.. class:: ImpLoader
+
+   :pep:`302` Loader that wraps Python's "classic" import algorithm.
+
+
 .. function:: extend_path(path, name)
 
    Extend the search path for the modules which comprise a package. Intended use is
@@ -37,6 +54,121 @@
    ``sys.path`` that cause errors when used as filenames may cause this function
    to raise an exception (in line with :func:`os.path.isdir` behavior).
 
+
+.. function:: find_loader(fullname)
+
+   Find a :pep:`302` "loader" object for fullname
+        
+   If fullname contains dots, path must be the containing package's
+   ``__path__``.  Returns None if the module cannot be found or
+   imported. This function uses :func:`iter_importers`, and is thus
+   subject to the same limitations regarding platform-specific special
+   import locations such as the Windows registry.
+
+
+.. function:: get_importer(path_item)
+
+   Retrieve a :pep:`302` importer for the given path item
+        
+   The returned importer is cached in ``sys.path_importer_cache`` if
+   it was newly created by a path hook.
+        
+   If there is no importer, a wrapper around the basic import
+   machinery is returned. This wrapper is never inserted into the
+   importer cache (None is inserted instead).
+        
+   The cache (or part of it) can be cleared manually if a rescan of
+   sys.path_hooks is necessary.
+    
+
+.. function:: get_loader(module_or_name)
+
+   Get a :pep:`302` "loader" object for module_or_name
+        
+   If the module or package is accessible via the normal import
+   mechanism, a wrapper around the relevant part of that machinery is
+   returned.  Returns None if the module cannot be found or imported.
+   If the named module is not already imported, its containing package
+   (if any) is imported, in order to establish the package
+   ``__path__``.
+        
+   This function uses :func:`iter_importers`, and is thus subject to
+   the same limitations regarding platform-specific special import
+   locations such as the Windows registry.
+  
+  
+.. function:: iter_importers(fullname='')
+
+   Yield :pep:`302` importers for the given module name
+        
+   If fullname contains a '.', the importers will be for the package
+   containing fullname, otherwise they will be importers for
+   ``sys.meta_path``, ``sys.path``, and Python's "classic" import
+   machinery, in that order.  If the named module is in a package,
+   that package is imported as a side effect of invoking this
+   function.
+        
+   Non :pep:`302` mechanisms (e.g. the Windows registry) used by the
+   standard import machinery to find files in alternative locations
+   are partially supported, but are searched AFTER
+   ``sys.path``. Normally, these locations are searched BEFORE
+   ``sys.path``, preventing ``sys.path`` entries from shadowing them.
+        
+   For this to cause a visible difference in behaviour, there must be
+   a module or package name that is accessible via both ``sys.path``
+   and one of the non :pep:`302` file system mechanisms. In this case,
+   the emulation will find the former version, while the builtin
+   import mechanism will find the latter.
+        
+   Items of the following types can be affected by this discrepancy:
+      ``imp.C_EXTENSION``, ``imp.PY_SOURCE``, ``imp.PY_COMPILED``,
+      ``imp.PKG_DIRECTORY``
+    
+.. function:: iter_modules(path=None, prefix='')
+
+   Yields (``module_loader``, ``name``, ``ispkg``) for all submodules
+   on path, or, if path is ``None``, all top-level modules on
+   ``sys.path``.
+        
+   ``path`` should be either ``None`` or a list of paths to look for
+   modules in.
+        
+   ``prefix`` is a string to output on the front of every module name
+   on output.
+    
+.. function:: read_code(stream)
+    
+.. function:: walk_packages(path=None, prefix='', onerror=None)
+
+   Yields (``module_loader``, ``name``, ``ispkg``) for all modules
+   recursively on path, or, if path is ``None``, all accessible
+   modules.
+        
+   ``path`` should be either ``None`` or a list of paths to look for
+   modules in.
+        
+   ``prefix`` is a string to output on the front of every module name
+   on output.
+        
+   Note that this function must import all *packages* (NOT all
+   modules!) on the given path, in order to access the ``__path__``
+   attribute to find submodules.
+        
+   ``onerror`` is a function which gets called with one argument (the
+   name of the package which was being imported) if any exception
+   occurs while trying to import a package.  If no onerror function is
+   supplied, ImportErrors are caught and ignored, while all other
+   exceptions are propagated, terminating the search.
+        
+   Examples::
+        
+        # list all modules python can access
+        walk_packages()
+        
+        # list all submodules of ctypes
+        walk_packages(ctypes.__path__, ctypes.__name__+'.')
+
+
 .. function:: get_data(package, resource)
 
    Get a resource from a package.