Ausnahme erneut mit einem anderen Typ und einer anderen Nachricht auslösen, wobei vorhandene Informationen erhalten bleiben

Ich schreibe ein Modul und möchte eine einheitliche Ausnahmehierarchie für die Ausnahmen haben, die es auslösen kann (z. B. Erben von einer FooErrorabstrakten Klasse für alle foospezifischen Ausnahmen des Moduls). Auf diese Weise können Benutzer des Moduls diese bestimmten Ausnahmen abfangen und bei Bedarf eindeutig behandeln. Viele der vom Modul ausgelösten Ausnahmen werden jedoch aufgrund einer anderen Ausnahme ausgelöst. z. B. Fehler bei einer Aufgabe aufgrund eines OSError in einer Datei.

Was ich brauche, ist, die gefangene Ausnahme so zu "verpacken", dass sie einen anderen Typ und eine andere Nachricht hat , so dass Informationen weiter oben in der Propagierungshierarchie verfügbar sind, je nachdem, was die Ausnahme abfängt. Aber ich möchte den vorhandenen Typ, die Nachricht und den Stack-Trace nicht verlieren. Das sind alles nützliche Informationen für jemanden, der versucht, das Problem zu beheben. Ein Ausnahmebehandler der obersten Ebene ist nicht gut, da ich versuche, die Ausnahme zu dekorieren, bevor sie den Propagierungsstapel weiter nach oben führt, und der Handler der obersten Ebene zu spät ist.

Dies wird teilweise dadurch gelöst, dass die foospezifischen Ausnahmetypen meines Moduls vom vorhandenen Typ abgeleitet werden (z. B. class FooPermissionError(OSError, FooError)). Dies macht es jedoch nicht einfacher, die vorhandene Ausnahmeinstanz in einen neuen Typ zu packen oder die Nachricht zu ändern.

In Pythons PEP 3134 „Ausnahmekettung und eingebettete Tracebacks“ wird eine in Python 3.0 akzeptierte Änderung für die Verkettung von Ausnahmeobjekten erläutert, um anzuzeigen, dass während der Behandlung einer vorhandenen Ausnahme eine neue Ausnahme ausgelöst wurde.

Was ich versuche zu tun, ist verwandt: Ich brauche es auch in früheren Python-Versionen, und ich brauche es nicht zum Verketten, sondern nur für Polymorphismus. Was ist der richtige Weg, um dies zu tun?

Python 3 führte eine Ausnahmeverkettung ein (wie in PEP 3134 beschrieben ). Auf diese Weise können Sie beim Auslösen einer Ausnahme eine vorhandene Ausnahme als „Ursache“ angeben:

try:
    frobnicate()
except KeyError as exc:
    raise ValueError("Bad grape") from exc

Die abgefangene Ausnahme wird dadurch Teil der neuen Ausnahme (ist die „Ursache“ dafür) und steht für jeden Code zur Verfügung, der die neue Ausnahme abfängt.

Mit dieser Funktion wird das __cause__Attribut festgelegt. Der integrierte Ausnahmebehandler weiß auch , wie die "Ursache" und der "Kontext" der Ausnahme zusammen mit dem Traceback gemeldet werden.

In Python 2 scheint dieser Anwendungsfall keine gute Antwort zu haben (wie von Ian Bicking und Ned Batchelder beschrieben ). Schade.

Sie können sys.exc_info () verwenden, um den Traceback abzurufen, und Ihre neue Ausnahme mit diesem Traceback auslösen (wie im PEP erwähnt). Wenn Sie den alten Typ und die alte Nachricht beibehalten möchten, können Sie dies für die Ausnahme tun. Dies ist jedoch nur dann nützlich, wenn das, was Ihre Ausnahme abfängt, danach sucht.

Beispielsweise

import sys

def failure():
    try: 1/0
    except ZeroDivisionError, e:
        type, value, traceback = sys.exc_info()
        raise ValueError, ("You did something wrong!", type, value), traceback

Das ist natürlich nicht so nützlich. Wenn es so wäre, würden wir diesen PEP nicht brauchen. Ich würde es nicht empfehlen.

Sie können Ihren eigenen Ausnahmetyp erstellen, der die von Ihnen abgefangene Ausnahme erweitert .

class NewException(CaughtException):
    def __init__(self, caught):
        self.caught = caught

try:
    ...
except CaughtException as e:
    ...
    raise NewException(e)

Aber die meiste Zeit denke ich, dass es einfacher wäre, die Ausnahme abzufangen, damit raiseumzugehen und entweder die ursprüngliche Ausnahme (und den Traceback beizubehalten) oder raise NewException(). Wenn ich Ihren Code aufrufen würde und eine Ihrer benutzerdefinierten Ausnahmen erhalten würde, würde ich erwarten, dass Ihr Code bereits alle Ausnahmen behandelt hat, die Sie abfangen mussten. Daher muss ich nicht selbst darauf zugreifen.

Bearbeiten: Ich habe diese Analyse der Möglichkeiten gefunden, Ihre eigene Ausnahme auszulösen und die ursprüngliche Ausnahme beizubehalten. Keine schönen Lösungen.

Ich fand auch, dass ich oft etwas "Wrapping" für Fehler brauche.

Dies umfasste sowohl einen Funktionsumfang als auch manchmal nur einige Zeilen innerhalb einer Funktion.

Erstellt einen Wrapper zur Verwendung von a decoratorund context manager:

Implementierung

import inspect
from contextlib import contextmanager, ContextDecorator
import functools    

class wrap_exceptions(ContextDecorator):
    def __init__(self, wrapper_exc, *wrapped_exc):
        self.wrapper_exc = wrapper_exc
        self.wrapped_exc = wrapped_exc

    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        if not exc_type:
            return
        try:
            raise exc_val
        except self.wrapped_exc:
            raise self.wrapper_exc from exc_val

    def __gen_wrapper(self, f, *args, **kwargs):
        with self:
            for res in f(*args, **kwargs):
                yield res

    def __call__(self, f):
        @functools.wraps(f)
        def wrapper(*args, **kw):
            with self:
                if inspect.isgeneratorfunction(f):
                    return self.__gen_wrapper(f, *args, **kw)
                else:
                    return f(*args, **kw)
        return wrapper

Anwendungsbeispiele

Dekorateur

@wrap_exceptions(MyError, IndexError)
def do():
   pass

beim Aufruf doMethode, keine Sorge über IndexError, nurMyError

try:
   do()
except MyError as my_err:
   pass # handle error 

Kontextmanager

def do2():
   print('do2')
   with wrap_exceptions(MyError, IndexError):
       do()

innen do2, in der context manager, wenn IndexErrores angehoben wird, wird es eingewickelt und angehobenMyError

Die einfachste Lösung für Ihre Anforderungen sollte folgende sein:

try:
     upload(file_id)
except Exception as upload_error:
     error_msg = "Your upload failed! File: " + file_id
     raise RuntimeError(error_msg, upload_error)

Auf diese Weise können Sie später Ihre Nachricht und den spezifischen Fehler drucken, der von der Upload-Funktion ausgelöst wird