Controllare le condizioni prima del metodo chiamare

Question

Ho una classe denominata Server che può essere avviata e arrestata. Alcuni metodi non dovrebbero essere chiamati a meno che il Server non sia avviato, nel qual caso dovrebbe essere sollevata una NotConnectedException. C'è un modo per chiamare un metodo prima di ogni metodo in una classe e determinare se la variabile di classe _started è impostata su True?

Ho provato a utilizzare un decoratore, ma la funzione decoratore non ha accesso alla variabile di classe. Stavo cercando di fare qualcosa di simile:

class Server(object): 
    _started = False 
    def started(self): 
     if(self._started == False): 
      raise NotConnectedException 

    @started 
    def doServerAction(self): 
     ... 

Answer 1

ricordare cosa decoratori sono:

@decorate 
def foo(...): 
    ... 

è esattamente equivalente a:

def foo(...): 
    ... 
foo = decorate(foo) 

Il decoratore è chiamato sulla funzione , quindi chiamando il primo parametro auto non fa senso. Inoltre, il decoratore viene chiamato sulla funzione quando viene definito e qualsiasi cosa restituisce viene utilizzata al posto della funzione. Pertanto, anche se il tuo decoratore started non ha lanciato un AttributeError tentando di accedere all'attributo _started di una funzione, restituisce quindi None, impostando tutti i metodi su None e quindi non è nemmeno possibile chiamarlo.

quello che vuoi è qualcosa di simile:

import functools 

def started(func): 
    @functools.wraps(func) 
    def wrapper(self, *args, **kwargs): 
     if not self._started: 
      raise ... 
     else: 
      return func(self, *args, **kwargs) 
    return wrapper 

Quasi tutti i decoratori sono di questa forma; prendono una funzione, creano un wrapper che fa qualcosa "attorno" alla funzione ricevuta e quindi restituisce il wrapper. L'uso di functools.wraps qui è utile se si finisce mai con questo codice in una sessione di interprete interattivo; aggiorna automaticamente la funzione wrapper con il nome e la docstring della funzione originale, il che rende le funzioni decorate "simili" alla funzione originale un po 'di più.

È irrilevante se questo è definito all'interno della classe oppure no.