¿Agregar información a una excepción?

Quiero lograr algo como esto:

def foo():
   try:
       raise IOError('Stuff ')
   except:
       raise

def bar(arg1):
    try:
       foo()
    except Exception as e:
       e.message = e.message + 'happens at %s' % arg1
       raise

bar('arg1')

Traceback...
  IOError('Stuff Happens at arg1')

Pero lo que obtengo es:

Traceback..
  IOError('Stuff')

¿Alguna pista sobre cómo lograr esto? ¿Cómo hacerlo tanto en Python 2 como en 3?

Lo haría así, así que cambiar su tipo foo()no requerirá también cambiarlo bar().

def foo():
    try:
        raise IOError('Stuff')
    except:
        raise

def bar(arg1):
    try:
        foo()
    except Exception as e:
        raise type(e)(e.message + ' happens at %s' % arg1)

bar('arg1')

Traceback (most recent call last):
  File "test.py", line 13, in <module>
    bar('arg1')
  File "test.py", line 11, in bar
    raise type(e)(e.message + ' happens at %s' % arg1)
IOError: Stuff happens at arg1

Actualización 1

Aquí hay una ligera modificación que conserva el rastreo original:

...
def bar(arg1):
    try:
        foo()
    except Exception as e:
        import sys
        raise type(e), type(e)(e.message +
                               ' happens at %s' % arg1), sys.exc_info()[2]

bar('arg1')

Traceback (most recent call last):
  File "test.py", line 16, in <module>
    bar('arg1')
  File "test.py", line 11, in bar
    foo()
  File "test.py", line 5, in foo
    raise IOError('Stuff')
IOError: Stuff happens at arg1

Actualización 2

Para Python 3.x, el código en mi primera actualización es sintácticamente incorrecto y la idea de tener un messageatributo activadoBaseException se retractó en un cambio a PEP 352 el 16/05/2012 (mi primera actualización se publicó el 12/03/2012) . Entonces, actualmente, en Python 3.5.2 de todos modos, necesitaría hacer algo en este sentido para preservar el rastreo y no codificar el tipo de excepción en la función bar(). También tenga en cuenta que habrá la línea:

During handling of the above exception, another exception occurred:

en los mensajes de rastreo que se muestran.

# for Python 3.x
...
def bar(arg1):
    try:
        foo()
    except Exception as e:
        import sys
        raise type(e)(str(e) +
                      ' happens at %s' % arg1).with_traceback(sys.exc_info()[2])

bar('arg1')

Actualización 3

Un comentarista preguntó si había una manera que funcione tanto en Python 2 y 3. Aunque la respuesta podría parecer que es "No", debido a las diferencias de sintaxis, no es una forma de evitar que mediante el uso de una función de ayuda al igual que reraise()en el sixAgregar- en el módulo Entonces, si prefiere no usar la biblioteca por alguna razón, a continuación se muestra una versión independiente simplificada.

Tenga en cuenta también que, dado que la excepción se vuelve a generar dentro de la reraise()función, aparecerá en cualquier rastreo que se genere, pero el resultado final es lo que desea.

import sys

if sys.version_info.major < 3:  # Python 2?
    # Using exec avoids a SyntaxError in Python 3.
    exec("""def reraise(exc_type, exc_value, exc_traceback=None):
                raise exc_type, exc_value, exc_traceback""")
else:
    def reraise(exc_type, exc_value, exc_traceback=None):
        if exc_value is None:
            exc_value = exc_type()
        if exc_value.__traceback__ is not exc_traceback:
            raise exc_value.with_traceback(exc_traceback)
        raise exc_value

def foo():
    try:
        raise IOError('Stuff')
    except:
        raise

def bar(arg1):
    try:
       foo()
    except Exception as e:
        reraise(type(e), type(e)(str(e) +
                                 ' happens at %s' % arg1), sys.exc_info()[2])

bar('arg1')

En caso de que haya venido aquí buscando una solución para Python 3, el manual dice:

Cuando se genera una nueva excepción (en lugar de utilizar un bare raisepara volver a generar la excepción que se está manejando actualmente), el contexto de excepción implícito se puede complementar con una causa explícita al usar from with raise:

raise new_exc from original_exc

Ejemplo:

try:
    return [permission() for permission in self.permission_classes]
except TypeError as e:
    raise TypeError("Make sure your view's 'permission_classes' are iterable. "
                    "If you use '()' to generate a set with a single element "
                    "make sure that there is a comma behind the one (element,).") from e

Que se ve así al final:

2017-09-06 16:50:14,797 [ERROR] django.request: Internal Server Error: /v1/sendEmail/
Traceback (most recent call last):
File "venv/lib/python3.4/site-packages/rest_framework/views.py", line 275, in get_permissions
    return [permission() for permission in self.permission_classes]
TypeError: 'type' object is not iterable 

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
    # Traceback removed...
TypeError: Make sure your view's Permission_classes are iterable. If 
     you use parens () to generate a set with a single element make 
     sure that there is a (comma,) behind the one element.

Convirtiendo un TypeErrormensaje totalmente indescriptible en un bonito mensaje con sugerencias hacia una solución sin estropear la excepción original

Suponiendo que no desea o no puede modificar foo (), puede hacer esto:

try:
    raise IOError('stuff')
