pyramid_peewee 0.5

Utilize Peewee as your ORM with Pyramid webapplications. - pyramid_peewee

Pyramid_peewee is a module for the Pyramid web application framework which allos developers to use Peewee as their ORM.

Requirements:

1. Pyramid
2. Peewee
3. Database

Usage:

Typically Pyramid based applications are configured in two locations, at the application level within the application __init__.py file and at the instance level within an “ini” file, such as production.ini. To configure your applicaiton, first at the instance (eg production.ini) level you must set peewee.urls = “database connection url”

peewee.urls = sqlite:///dbase.db
or
peewee.urls =
    postgresql://user:pass@localhost:5432/mydatabase
    sqlite:///dbase.db

Note we specifically use database urls as defined in the peewee documentation Connecting using a Database URL and that you may specify as many database urls as your application needs within the peewee.urls paramter. At the application level, eg within your applications __init__.py file

1. import your database model

2. include the command config.include(‘pyramid_peewee’) within the config section.

Define your data model: To define your data model fist set your database = peewee.Proxy. Note if your database contains a “.” in the name, such as with sqlite files replace it with an “_” (underscore).

from peewee import *

mydatabase = Proxy()
dbase_db = Proxy()

class People(Model):
    name = TextField()
    class Meta:
        database = mydatabase

class Cars(model):
    name = TextField()
        class Meta:
            database = dbase_db

In this example we’ve defined two tables, each derived from different database Proxies. Peewee allows you to define as many database connections as you need and utilize them seemlessly within an application.

Using your datamodel within a View:

To utilize your datamodel within a view you must first get a datbase connection. This is accomplished by calling the database proxy which is tied to the view request. By doing so database connections are properly closed as the end of the request.

from model import *
def myView(requset):
    request.mydatabase
    joe = People.select().where(People.name=='joe').get()
    return dict(name=joe.name)

As stated above by calling request.mydatabase two things are accomplished, one a database connection is opened for the request, and two a callback is registered wich will properly close the connection at the end of the request. Trying to use the model without first calling the database method from the request object will result in an DataBaseClosed error. This is a devation from the normal PeeWee behavior which normaly opens a connection as needed.

Supported database urls from the PeeWee documentation:

1. sqlite:///my_database.db will create a SqliteDatabase instance for the file my_database.db in the current directory.

2. sqlite:///:memory: will create an in-memory SqliteDatabase instance.

3. postgresql://postgres:my_password@localhost:5432/my_database will create a PostgresqlDatabase instance. A username and password are provided, as well as the host and port to connect to.

4. mysql://user:passwd@ip:port/my_db will create a MySQLDatabase instance for the local MySQL database my_db.

Supported schemes:

1. apsw: APSWDatabase

2. mysql: MySQLDatabase

3. mysql+pool: PooledMySQLDatabase

4. postgres: PostgresqlDatabase

5. postgres+pool: PooledPostgresqlDatabase

6. postgresext: PostgresqlExtDatabase

7. postgresext+pool: PooledPostgresqlExtDatabase

8. sqlite: SqliteDatabase

9. sqliteext: SqliteExtDatabase

The most up to date documentation can always be found on their website: Peewee Database URL