[Python-checkins] CVS: python/dist/src/Lib exceptions.py,1.18,1.19
Barry Warsaw
python-dev@python.org
Thu, 25 May 2000 16:15:54 -0700
Update of /cvsroot/python/python/dist/src/Lib
In directory slayer.i.sourceforge.net:/tmp/cvs-serv25262
Modified Files:
exceptions.py
Log Message:
For backwards compatibility, simply import everything from the
_exceptions module, including __doc__.
Index: exceptions.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/exceptions.py,v
retrieving revision 1.18
retrieving revision 1.19
diff -C2 -r1.18 -r1.19
*** exceptions.py 2000/03/10 23:16:02 1.18
--- exceptions.py 2000/05/25 23:15:52 1.19
***************
*** 1,247 ****
! """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
--- 1,4 ----
! # 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__