Hooks for CRUD
I'm on the fence about this...feel like the signals should be able to exist at the application level as opposed to the database level.
 Sure, as I see it they should be on each model, that's how I was imagining to use them.

I my FSM case I would load the local in-memory FSM object after the model is loaded from the db, and I would imagine doing it on a post_init method of my actual model that have the FSM field.

A naming convention would probably be the best option, for example having the above methods as abstract methods on peewee.Model and just override any of them you wish to use in your own models.

Another option is setting each callback you want to use on the class level in your model.
 Since save() and delete_instance() can easily be overridden and will do the right thing, I'll leave them as-is.  I have added a hook on the model instance named `prepared` which will be called when the row is ready and has received data from the db cursor.  You can now write:

``` python

class FSM(Model):
    state = CharField()

    def prepared(self):
        self.do_something_with_state()
```

This will be called when a model is populated from the db, whether called by
- select
- filter
- get

It will not be called when "related" models are selected, though, for instance

``` python

for entry in Entry.select({Entry: '*', Blog: '*'}):
    # entry will be prepared, but entry.blog will not
    pass
```
 Cool, will try it out!

I'm trying to add this minimalistic FSM (https://github.com/oxplot/fysom) to a peewee model and just storing the state as a char field. The problem I'm having is restoring the state when selecting or creating models from elsewhere. Saving a state change is easy using the FSM callbacks. I have tried using a overloaded init, but that is called before the fields are pulled from the db. I have also tried overloaded class methods for create and and get, but that doesn't cover all cases (the filter method seems tricky to hack into from a subclass). Lastly, all my tries so far results in very un-pythonic code...

Have you though about adding hooks like the Django signals to perform custom pre/post CRUD? Some very simple callbacks would be enough to do some post init of more complex in-memory data structures (like a FSM) that depends on fields in the model.

Django uses these (https://docs.djangoproject.com/en/dev/ref/signals/):

``` python
pre_init
post_init
pre_save
post_save
pre_delete
post_delete
```

I think these hooks adds just enough to be a powerful tool without making peewee less minimalistic.

What do you think?
