def load(val, import_custom_exceptions, instantiate_custom_exceptions,
instantiate_oldstyle_exceptions):
if val == consts.EXC_STOP_ITERATION:
return StopIteration # optimization
if type(val) is str:
return val # deprecated string exceptions
(modname, clsname), args, attrs, tbtext = val
if import_custom_exceptions and modname not in sys.modules:
try:
mod = __import__(modname, None, None, "*")
except ImportError:
pass
if instantiate_custom_exceptions:
cls = getattr(sys.modules[modname], clsname, None)
elif modname == "exceptions":
cls = getattr(exceptions, clsname, None)
else:
cls = None
if not isinstance(cls, (type, ClassType)):
cls = None
elif issubclass(cls, ClassType) and not instantiate_oldstyle_exceptions:
cls = None
elif not issubclass(cls, BaseException):
cls = None
if cls is None:
fullname = "%s.%s" % (modname, clsname)
if fullname not in _generic_exceptions_cache:
fakemodule = {"__module__": "%s.%s" % (__name__, modname)}
if isinstance(GenericException, ClassType):
_generic_exceptions_cache[fullname] = ClassType(
fullname, (GenericException, ), fakemodule)
else:
_generic_exceptions_cache[fullname] = type(
fullname, (GenericException, ), fakemodule)
cls = _generic_exceptions_cache[fullname]
# support old-style exception classes
if isinstance(cls, ClassType):
exc = InstanceType(cls)
else:
exc = cls.__new__(cls)
exc.args = args
for name, attrval in attrs:
setattr(exc, name, attrval)
if hasattr(exc, "_remote_tb"):
exc._remote_tb += (tbtext, )
else:
exc._remote_tb = (tbtext, )
return exc
def load(val, import_custom_exceptions, instantiate_custom_exceptions,
instantiate_oldstyle_exceptions):
if val == consts.EXC_STOP_ITERATION:
return StopIteration # optimization
if type(val) is str:
return val # deprecated string exceptions
(modname, clsname), args, attrs, tbtext = val
if import_custom_exceptions and modname not in sys.modules:
try:
mod = __import__(modname, None, None, "*")
except ImportError:
pass
if instantiate_custom_exceptions:
cls = getattr(sys.modules[modname], clsname, None)
elif modname == "exceptions":
cls = getattr(exceptions, clsname, None)
else:
cls = None
if not isinstance(cls, (type, ClassType)):
cls = None
elif issubclass(cls, ClassType) and not instantiate_oldstyle_exceptions:
cls = None
elif not issubclass(cls, BaseException):
cls = None
if cls is None:
fullname = "%s.%s" % (modname, clsname)
if fullname not in _generic_exceptions_cache:
fakemodule = {"__module__" : "%s.%s" % (__name__, modname)}
if isinstance(GenericException, ClassType):
_generic_exceptions_cache[fullname] = ClassType(fullname, (GenericException,), fakemodule)
else:
_generic_exceptions_cache[fullname] = type(fullname, (GenericException,), fakemodule)
cls = _generic_exceptions_cache[fullname]
# support old-style exception classes
if isinstance(cls, ClassType):
exc = InstanceType(cls)
else:
exc = cls.__new__(cls)
exc.args = args
for name, attrval in attrs:
setattr(exc, name, attrval)
if hasattr(exc, "_remote_tb"):
exc._remote_tb += (tbtext,)
else:
exc._remote_tb = (tbtext,)
return exc
def _newInstance(cls, state=_NO_STATE):
"""
Make a new instance of a class without calling its __init__ method.
Supports both new- and old-style classes.
@param state: A C{dict} used to update C{inst.__dict__} or C{_NO_STATE}
to skip this part of initialization.
@return: A new instance of C{cls}.
"""
if not isinstance(cls, types.ClassType):
# new-style
inst = cls.__new__(cls)
if state is not _NO_STATE:
inst.__dict__.update(state) # Copy 'instance' behaviour
else:
if state is not _NO_STATE:
inst = InstanceType(cls, state)
else:
inst = InstanceType(cls)
return inst
def load(val, import_custom_exceptions, instantiate_custom_exceptions,
instantiate_oldstyle_exceptions):
"""
Loads a dumped exception (the tuple returned by :func:`dump`) info a
throwable exception object. If the exception cannot be instantiated for any
reason (i.e., the security parameters do not allow it, or the exception
class simply doesn't exist on the local machine), a :class:`GenericException`
instance will be returned instead, containing all of the original exception's
details.
:param val: the dumped exception
:param import_custom_exceptions: whether to allow this function to import custom modules
(imposes a security risk)
:param instantiate_custom_exceptions: whether to allow this function to instantiate "custom
exceptions" (i.e., not one of the built-in exceptions,
such as ``ValueError``, ``OSError``, etc.)
:param instantiate_oldstyle_exceptions: whether to allow this function to instantiate exception
classes that do not derive from ``BaseException``.
This is required to support old-style exceptions.
Not applicable for Python 3 and above.
:returns: A throwable exception object
"""
if val == consts.EXC_STOP_ITERATION:
return StopIteration # optimization
if type(val) is str:
return val # deprecated string exceptions
(modname, clsname), args, attrs, tbtext = val
if import_custom_exceptions and modname not in sys.modules:
try:
__import__(modname, None, None, "*")
except Exception:
pass
if instantiate_custom_exceptions:
if modname in sys.modules:
cls = getattr(sys.modules[modname], clsname, None)
else:
cls = None
elif modname == exceptions_module.__name__:
cls = getattr(exceptions_module, clsname, None)
else:
cls = None
if is_py3k:
if not isinstance(cls, type) or not issubclass(cls, BaseException):
cls = None
else:
if not isinstance(cls, (type, ClassType)):
cls = None
elif issubclass(cls,
ClassType) and not instantiate_oldstyle_exceptions:
cls = None
elif not issubclass(cls, BaseException):
cls = None
if cls is None:
fullname = "%s.%s" % (modname, clsname)
# py2: `type()` expects `str` not `unicode`!
fullname = str(fullname)
if fullname not in _generic_exceptions_cache:
fakemodule = {"__module__": "%s/%s" % (__name__, modname)}
if isinstance(GenericException, ClassType):
_generic_exceptions_cache[fullname] = ClassType(
fullname, (GenericException, ), fakemodule)
else:
_generic_exceptions_cache[fullname] = type(
fullname, (GenericException, ), fakemodule)
cls = _generic_exceptions_cache[fullname]
cls = _get_exception_class(cls)
# support old-style exception classes
if ClassType is not type and isinstance(cls, ClassType):
exc = InstanceType(cls)
else:
exc = cls.__new__(cls)
exc.args = args
for name, attrval in attrs:
try:
setattr(exc, name, attrval)
except AttributeError: # handle immutable attrs (@property)
pass
exc._remote_tb = tbtext
return exc
def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantiate_oldstyle_exceptions):
"""
Loads a dumped exception (the tuple returned by :func:`dump`) info a
throwable exception object. If the exception cannot be instantiated for any
reason (i.e., the security parameters do not allow it, or the exception
class simply doesn't exist on the local machine), a :class:`GenericException`
instance will be returned instead, containing all of the original exception's
details.
:param val: the dumped exception
:param import_custom_exceptions: whether to allow this function to import custom modules
(imposes a security risk)
:param instantiate_custom_exceptions: whether to allow this function to instantiate "custom
exceptions" (i.e., not one of the built-in exceptions,
such as ``ValueError``, ``OSError``, etc.)
:param instantiate_oldstyle_exceptions: whether to allow this function to instantiate exception
classes that do not derive from ``BaseException``.
This is required to support old-style exceptions.
Not applicable for Python 3 and above.
:returns: A throwable exception object
"""
if val == consts.EXC_STOP_ITERATION:
return StopIteration # optimization
if type(val) is str:
return val # deprecated string exceptions
(modname, clsname), args, attrs, tbtext = val
if import_custom_exceptions and modname not in sys.modules:
try:
__import__(modname, None, None, "*")
except ImportError:
pass
if instantiate_custom_exceptions:
if modname in sys.modules:
cls = getattr(sys.modules[modname], clsname, None)
else:
cls = None
elif modname == exceptions_module.__name__:
cls = getattr(exceptions_module, clsname, None)
else:
cls = None
if is_py3k:
if not isinstance(cls, type) or not issubclass(cls, BaseException):
cls = None
else:
if not isinstance(cls, (type, ClassType)):
cls = None
elif issubclass(cls, ClassType) and not instantiate_oldstyle_exceptions:
cls = None
elif not issubclass(cls, BaseException):
cls = None
if cls is None:
fullname = "%s.%s" % (modname, clsname)
if fullname not in _generic_exceptions_cache:
fakemodule = {"__module__" : "%s/%s" % (__name__, modname)}
if isinstance(GenericException, ClassType):
_generic_exceptions_cache[fullname] = ClassType(fullname, (GenericException,), fakemodule)
else:
_generic_exceptions_cache[fullname] = type(fullname, (GenericException,), fakemodule)
cls = _generic_exceptions_cache[fullname]
cls = _get_exception_class(cls)
# support old-style exception classes
if ClassType is not type and isinstance(cls, ClassType):
exc = InstanceType(cls)
else:
exc = cls.__new__(cls)
exc.args = args
for name, attrval in attrs:
setattr(exc, name, attrval)
exc._remote_tb = tbtext
return exc