¿Debería un método de clase modificadora guardarse o ser llamado explícitamente después de llamar al método?

Question

Supongamos que una clase tiene un método que modifica su funcionamiento interno. ¿Debería ese método llamar a guardar en sí mismo antes de regresar o debería guardarse para que la persona que llama guarde explícitamente después de haber llamado al método de modificación?

Ejemplo:

Explícitamente llamar a save:

class Bar(models.Model): 
    def set_foo(self, foo): 
     self.foo = foo 

bar = Bar() 
bar.set_foo("foobar") 
bar.save() 

o permitiendo método para llamar a ahorrar:

class Bar(models.Model): 
    def set_foo(self, foo): 
     self.foo = foo 
     self.save() 

bar = Bar() 
bar.set_foo("foobar") 

estoy trabajando con Django, pero me preguntaba si había una las mejores prácticas en django o en general para esta situación.

Answer 1

El usuario de su API puede olvidarse de llamar a .save() y luego ser atornillado. Entonces creo que es mejor llamar a salvarlo. Para casos como los Daslch menciona, si tiene sentido, puede definir:

def set_foo(self, foo, skip_save=False): 
    self.foo = foo 
    if not skip_save: 
     self.save() 

por lo que el usuario puede, si lo desea (y explícitamente establece que), evitar el salve.

Answer 2

El usuario de su API podría querer hacer varios cambios, guardando el objeto después de que cada cambio sea cualquier cosa menos bueno, así que no, no llame a guardar en su método.

Answer 3

En realidad, estoy de acuerdo con Ofri y Daslch ... dependiendo de qué día de la semana es. Si esta es solo una de las muchas rutinas de modificación que podría hacerle a un objeto en particular, entonces será bastante caro que cada uno de ellos haga su propio ahorro. Por otro lado, si se trata de un evento raro e independiente, entonces debe guardar porque no es obvio para la persona que llama (es decir, alguien que no sea que debe hacerse.

Por ejemplo, los eventos de etiquetado (que usan ManyToMany de todos modos) no requieren guardar adicional() en la parte de programadores

Answer 4

Para tratar todos los problemas expresados ​​en varias respuestas existentes, sugiero el siguiente enfoque: crear un método, llamarlo decir saving o modifying, que es un administrador de contexto. La entrada a ese método establece una bandera privada que dice que la modificación está en progreso; la salida restablece los indicadores y realiza el guardado; todos los métodos de modificación verifican rezagar y generar una excepción si no se establece. Por ejemplo, el uso de una clase base y un método que save subclases reales deben prevalecer:

import contextlib 

class CarefullyDesigned(object): 

    def __init__(self): 
     self.__saving = False 

    def _save(self): 
     raise NotImplementedError('Must override `_save`!') 

    def _checksaving(self): 
     "Call at start of subclass `save` and modifying-methods" 
     if not self.__saving: raise ValueError('No saving in progress!') 

    @contextlib.contextmanager 
    def saving(self): 
     if self.__saving: raise ValueError('Saving already in progress!') 
     self.__saving = True 
     yield 
     self._save() 
     self.__saving = False 

Ejemplo del uso ...:

class Bar(models.Model, CarefullyDesigned): 

    def __init__(self, *a, **k): 
     models.Model.__init__(self, *a, **k) 
     CarefullyDesigned.__init__(self) 

    def _save(self): 
     self._checksaving() 
     self.save() 

    def set_foo(self, foo): 
     self._checksaving() 
     self.foo = foo 

    def set_fie(self, fie): 
     self._checksaving() 
     self.fie = fie 

bar = Bar() 
with bar.saving(): 
    bar.set_foo("foobar") 
    bar.set_fie("fo fum") 

Esto garantiza que el usuario no se olvide de llamar saving ni accidentalmente llámalo de forma anidada (ese es el propósito de todas esas excepciones), y llama al save solo una vez cuando el grupo de métodos modificadores esté hecho, de una forma práctica y, diría, bastante natural.