Abstract Model database metadata inheritance doesn't work
First off, where did you get the `meta.abstract` thing? That is a django orm thing, not peewee.
 Oh. I thought peewee have similar implementation. My mistake.
Does peewee have something like this?
 I should close this issue then
 Also the code works fine for me:

``` python

In [5]: from peewee import *

In [6]: db = SqliteDatabase('foo.db')

In [7]: db.database
Out[7]: 'foo.db'

In [8]: class BaseModel(Model):
    timestamp = DateTimeField()
    class Meta:
        database = db
        db_table_func = lambda model_cls: model_cls.__name__.title()
   ...:         

In [9]: class TestModel(BaseModel):
   ...:     name = CharField()
   ...:     

In [10]: tm = TestModel(name='test')

In [11]: tm._meta.database.database
Out[11]: 'foo.db'

In [12]: tm._meta.db_table
Out[12]: 'Testmodel'
```
 I am using `from playhouse.flask_utils import FlaskDB` and `from playhouse.signals import Model` I guess that mix is the one causing issues 
 It is trick if you want to benefit from both playhouse flask utils `FlaskDB` and also benefit from signals
 @coleifer I found out the cause of such wild behaviour.

The cause was that I was using `playhouse.signals.Model`with `playhouse.flask_utils.FlaskDB`.

I solved it by using both

``` python
from playhouse.flask_utils import FlaskDB
from playhouse.signals import Model

db = FlaskDB(app, ....)

class BaseModel(db.Model, Model):
    class Meta:
        database = db.database

class Foo(BaseModel):
    name = CharField()
...
```

I don't know if this is the sane way to do it but it seems to work
 Yes, FlaskDB is a wrapper and you still need to point at the underlying peewee db
 Cool. Thanks
 @coleifer, `BaseModel` from your example will also generate a table in db. Do we have any option to specify that for a specific model we don't want a table? Only if you call `BasModel.create_table()` or pass it to database.create_tables(), so I'm not sure I see the problem.
``` python
db = PostgresqlDatabase(...)

class BaseModel(Model):
    created_at = DateTimeField(default=datetime.now)
    modified_at = DateTimeField(default=datetime.now)

    class Meta:
        abstract = True
        db_table_func = lambda model_cls: tableize(model_cls.__name__)
        database = db

class Foo(BaseModel):
    name = CharField()

foo = Foo(name="Foo Bar")
foo.name                            #-> Foo Bar
foo._meta.db_table            #-> foos
foo._meta.database           #-> <peewee.SqliteDatabase object at 0x1012e64a8>
```

Inheritance from the abstract model works on field and other _meta arguments but database.
when I call `create_tables` for all model i found that an sqlite db have been created called `peewee.db`
