>>> import shutil
>>> help(shutil)
Help on module shutil:

NAME
    shutil - Utility functions for copying files and directory trees.

FILE
    e:\python25\lib\shutil.py

DESCRIPTION
    XXX The functions here don't copy the resource fork or other metadata on Mac.

CLASSES
    exceptions.EnvironmentError(exceptions.StandardError)
        Error
   
    class Error(exceptions.EnvironmentError)
     |  Method resolution order:
     |      Error
     |      exceptions.EnvironmentError
     |      exceptions.StandardError
     |      exceptions.Exception
     |      exceptions.BaseException
     |      __builtin__.object
     |  
     |  Data descriptors defined here:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.EnvironmentError:
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see x.__class__.__doc__ for signature
     |  
     |  __reduce__(...)
     |  
     |  __str__(...)
     |      x.__str__() <==> str(x)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.EnvironmentError:
     |  
     |  errno
     |      exception errno
     |  
     |  filename
     |      exception filename
     |  
     |  message
     |      exception message
     |  
     |  strerror
     |      exception strerror
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from exceptions.EnvironmentError:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x1E1CB2E0>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.BaseException:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  __setstate__(...)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.BaseException:
     |  
     |  __dict__
     |  
     |  args

FUNCTIONS
    copy(src, dst)
        Copy data and mode bits ("cp src dst" ).
       
        The destination may be a directory.
   
    copy2(src, dst)
        Copy data and all stat info ("cp -p src dst" ).
       
        The destination may be a directory.
   
    copyfile(src, dst)
        Copy data from src to dst
   
    copyfileobj(fsrc, fdst, length=16384)
        copy data from file-like object fsrc to file-like object fdst
   
    copymode(src, dst)
        Copy mode bits from src to dst
   
    copystat(src, dst)
        Copy all stat info (mode bits, atime and mtime) from src to dst
   
    copytree(src, dst, symlinks=False)
        Recursively copy a directory tree using copy2().
       
        The destination directory must not already exist.
        If exception(s) occur, an Error is raised with a list of reasons.
       
        If the optional symlinks flag is true, symbolic links in the
        source tree result in symbolic links in the destination tree; if
        it is false, the contents of the files pointed to by symbolic
        links are copied.
       
        XXX Consider this example code rather than the ultimate tool.
   
    move(src, dst)
        Recursively move a file or directory to another location.
       
        If the destination is on our current filesystem, then simply use
        rename.  Otherwise, copy src to the dst and then remove src.
        A lot more could be done here...  A look at a mv.c shows a lot of
        the issues this implementation glosses over.
   
    rmtree(path, ignore_errors=False, onerror=None)
        Recursively delete a directory tree.
       
        If ignore_errors is set, errors are ignored; otherwise, if onerror
        is set, it is called to handle the error with arguments (func,
        path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
        path is the argument to that function that caused it to fail; and
        exc_info is a tuple returned by sys.exc_info().  If ignore_errors
        is false and onerror is None, an exception is raised.

DATA
    __all__ = ['copyfileobj', 'copyfile', 'copymode', 'copystat', 'copy', ...

>>>