On this page:
Inheritance Hierarchy for Exceptions in Python
The mapping for exceptions is based on the inheritance hierarchy shown below:
Inheritance structure for Ice exceptions.
The ancestor of all exceptions is
exceptions.Exception, from which
Ice.Exception is derived.
Ice.UserException are derived from
Ice.Exception and form the base for all run-time and user exceptions.
Python Mapping for User Exceptions
Here is a fragment of the Slice definition for our world time server once more:
These exception definitions map as follows:
Each Slice exception is mapped to a Python class with the same name. The inheritance structure of the Slice exceptions is preserved for the generated classes, so
BadZoneName inherit from
Each exception member corresponds to an attribute of the instance, which the constructor initializes to a default value appropriate for its type. You can also declare different default values for members of primitive and enumerated types. For derived exceptions, the constructor has one parameter for each of the base exception's data members, plus one parameter for each of the derived exception's data members, in base-to-derived order. As an example, although
BadZoneName do not declare data members, their constructors still accept a value for the inherited data member
reason in order to pass it to the constructor of the base exception
Optional data members use the same mapping as required data members, but an optional data member can also be set to the marker value
Ice.Unset to indicate that the member is unset. A well-behaved program must compare an optional data member to
Ice.Unset before using the member's value:
Each exception also defines the
ice_name method to return the name of the exception, and the special method
__str__ to return a stringified representation of the exception and its members.
All user exceptions are derived from the base class
Ice.UserException. This allows you to catch all user exceptions generically by installing a handler for
Ice.UserException. Similarly, you can catch all Ice run-time exceptions with a handler for
Ice.LocalException, and you can catch all Ice exceptions with a handler for
Python Mapping for Run-Time Exceptions
The Ice run time throws run-time exceptions for a number of pre-defined error conditions. All run-time exceptions directly or indirectly derive from
Ice.LocalException (which, in turn, derives from
By catching exceptions at the appropriate point in the inheritance hierarchy, you can handle exceptions according to the category of error they indicate:
This is the root of the inheritance tree for run-time exceptions.
This is the root of the inheritance tree for user exceptions.
This is the base exception for both operation-invocation and connection-establishment timeouts.
This exception is raised when the initial attempt to establish a connection to a server times out.
For example, a
ConnectTimeoutException can be handled as
You will probably have little need to catch run-time exceptions as their most-derived type and instead catch them as
LocalException; the fine-grained error handling offered by the remainder of the hierarchy is of interest mainly in the implementation of the Ice run time. Exceptions to this rule are the exceptions related to facet and object life cycles, which you may want to catch explicitly. These exceptions are
- User Exceptions
- Run-Time Exceptions
- Python Mapping for Identifiers
- Python Mapping for Modules
- Python Mapping for Built-In Types
- Python Mapping for Enumerations
- Python Mapping for Structures
- Python Mapping for Sequences
- Python Mapping for Dictionaries
- Python Mapping for Constants
- Optional Data Members
- Facets and Versioning
- Object Life Cycle