Behandeln von Instanzen eines Kontextmanagers in einem anderen Kontextmanager

Question

Wie sollte ein in einem anderen Kontextmanager erstellter Kontextmanager in Python behandelt werden?

Beispiel: Angenommen, Sie haben die Klasse A, die als Kontextmanager fungiert, und die Klasse B, die auch als Kontextmanager fungiert. Aber Klasse B Instanzen müssen instanziieren und eine Instanz der Klasse A verwenden. Ich bin durch PEP 343 gegangen und das ist die Lösung, an die ich gedacht habe:

Ist das der richtige Ansatz? Oder fehle ich ein paar Gotchas?

Answer 1

Alternativ können Sie Ihren Code wie so schreiben:

with A() as a: 
    with B(a) as b: 
     # your code here 

Eine andere Lösung, die Sie vielleicht ausprobieren möchten dies sein könnte:

class A: 

    def __init__(self): 
     pass 

    def __enter__(self): 
     return self 

    def __exit__(self, exc_type, exc_val, exc_tb): 
     pass 

class B(A): 

    def __init__(self): 
     super().__init__() 

    def __enter__(self): 
     super().__enter__() 
     return self 

    def __exit__(self, exc_type, exc_val, exc_tb): 
     super().__exit__(exc_type, exc_val, exc_tb) 

Nach Prüfung der Erklärung Ihrer Situation, könnte dies sein eine bessere Lösung:

class Resource: 

    def __init__(self, dependency=None): 
     self.dependency = dependency 
     # your code here 

    def __enter__(self): 
     if self.dependency: 
      self.dependency.__enter__() 
     # your code here 
     return self 

    def __exit__(self, exc_type, exc_val, exc_tb): 
     # your code here 
     if self.dependency: 
      self.dependency.__exit__(exc_type, exc_val, exc_tb) 

Ich bin mir nicht sicher, ob die folgende Implementierung ist korrekt, aber __exit__ muss sorgfältig auf Ausnahmen achten. Es ist etwas schwierig für mich, sich vorzustellen, wie man die Aufrufe rekursiv kettet, während Ausnahmen gut behandelt werden.

class Resource: 

    def __init__(self, dependency=None): 
     self.dependency = dependency 
     self.my_init() 

    def __enter__(self): 
     if self.dependency: 
      self.dependency.__enter__() 
     return self.my_enter() 

    def __exit__(self, exc_type, exc_val, exc_tb): 
     suppress = False 
     try: 
      suppress = self.my_exit(exc_type, exc_val, exc_tb): 
     except: 
      exc_type, exc_val, exc_tb = sys.exc_info() 
     if suppress: 
      exc_type = exc_val = exc_tb = None 
     if self.dependency: 
      suppress = self.dependeny.__exit__(exc_type, exc_val, exc_tb) 
      if not supress: 
       raise exc_val.with_traceback(exc_tb) from None 
     return suppress 

    def my_init(self): 
     pass 

    def my_enter(self): 
     pass 

    def my_exit(self, exc_type, exc_val, exc_tb): 
     pass 

Answer 2

Wenn Sie den @contextlib.contextmanager Dekorateur verwenden können, um das Leben viel einfacher wird:

import contextlib 

@contextlib.contextmanager 
def internal_cm(): 
    try: 
     print "Entering internal_cm" 
     yield None 
     print "Exiting cleanly from internal_cm" 
    finally: 
     print "Finally internal_cm" 


@contextlib.contextmanager 
def external_cm(): 
    with internal_cm() as c: 
     try: 
      print "In external_cm_f", c 
      yield [c] 
      print "Exiting cleanly from external_cm_f", c 
     finally: 
      print "Finally external_cm_f", c 


if "__main__" == __name__: 
    with external_cm(): 
     print "Location A" 
    print 
    with external_cm(): 
     print "Location B" 
     raise Exception("Some exception occurs!!")