except Exception as e:
    if len(e.args) >= 1:
        e.args = (e.args[0] + ' happens',) + e.args[1:]
    raise

De hecho, esta es la única solución aquí que resuelve el problema en Python 3 sin un mensaje feo y confuso "Durante el manejo de la excepción anterior, ocurrió otra excepción".

En caso de que la línea de resubir se agregue a la traza de la pila, escribir en raise elugar de raisehará el truco.

No me gustan todas las respuestas dadas hasta ahora. Todavía son demasiado detallados en mi humilde opinión. En salida de código y mensaje.

Todo lo que quiero tener es el seguimiento de la pila que apunta a la excepción de origen, sin cosas de excepción en el medio, por lo que no se crean nuevas excepciones, solo se vuelve a elevar el original con todos los estados relevantes del marco de la pila que condujeron allí.

Steve Howard dio una buena respuesta que quiero extender, no, reducir ... solo a Python 3.

except Exception as e:
    e.args = ("Some failure state", *e.args)
    raise

Lo único nuevo es la expansión / desempaquetado de parámetros, que lo hace lo suficientemente pequeño y fácil de usar.

Intentalo:

foo = None

try:
    try:
        state = "bar"
        foo.append(state)

    except Exception as e:
        e.args = ("Appending '"+state+"' failed", *e.args)
        raise

    print(foo[0]) # would raise too

except Exception as e:
    e.args = ("print(foo) failed: " + str(foo), *e.args)
    raise

Esto te dará:

Traceback (most recent call last):
  File "test.py", line 6, in <module>
    foo.append(state)
AttributeError: ('print(foo) failed: None', "Appending 'bar' failed", "'NoneType' object has no attribute 'append'")

Una simple impresión bonita podría ser algo así como

print("\n".join( "-"*i+" "+j for i,j in enumerate(e.args)))

Un enfoque útil que utilicé es usar el atributo de clase como almacenamiento para detalles, ya que el atributo de clase es accesible tanto desde el objeto de clase como desde la instancia de clase:

class CustomError(Exception):
    def __init__(self, details: Dict):
        self.details = details

Luego en tu código:

raise CustomError({'data': 5})

Y al detectar un error:

except CustomError as e:
    # Do whatever you want with the exception instance
    print(e.details)

A diferencia de las respuestas anteriores, esto funciona frente a excepciones con muy mal __str__. Sin embargo, modifica el tipo, para factorizar __str__implementaciones inútiles .

Todavía me gustaría encontrar una mejora adicional que no modifique el tipo.

from contextlib import contextmanager
@contextmanager
def helpful_info():
    try:
        yield
    except Exception as e:
        class CloneException(Exception): pass
        CloneException.__name__ = type(e).__name__
        CloneException.__module___ = type(e).__module__
        helpful_message = '%s\n\nhelpful info!' % e
        import sys
        raise CloneException, helpful_message, sys.exc_traceback


class BadException(Exception):
    def __str__(self):
        return 'wat.'

with helpful_info():
    raise BadException('fooooo')

El rastreo original y el tipo (nombre) se conservan.

Traceback (most recent call last):
  File "re_raise.py", line 20, in <module>
    raise BadException('fooooo')
  File "/usr/lib64/python2.6/contextlib.py", line 34, in __exit__
    self.gen.throw(type, value, traceback)
  File "re_raise.py", line 5, in helpful_info
    yield
  File "re_raise.py", line 20, in <module>
    raise BadException('fooooo')
__main__.BadException: wat.

helpful info!

Proporcionaré un fragmento de código que utilizo a menudo cuando quiera agregar información adicional a una excepción. Trabajo tanto en Python 2.7 como en 3.6.

import sys
import traceback

try:
    a = 1
    b = 1j

    # The line below raises an exception because
    # we cannot compare int to complex.
    m = max(a, b)  

except Exception as ex:
    # I create my  informational message for debugging:
    msg = "a=%r, b=%r" % (a, b)

    # Gather the information from the original exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()

    # Format the original exception for a nice printout:
    traceback_string = ''.join(traceback.format_exception(
        exc_type, exc_value, exc_traceback))

    # Re-raise a new exception of the same class as the original one, 
    # using my custom message and the original traceback:
    raise type(ex)("%s\n\nORIGINAL TRACEBACK:\n\n%s\n" % (msg, traceback_string))

El código anterior da como resultado el siguiente resultado:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-09b74752c60d> in <module>()
     14     raise type(ex)(
     15         "%s\n\nORIGINAL TRACEBACK:\n\n%s\n" %
---> 16         (msg, traceback_string))

TypeError: a=1, b=1j

ORIGINAL TRACEBACK:

Traceback (most recent call last):
  File "<ipython-input-6-09b74752c60d>", line 7, in <module>
    m = max(a, b)  # Cannot compare int to complex
TypeError: no ordering relation is defined for complex numbers

Sé que esto se desvía un poco del ejemplo proporcionado en la pregunta, pero sin embargo espero que alguien lo encuentre útil.

Puede definir su propia excepción que hereda de otro y crear su propio constructor para establecer el valor.

Por ejemplo:

class MyError(Exception):
   def __init__(self, value):
     self.value = value
     Exception.__init__(self)

   def __str__(self):
     return repr(self.value)

Tal vez

except Exception as e:
    raise IOError(e.message + 'happens at %s'%arg1)