tracim.models

Complexity

Total Complexity

5

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Importance

Changes

0

4 Functions

Rating	Name	Duplication	Size	Complexity
B	get_tm_session()	0	26	1
A	get_session_factory()	0	4	1
A	get_engine()	0	2	1
B	includeme()	0	25	2

# -*- coding: utf-8 -*-

This module should have a docstring.

from sqlalchemy import engine_from_config
from sqlalchemy.event import listen
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import configure_mappers
import zope.sqlalchemy
from .meta import DeclarativeBase
from .revision_protection import prevent_content_revision_delete
# import or define all models here to ensure they are attached to the
# Base.metadata prior to any initialization routines
from tracim.models.auth import User, Group, Permission

external import "from tracim.models.auth import User, Group, Permission" should be placed before "from .meta import DeclarativeBase"

from tracim.models.data import Content, ContentRevisionRO

external import "from tracim.models.data import Content, ContentRevisionRO" should be placed before "from .meta import DeclarativeBase"

# run configure_mappers after defining all of the models to ensure
# all relationships can be setup
configure_mappers()


def get_engine(settings, prefix='sqlalchemy.'):

This function should have a docstring.

    return engine_from_config(settings, prefix)


def get_session_factory(engine):

This function should have a docstring.

    factory = sessionmaker(expire_on_commit=False)
    factory.configure(bind=engine)
    return factory


def get_tm_session(session_factory, transaction_manager):
    """
    Get a ``sqlalchemy.orm.Session`` instance backed by a transaction.

    This function will hook the _session to the transaction manager which
    will take care of committing any changes.

    - When using pyramid_tm it will automatically be committed or aborted
      depending on whether an exception is raised.

    - When using scripts you should wrap the _session in a manager yourself.
      For example::

          import transaction

          engine = get_engine(settings)
          session_factory = get_session_factory(engine)
          with transaction.manager:
              dbsession = get_tm_session(session_factory, transaction.manager)

    """
    dbsession = session_factory()
    zope.sqlalchemy.register(
        dbsession, transaction_manager=transaction_manager)
    listen(dbsession, 'before_flush', prevent_content_revision_delete)
    return dbsession


def includeme(config):
    """
    Initialize the model for a Pyramid app.

    Activate this setup using ``config.include('tracim.models')``.

    """
    settings = config.get_settings()
    settings['tm.manager_hook'] = 'pyramid_tm.explicit_manager'

    # use pyramid_tm to hook the transaction lifecycle to the request
    config.include('pyramid_tm')

    # use pyramid_retry to retry a request when transient exceptions occur
    config.include('pyramid_retry')

    session_factory = get_session_factory(get_engine(settings))
    config.registry['dbsession_factory'] = session_factory

    # make request.dbsession available for use in Pyramid
    config.add_request_method(
        # r.tm is the transaction manager used by pyramid_tm
        lambda r: get_tm_session(session_factory, r.tm),
        'dbsession',
        reify=True
    )