Esecuzione saltata di -with- block

Question

Sto definendo una classe di gestione del contesto e vorrei poter saltare il blocco di codice senza generare un'eccezione se determinate condizioni sono soddisfatte durante l'istanziazione. Ad esempio,

class My_Context(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Exiting...' 
      CODE TO EXIT PREMATURELY 
    def __exit__(self, type, value, traceback): 
     print 'Exiting...' 

with My_Context(mode=1): 
    print 'Executing block of codes...' 

Answer 1

Se si desidera una soluzione ad hoc che utilizza le idee da withhacks (in particolare da AnonymousBlocksInPython), questo funzionerà:

import sys 
import inspect 

class My_Context(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Met block-skipping criterion ...' 
      # Do some magic 
      sys.settrace(lambda *args, **keys: None) 
      frame = inspect.currentframe(1) 
      frame.f_trace = self.trace 
    def trace(self, frame, event, arg): 
     raise 
    def __exit__(self, type, value, traceback): 
     print 'Exiting context ...' 
     return True 

Confrontare il seguente:

with My_Context(mode=1): 
    print 'Executing block of code ...' 

con

with My_Context(mode=0): 
    print 'Executing block of code ... ' 

Answer 2

Quello che stai cercando di fare non è possibile, sfortunatamente. Se __enter__ solleva un'eccezione, tale eccezione viene sollevata nell'istruzione with (__exit__ non viene chiamato). Se non genera un'eccezione, il valore di ritorno viene inviato al blocco e il blocco viene eseguito.

cosa più vicina che riuscivo a pensare è una bandiera a scacchi in modo esplicito dal blocco:

class Break(Exception): 
    pass 

class MyContext(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Exiting...' 
     return self.mode 
    def __exit__(self, type, value, traceback): 
     if type is None: 
      print 'Normal exit...' 
      return # no exception 
     if issubclass(type, Break): 
      return True # suppress exception 
     print 'Exception exit...' 

with MyContext(mode=1) as skip: 
    if skip: raise Break() 
    print 'Executing block of codes...' 

Questo consente anche di alzare Break() nel bel mezzo di un blocco with per simulare un normale break dichiarazione.

Answer 3

Secondo PEP-343, una dichiarazione with traduce dal:

with EXPR as VAR: 
    BLOCK 

a:

mgr = (EXPR) 
exit = type(mgr).__exit__ # Not calling it yet 
value = type(mgr).__enter__(mgr) 
exc = True 
try: 
    try: 
     VAR = value # Only if "as VAR" is present 
     BLOCK 
    except: 
     # The exceptional case is handled here 
     exc = False 
     if not exit(mgr, *sys.exc_info()): 
      raise 
     # The exception is swallowed if exit() returns true 
finally: 
    # The normal and non-local-goto cases are handled here 
    if exc: 
     exit(mgr, None, None, None) 

Come si può vedere, non c'è nulla di ovvio che si può fare dalla chiamata al metodo di __enter__() il gestore del contesto che può saltare il corpo ("BLOCK") dell'istruzione with.

Le persone hanno fatto cose specifiche dell'implementazione di Python, come la manipolazione dello stack di chiamate all'interno di __enter__(), in progetti come withhacks. Ricordo che Alex Martelli pubblicò un interessante con-hack su stackoverflow uno o due anni fa (non ricordo abbastanza post del post per cercare e trovarlo).

Ma la semplice risposta alla tua domanda/problema è che non puoi fare quello che stai chiedendo, saltando il corpo della frase con, senza ricorrere alla cosiddetta "magia profonda" (che non è necessariamente portatile tra python implementazioni). Con la magia profonda, potresti essere in grado di farlo, ma io consiglio solo di fare cose come un esercizio nel vedere come potrebbe essere fatto, mai in "codice di produzione".