API Reference

class chemist.managers.Manager(model_klass, context)

all(limit_by=None, offset_by=None, order_by=None)

Returns all existing rows as Model

create(**data)

Creates a new model and saves it to MySQL

find_by(**kw)

Find a list of models that could be found in the database and match all the given keyword-arguments

find_one_by(**kw)

Find a single model that could be found in the database and match all the given keyword-arguments

from_result_proxy(proxy, result)

Creates a new instance of the model given an instance of sqlalchemy.engine.ResultProxy

generate_query(order_by=None, limit_by=None, offset_by=None, **kw)

Queries the table with the given keyword-args and optionally a single order_by field.

get_or_create(**data)

Tries to get a model from the database that would match the given keyword-args through Manager.find_one_by(). If not found, a new instance is created in the database through Manager.create()

query_by(**kwargs)

This method is used internally and is not consistent with the other ORM methods by not returning a model instance.

total_rows(field_name=None, **where)

Gets the total number of rows in the table

class chemist.orm.Context(default_uri=None)

Context is a system component that keeps track of multiple engines, switch between them and manage their lifecycle.

It also provides a sqlalchemy.MetaData instance that is automatically bound to

Its purpose is to leverage quicky swapping the engine between “unit” tests.

class chemist.orm.Monetary

class chemist.orm.ORM(name, bases, attrs)

metaclass for chemist.models.Model

class chemist.models.Model(engine=None, **data)

Super-class of active record models.

Example:

class BlogPost(Mode):
    table = db.Table(
        'blog_post',
        metadata,
        db.Column('id', db.Integer, primary_key=True),
        db.Column('title', db.Unicode(200), nullable=False),
        db.Column('slug', db.Unicode(200), nullable=False),
        db.Column('content', db.UnicodeText, nullable=False),
   )

    def preprocess(self, data):
        # always derive slug from title
        data['slug'] = slugify(data['title'])
        return data

delete()

Deletes the current model from the database (removes a row that has the given model primary key)

get(name, fallback=None)

Get a field value from the model

initialize()

Dummy method to be optionally overwritten in the subclasses. Gets automatically called once a model instance is constructed.

is_persisted

boolean property that returns True if the primary key is set. This property does not perform I/O against the database

manager

alias of chemist.managers.Manager

post_delete()

called right after executing a deletion. This method can be overwritten by subclasses in order to take any domain-related action

post_save(transaction)

called right after executing a save. This method can be overwritten by subclasses in order to take any domain-related action

pre_delete()

called right before executing a deletion. This method can be overwritten by subclasses in order to take any domain-related action

pre_save()

called right before executing a save. This method can be overwritten by subclasses in order to take any domain-related action

preprocess(data)

Placeholder for your own custom preprocess method, remember it must return a dictionary.

class BlogPost(Mode):
    table = db.Table(
        'blog_post',
        metadata,
        db.Column('id', db.Integer, primary_key=True),
        db.Column('title', db.Unicode(200), nullable=False),
        db.Column('slug', db.Unicode(200), nullable=False),
        db.Column('content', db.UnicodeText, nullable=False),
   )

    def preprocess(self, data):
        # always derive slug from title
        data['slug'] = slugify(data['title'])
        return data

refresh()

updates the current record with fresh values retrieved by find_one_by() and also returns a brand new instance.

Note

any unsaved changes in the model will be lost upon calling this method.

save(input_engine=None)

Persists the model instance in the DB. It takes care of checking whether it already exists and should be just updated or if a new record should be created.

serialize()

pre-serializes the model, returning a dictionary with key-values.

This method is use by the to_dict() and only exists as a separate method so that subclasses overwriting to_dict can call serialize() rather than super(SubclassName, self).to_dict()

set(**kw)

Sets multiple fields, does not perform a save operation

to_dict()

pre-serializes the model, returning a dictionary with key-values.

This method can be overwritten by subclasses at will.

Example:

>>> post = BlogPost.create(title='Some Title', content='loren ipsum')
>>> post.to_dict()
{
  'id': 1,
  'title': 'Some Title',
  'slug': 'some-title',
}

to_insert_params()

utility method used internally to generate a dict with all the serialized values except primary keys.

Example:

>>> post = BlogPost.create(title='Some Title', content='loren ipsum')
>>> post.to_insert_params()
{
  'title': 'Some Title',
  'slug': 'some-title',
}

to_json(indent=None, sort_keys=True, **kw)

Grabs the dictionary with the current model state returned by to_dict and serializes it to JSON

update_and_save(**kw)

Sets multiple fields then saves them