Attraper une exception dans le gestionnaire de contexte __enter __ ()

Est-il possible de s'assurer de la __exit__() méthode est appelée, même si il y a une exception dans __enter__()?

>>> class TstContx(object):
...    def __enter__(self):
...        raise Exception('Oops in __enter__')
...
...    def __exit__(self, e_typ, e_val, trcbak):
...        print "This isn't running"
... 
>>> with TstContx():
...     pass
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __enter__
Exception: Oops in __enter__
>>>

Modifier

C'est aussi proche que j'ai pu obtenir...

class TstContx(object):
    def __enter__(self):
        try:
            # __enter__ code
        except Exception as e
            self.init_exc = e

        return self

    def __exit__(self, e_typ, e_val, trcbak):
        if all((e_typ, e_val, trcbak)):
            raise e_typ, e_val, trcbak

        # __exit__ code


with TstContx() as tc:
    if hasattr(tc, 'init_exc'): raise tc.init_exc

    # code in context

Dans les postérieurs de la vue, un gestionnaire de contexte pourraient ne pas avoir été la meilleure décision de conception

source d'informationauteur tMC

  1. 14

    Comme ceci:

    import sys

class Context(object):
    def __enter__(self):
        try:
            raise Exception("Oops in __enter__")
        except:
            # Swallow exception if __exit__ returns a True value
            if self.__exit__(*sys.exc_info()):
                pass
            else:
                raise


    def __exit__(self, e_typ, e_val, trcbak):
        print "Now it's running"


with Context():
    pass

    De laisser le programme de continuer son petit bonhomme de chemin sans exécuter le contexte de bloc, vous devez vérifier le contexte de l'objet à l'intérieur du contexte de bloc et ne faire que les choses importantes, si __enter__ réussi.

    class Context(object):
    def __init__(self):
        self.enter_ok = True

    def __enter__(self):
        try:
            raise Exception("Oops in __enter__")
        except:
            if self.__exit__(*sys.exc_info()):
                self.enter_ok = False
            else:
                raise
        return self

    def __exit__(self, e_typ, e_val, trcbak):
        print "Now this runs twice"
        return True


with Context() as c:
    if c.enter_ok:
        print "Only runs if enter succeeded"

print "Execution continues"

    Pour autant que je puisse en juger, vous ne pouvez pas sauter le avec bloc entièrement. Et notez que ce contexte avale maintenant tous exceptions. Si vous souhaitez ne pas avaler des exceptions si __enter__ réussit, vérifier self.enter_ok dans __exit__ et return False si c'est True.

  2. 6

    Pas. Si il ya la possibilité qu'une exception peut se produire dans __enter__() alors vous aurez besoin de l'attraper vous-même et d'appeler une fonction d'aide qui contient le code de nettoyage.

  3. 2

    Vous pouvez utiliser contextlib.ExitStack (pas testé):

    with ExitStack() as stack:
    cm = TstContx()
    stack.push(cm) # ensure __exit__ is called
    with ctx:
         stack.pop_all() # __enter__ succeeded, don't call __exit__ callback

    Ou un exemple de les docs:

    stack = ExitStack()
try:
    x = stack.enter_context(cm)
except Exception:
    # handle __enter__ exception
else:
    with stack:
        # Handle normal case

    Voir contextlib2 sur Python <3.3.

  4. 1

    si l'héritage ou complexe de sous-programmes ne sont pas nécessaires, vous pouvez utiliser un moyen plus court:

    from contextlib import contextmanager

@contextmanager
def test_cm():
    try:
        # dangerous code
        yield  
    except Exception, err
        pass # do something
  5. 0
    class MyContext:
    def __enter__(self):
        try:
            pass
            # exception-raising code
        except Exception as e:
            self.__exit__(e)

    def __exit__(self, *args):
        # clean up code ...
        if args[0]:
            raise

    Je l'ai fait comme cela. Il appelle __exit__() avec l'erreur comme argument. Si args[0] contient une erreur, il reraises l'exception après l'exécution de la nettoyer le code.