bag.web.pyramid.resources module

Construction kit for Pyramid resource classes.

Example usage:

from bag.web.pyramid.resources import (
    BaseRootResource, BaseResource, IntResource,
    ancestor, ancestor_model, model_property)
from pyramid.decorator import reify
from import (Allow, Deny, Everyone, Authenticated,
from .models import User, Address

class RootResource(BaseRootResource):
    __acl__ = [
        (Allow, 'group:admin', ALL_PERMISSIONS),
        (Allow, Authenticated, ('view_dashboard', 'edit_users')),
        (Deny, Everyone, ALL_PERMISSIONS),
    factories = {}  # a static registry of Resource classes

class UserResource(IntResource):  # /users/1/
    factories = {}  # a static registry of Resource classes

    def model(self):
        return sas.query(User).get(self.__name__)

    def __acl__(self):
        user_id = self._request.authenticated_userid
        return [(Allow, user_id, self.model.get_permissions(user_id))]

class UsersResource(BaseResource):  # /users/
    contains_cls = UserResource

    def models(self):
        return sas.query(User)

RootResource.factories['users'] = UsersResource

class AddressResource(IntResource):  # /users/1/addresses/1
    factories = {}  # a static registry of Resource classes
    model = model_property(sas, Address, user=User)

class AddressesResource(BaseResource):  # /users/1/addresses
    contains_cls = AddressResource

    def models(self):
        return ancestor_model(self, User).addresses

UserResource.factories['addresses'] = AddressesResource
class bag.web.pyramid.resources.BaseResource[source]

Bases: bag.web.pyramid.resources.BaseRootResource

Base class for Pyramid traversal resources.

Subclasses may define a static factories dict, used to map URL elements to other resource classes or factories. This is useful for any resource whose children fork into separate trees.

Subclasses may also represent collections, such as /books/. These subclasses must define a contains_cls attribute, whose value is to be the contained resource class.

For a subclass representing a single model instance ― e. g. /books/1/ ―, you can implement a model property; then a descendant view such as /books/1/authors/ may call ancestor_model(Book), which will find the ancestor and return the model property value. Example:

def model(self):
    return sas.query(Book).get(self.__name__)
class bag.web.pyramid.resources.BaseRootResource(request)[source]

Bases: object

Base class for your Root resource.

class bag.web.pyramid.resources.IntResource[source]

Bases: bag.web.pyramid.resources.BaseResource

Base class for resources whose name must be an int, e.g. /books/1.

bag.web.pyramid.resources.ancestor(resource, cls, include_self=False)[source]

Return the first ancestor of resource that is of type cls.

bag.web.pyramid.resources.ancestor_finder(resource, predicate, include_self=False)[source]

Generate ancestors that satisfy predicate.

Generator that climbs the tree yielding resources for which predicate(current_resource) returns True.

bag.web.pyramid.resources.ancestor_model(resource, cls, include_self=False)[source]

Find in ancestors a model instance of type cls.

The search is done in the model attribute of the ancestors of resource. Returns None if not found.


Find and return the root resource.

bag.web.pyramid.resources.model_property(sas, model_cls, **ancestors)[source]

Return a property that checks ancestor IDs.

If you are using SQLAlchemy, this function returns a model property that checks some ancestor ID(s) against its foreign key(s). Example usage:

class AddressResource(BaseResource):
    model = model_property(sas, Address, user=User)