For backwards compatibility, simply import everything from the

_exceptions module, including __doc__.

1 files changed, 4 insertions, 247 deletions

diff --git a/Lib/exceptions.py b/Lib/exceptions.py
index 43d1c2d..dd82592 100644
--- a/Lib/exceptions.py
+++ b/Lib/exceptions.py
@@ -1,247 +1,4 @@
-"""Class based built-in exception hierarchy.
-
-New with Python 1.5, all standard built-in exceptions are now class objects by
-default.  This gives Python's exception handling mechanism a more
-object-oriented feel.  Traditionally they were string objects.  Python will
-fallback to string based exceptions if the interpreter is invoked with the -X
-option, or if some failure occurs during class exception initialization (in
-this case a warning will be printed).
-
-Most existing code should continue to work with class based exceptions.  Some
-tricky uses of IOError may break, but the most common uses should work.
-
-Here is a rundown of the class hierarchy.  You can change this by editing this
-file, but it isn't recommended because the old string based exceptions won't
-be kept in sync.  The class names described here are expected to be found by
-the bltinmodule.c file.  If you add classes here, you must modify
-bltinmodule.c or the exceptions won't be available in the __builtin__ module,
-nor will they be accessible from C.
-
-The classes with a `*' are new since Python 1.5.  They are defined as tuples
-containing the derived exceptions when string-based exceptions are used.  If
-you define your own class based exceptions, they should be derived from
-Exception.
-
-Exception(*)
- |
- +-- SystemExit
- +-- StandardError(*)
-      |
-      +-- KeyboardInterrupt
-      +-- ImportError
-      +-- EnvironmentError(*)
-      |    |
-      |    +-- IOError
-      |    +-- OSError(*)
-      |         |
-      |         +-- WindowsError(*)
-      |
-      +-- EOFError
-      +-- RuntimeError
-      |    |
-      |    +-- NotImplementedError(*)
-      |
-      +-- NameError
-      |    |
-      |    +-- UnboundLocalError(*)
-      |
-      +-- AttributeError
-      +-- SyntaxError
-      +-- TypeError
-      +-- AssertionError
-      +-- LookupError(*)
-      |    |
-      |    +-- IndexError
-      |    +-- KeyError
-      |
-      +-- ArithmeticError(*)
-      |    |
-      |    +-- OverflowError
-      |    +-- ZeroDivisionError
-      |    +-- FloatingPointError
-      |
-      +-- ValueError
-      |    |
-      |    +-- UnicodeError(*)
-      |
-      +-- SystemError
-      +-- MemoryError
-"""
-
-class Exception:
-    """Proposed base class for all exceptions."""
-    def __init__(self, *args):
-        self.args = args
-
-    def __str__(self):
-        if not self.args:
-            return ''
-        elif len(self.args) == 1:
-            return str(self.args[0])
-        else:
-            return str(self.args)
-
-    def __getitem__(self, i):
-        return self.args[i]
-
-class StandardError(Exception):
-    """Base class for all standard Python exceptions."""
-    pass
-
-class SyntaxError(StandardError):
-    """Invalid syntax."""
-    filename = lineno = offset = text = None
-    msg = ""
-    def __init__(self, *args):
-        self.args = args
-        if len(self.args) >= 1:
-            self.msg = self.args[0]
-        if len(self.args) == 2:
-            info = self.args[1]
-            try:
-                self.filename, self.lineno, self.offset, self.text = info
-            except:
-                pass
-    def __str__(self):
-        return str(self.msg)
-
-class EnvironmentError(StandardError):
-    """Base class for I/O related errors."""
-    def __init__(self, *args):
-        self.args = args
-        self.errno = None
-        self.strerror = None
-        self.filename = None
-        if len(args) == 3:
-            # open() errors give third argument which is the filename.  BUT,
-            # so common in-place unpacking doesn't break, e.g.:
-            #
-            # except IOError, (errno, strerror):
-            #
-            # we hack args so that it only contains two items.  This also
-            # means we need our own __str__() which prints out the filename
-            # when it was supplied.
-            self.errno, self.strerror, self.filename = args
-            self.args = args[0:2]
-        if len(args) == 2:
-            # common case: PyErr_SetFromErrno()
-            self.errno, self.strerror = args
-
-    def __str__(self):
-        if self.filename is not None:
-            return '[Errno %s] %s: %s' % (self.errno, self.strerror,
-                                          repr(self.filename))
-        elif self.errno and self.strerror:
-            return '[Errno %s] %s' % (self.errno, self.strerror)
-        else:
-            return StandardError.__str__(self)
-
-class IOError(EnvironmentError):
-    """I/O operation failed."""
-    pass
-
-class OSError(EnvironmentError):
-    """OS system call failed."""
-    pass
-
-class WindowsError(OSError):
-    """MS-Windows OS system call failed."""
-    pass
-
-class RuntimeError(StandardError):
-    """Unspecified run-time error."""
-    pass
-
-class NotImplementedError(RuntimeError):
-    """Method or function hasn't been implemented yet."""
-    pass
-
-class SystemError(StandardError):
-    """Internal error in the Python interpreter.
-
-    Please report this to the Python maintainer, along with the traceback,
-    the Python version, and the hardware/OS platform and version."""
-    pass
-
-class EOFError(StandardError):
-    """Read beyond end of file."""
-    pass
-
-class ImportError(StandardError):
-    """Import can't find module, or can't find name in module."""
-    pass
-
-class TypeError(StandardError):
-    """Inappropriate argument type."""
-    pass
-
-class ValueError(StandardError):
-    """Inappropriate argument value (of correct type)."""
-    pass
-
-class KeyboardInterrupt(StandardError):
-    """Program interrupted by user."""
-    pass
-
-class AssertionError(StandardError):
-    """Assertion failed."""
-    pass
-
-class ArithmeticError(StandardError):
-    """Base class for arithmetic errors."""
-    pass
-
-class OverflowError(ArithmeticError):
-    """Result too large to be represented."""
-    pass
-
-class FloatingPointError(ArithmeticError):
-    """Floating point operation failed."""
-    pass
-
-class ZeroDivisionError(ArithmeticError):
-    """Second argument to a division or modulo operation was zero."""
-    pass
-
-class LookupError(StandardError):
-    """Base class for lookup errors."""
-    pass
-
-class IndexError(LookupError):
-    """Sequence index out of range."""
-    pass
-
-class KeyError(LookupError):
-    """Mapping key not found."""
-    pass
-
-class AttributeError(StandardError):
-    """Attribute not found."""
-    pass
-
-class NameError(StandardError):
-    """Name not found globally."""
-    pass
-
-class UnboundLocalError(NameError):
-    """Local name referenced but not bound to a value."""
-    pass
-
-class UnicodeError(ValueError):
-    """Unicode related error."""
-    pass
-
-class MemoryError(StandardError):
-    """Out of memory."""
-    pass
-
-class SystemExit(Exception):
-    """Request to exit from the interpreter."""
-    def __init__(self, *args):
-        self.args = args
-        if len(args) == 0:
-            self.code = None
-        elif len(args) == 1:
-            self.code = args[0]
-        else:
-            self.code = args
+# Standard class-base exceptions are now all implemented in C.  This remains
+# for backwards compatibility with pre-1.6 releases.
+from _exceptions import *
+from _exceptions import __doc__