コード例 #1
0
def test_sqlalchemy_version():
    def parse_int(s):
        try:
            return int(s)
        except ValueError:
            return -1
    sqla_version_info = tuple(map(parse_int, __version__.split('.')[:3]))
    assert sqla_version_info >= SQLA_COMPAT_VERSION_INFO
    assert __version__.split('.')[:3] >= SQLA_COMPAT_VERSION.split('.')[:2]
コード例 #2
0
ファイル: datamanager.py プロジェクト: cproctor/nuzzle
def register(session, initial_state=STATUS_ACTIVE,
             transaction_manager=zope_transaction.manager, keep_session=False):
    """Register ZopeTransaction listener events on the
    given Session or Session factory/class.

    This function requires at least SQLAlchemy 0.7 and makes use
    of the newer sqlalchemy.event package in order to register event listeners
    on the given Session.

    The session argument here may be a Session class or subclass, a
    sessionmaker or scoped_session instance, or a specific Session instance.
    Event listening will be specific to the scope of the type of argument
    passed, including specificity to its subclass as well as its identity.

    """

    from sqlalchemy import __version__
    assert tuple(int(x) for x in __version__.split(".")) >= (0, 7), \
        "SQLAlchemy version 0.7 or greater required to use register()"

    from sqlalchemy import event

    ext = ZopeTransactionExtension(
        initial_state=initial_state,         
        transaction_manager=transaction_manager,
        keep_session=keep_session,
    )

    event.listen(session, "after_begin", ext.after_begin)
    event.listen(session, "after_attach", ext.after_attach)
    event.listen(session, "after_flush", ext.after_flush)
    event.listen(session, "after_bulk_update", ext.after_bulk_update)
    event.listen(session, "after_bulk_delete", ext.after_bulk_delete)
    event.listen(session, "before_commit", ext.before_commit)
コード例 #3
0
    def edit(self, for_package_id=None, from_app_id=None):
        """ 
        Add/Edit an application record, after submission the browser
        will be redirected to the referer page
        """
        if not userinfo.is_admin():
            controller.http_redirect(controller.base_url() + '/login/')

        # We need these to fill the combo box
        # do it here to avoid autoflush later
        categories = ApplicationsCategory.query.all()

        source_package = None
        application = None
        # the app info can be loaded from an app_id or for a package id
        if from_app_id:
            application = app_by_id(from_app_id)
            if not application:
                return "Application ID not found"
        elif for_package_id:
            package_id = for_package_id
            package = Package.query.filter_by(id=package_id).one()
            if not package:
                return "Package id %d not found" % package_id
            source_package = package.source or package.package

        if source_package:  # we got a package hint
            application = Application.query.filter_by(\
                source_package = source_package).first()

        if not application:  # app was not found, create new
            application = Application()
            application.source_package = source_package

        # Automatically set app name to source package
        # usefull hint on "for_package_id"
        if not application.name:
            application.name = source_package

        # No changes here, save will be performed on edit_submit
        database.rollback()
        if sa_version.split(".") < ["0", "5", "0"]:
            database.clear()

        # Set the screenshot filename
        screenshot_filename = ""
        id = application.id
        if id:
            screenshot_filename = "/media/screens/%d/%d_t.png" % (id, id)
        return template.render("app_edit.html" \
            , application = application \
            , categories = categories \
            , screenshot_filename = screenshot_filename \
        )
コード例 #4
0
ファイル: appinfo.py プロジェクト: Nitri0/tribus
 def edit(self, for_package_id = None, from_app_id = None):
     """ 
     Add/Edit an application record, after submission the browser
     will be redirected to the referer page
     """        
     if not userinfo.is_admin():
         controller.http_redirect(controller.base_url()+'/login/')
 
     # We need these to fill the combo box
     # do it here to avoid autoflush later
     categories = ApplicationsCategory.query.all()
     
     source_package = None
     application = None
     # the app info can be loaded from an app_id or for a package id
     if from_app_id:
         application = app_by_id(from_app_id)
         if not application:
             return "Application ID not found"
     elif for_package_id:
         package_id = for_package_id
         package = Package.query.filter_by(id = package_id).one()
         if not package:
             return "Package id %d not found" % package_id
         source_package = package.source or package.package
         
     if source_package: # we got a package hint
         application = Application.query.filter_by(\
             source_package = source_package).first()
 
     if not application: # app was not found, create new
         application = Application()
         application.source_package = source_package
 
     # Automatically set app name to source package
     # usefull hint on "for_package_id"                    
     if not application.name:
         application.name = source_package        
 
     # No changes here, save will be performed on edit_submit
     database.rollback()
     if sa_version.split(".") < ["0", "5", "0"]:
         database.clear()
     
     # Set the screenshot filename
     screenshot_filename = ""
     id = application.id
     if id:
         screenshot_filename = "/media/screens/%d/%d_t.png" % (id, id)            
     return template.render("app_edit.html" \
         , application = application \
         , categories = categories \
         , screenshot_filename = screenshot_filename \
     )
コード例 #5
0
    def setup_once():
        # type: () -> None

        try:
            version = tuple(map(int, SQLALCHEMY_VERSION.split("b")[0].split(".")))
        except (TypeError, ValueError):
            raise DidNotEnable(
                "Unparsable SQLAlchemy version: {}".format(SQLALCHEMY_VERSION)
            )

        if version < (1, 2):
            raise DidNotEnable("SQLAlchemy 1.2 or newer required.")

        listen(Engine, "before_cursor_execute", _before_cursor_execute)
        listen(Engine, "after_cursor_execute", _after_cursor_execute)
        listen(Engine, "handle_error", _handle_error)
コード例 #6
0
ファイル: __init__.py プロジェクト: limodou/uliweb
def patch(patch_none='empty'):
    from sqlalchemy import __version__

    if tuple(map(int, __version__.split('.')[:2])) >= (0, 9):
        def f(func, exception=False):
            def _construct(cls, operator, continue_on, skip_on, *clauses, **kw):
                c = []
                for clause in clauses:
                    if clause is not None:
                        c.append(clause)
                    else:
                        if exception:
                            raise Exception("Found None condition, in %r" % clauses)
                return func(operator, continue_on, skip_on, *c, **kw)
            return _construct

        import sqlalchemy.sql.elements as exp
        _f = f(exp.BooleanClauseList._construct, patch_none=='exception')
        exp.BooleanClauseList._construct = classmethod(_f)
コード例 #7
0
def patch(patch_none='empty'):
    from sqlalchemy import __version__

    if tuple(map(int, __version__.split('.')[:2])) >= (0, 9):
        def f(func, exception=False):
            def _construct(cls, operator, continue_on, skip_on, *clauses, **kw):
                c = []
                for clause in clauses:
                    if clause is not None:
                        c.append(clause)
                    else:
                        if exception:
                            raise Exception("Found None condition, in %r" % clauses)
                return func(operator, continue_on, skip_on, *c, **kw)
            return _construct

        import sqlalchemy.sql.elements as exp
        _f = f(exp.BooleanClauseList._construct, patch_none=='exception')
        exp.BooleanClauseList._construct = classmethod(_f)
コード例 #8
0
ファイル: __init__.py プロジェクト: dailymuse/oz
def engine(connection_string=None):
    global _engines
    connection_string = connection_string or oz.settings["db"]

    if connection_string not in _engines:
        kwargs = dict(echo=oz.settings["debug_sql"])

        if oz.settings["db_pool_size"]:
            kwargs["pool_size"] = oz.settings["db_pool_size"]
        if oz.settings["db_max_overflow"]:
            kwargs["max_overflow"] = oz.settings["db_max_overflow"]
        if oz.settings["db_pool_timeout"]:
            kwargs["pool_timeout"] = oz.settings["db_pool_timeout"]
        if oz.settings["db_pool_pre_ping"]:
            major, minor, *patch = sa_version.split(".")
            major = int(major)
            minor = int(minor)
            if patch:
                patch, *_ = patch[0].split("b")
                patch = int(patch)
            else:
                patch = None

            # Do not cast patch, as it could be beta/alpha .. may not even exist.
            if major > 1 and (minor > 2 or (minor == 2 and patch and patch >= 3)):
                # We can use the native pool_pre_ping
                kwargs["pool_pre_ping"] = oz.settings["db_pool_pre_ping"]
            else:
                # We are on an old version of pg. Use the event-based
                # pre-ping
                event.listen(Engine, "engine_connect", _ping_connection)

        first_engine = len(_engines) == 0
        _engines[connection_string] = create_engine(connection_string, **kwargs)

        if first_engine:
            after_fork.registered = True
            register_after_fork(after_fork, after_fork)

    return _engines[connection_string]
コード例 #9
0
ファイル: datamanager.py プロジェクト: shxianju/personal_web
def register(session,
             initial_state=STATUS_ACTIVE,
             transaction_manager=zope_transaction.manager,
             keep_session=False):
    """Register ZopeTransaction listener events on the
    given Session or Session factory/class.

    This function requires at least SQLAlchemy 0.7 and makes use
    of the newer sqlalchemy.event package in order to register event listeners
    on the given Session.

    The session argument here may be a Session class or subclass, a
    sessionmaker or scoped_session instance, or a specific Session instance.
    Event listening will be specific to the scope of the type of argument
    passed, including specificity to its subclass as well as its identity.

    """

    from sqlalchemy import __version__
    assert tuple(int(x) for x in __version__.split(".")) >= (0, 7), \
        "SQLAlchemy version 0.7 or greater required to use register()"

    from sqlalchemy import event

    ext = ZopeTransactionExtension(
        initial_state=initial_state,
        transaction_manager=transaction_manager,
        keep_session=keep_session,
    )

    event.listen(session, "after_begin", ext.after_begin)
    event.listen(session, "after_attach", ext.after_attach)
    event.listen(session, "after_flush", ext.after_flush)
    event.listen(session, "after_bulk_update", ext.after_bulk_update)
    event.listen(session, "after_bulk_delete", ext.after_bulk_delete)
    event.listen(session, "before_commit", ext.before_commit)
コード例 #10
0
ファイル: models.py プロジェクト: killthrush/pybald
import json
import pickle
import zlib
from pybald.db import engine, dump_engine
from pybald.util import camel_to_underscore, pluralize

import project
# from project import mc

# from sqlalchemy.orm.interfaces import SessionExtension
from sqlalchemy.ext.mutable import Mutable

from sqlalchemy import __version__ as sa_ver

sa_maj_ver, sa_min_ver, sa_rev_ver = sa_ver.split(".")

if int(sa_min_ver) >= 7:
    from sqlalchemy.orm.attributes import flag_modified
else:
    from sqlalchemy.orm.attributes import instance_dict, NO_VALUE

    def flag_modified(instance, key):
        state, dict_ = instance_state(instance), instance_dict(instance)
        impl = state.manager[key].impl
        state.modified_event(dict_, impl, True, NO_VALUE)


session_args = {}

if project.green:
コード例 #11
0
ファイル: forms.py プロジェクト: lieryan/formalchemy
# Copyright (C) 2007 Alexandre Conrad, alexandre (dot) conrad (at) gmail (dot) com
#
# This module is part of FormAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

import cgi
import warnings
import logging
from six import string_types
logger = logging.getLogger('formalchemy.' + __name__)

MIN_SA_VERSION = '0.5'
from sqlalchemy import __version__
if __version__.split('.') < MIN_SA_VERSION.split('.'):
    raise ImportError('Version %s or later of SQLAlchemy required' %
                      MIN_SA_VERSION)

from sqlalchemy.orm.attributes import InstrumentedAttribute
from sqlalchemy.orm.properties import SynonymProperty, CompositeProperty
from sqlalchemy.orm import configure_mappers, object_session, class_mapper
from sqlalchemy.orm.session import Session
from sqlalchemy.orm.scoping import ScopedSession
from sqlalchemy.orm.dynamic import DynamicAttributeImpl
from sqlalchemy.orm.exc import UnmappedInstanceError
from sqlalchemy.util import OrderedDict
from formalchemy import multidict
try:
    from werkzeug.datastructures import MultiDict as WerkzeugMD
except ImportError:

    class WerkzeugMD:
コード例 #12
0
# -*- coding: utf-8 -*-

from cherrypy.process import plugins

from sqlalchemy import create_engine, MetaData, __version__ as sa_version
from sqlalchemy.orm import scoped_session, sessionmaker

__all__ = ['SAEnginePlugin']

if sa_version.split('.') < ['0', '7', '4']:
    raise ImportError('Version 0.7.4 or later of SQLAlchemy required.')

class SAEnginePlugin(plugins.SimplePlugin):
    """
        SQLAlchemy integration for CherryPy
        ===================================

        Usage:

        In your application configuration:

        [sqlalchemy]

        engine.url = "postgresql+psycopg2://user:password@host/db"
        engine.echo = False
        engine.echo_pool = False
        engine.pool_size = 5
        engine.pool_timeout = 30
        engine.pool_recycle = -1
        engine.max_overflow = 10
        engine.convert_unicode = False
コード例 #13
0
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program. If not, see <http://www.gnu.org/licenses/>.

import sys
import os
from collections import namedtuple
from sqlalchemy import __version__ as sql_version

sqlalchemy_version2 = ([int(x) for x in sql_version.split('.')] >= [2,0,0])

# if installed via pip this variable is set to true (empty file with name .HOMEDIR present)
HOME_CONFIG = os.path.isfile(os.path.join(os.path.dirname(os.path.abspath(__file__)), '.HOMEDIR'))

#In executables updater is not available, so variable is set to False there
UPDATER_AVAILABLE = True

# Base dir is parent of current file, necessary if called from different folder
BASE_DIR            = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),os.pardir))
STATIC_DIR          = os.path.join(BASE_DIR, 'cps', 'static')
TEMPLATES_DIR       = os.path.join(BASE_DIR, 'cps', 'templates')
TRANSLATIONS_DIR    = os.path.join(BASE_DIR, 'cps', 'translations')

if HOME_CONFIG:
    home_dir = os.path.join(os.path.expanduser("~"),".calibre-web")
コード例 #14
0
ファイル: ibm_db.py プロジェクト: rredburn/python-ibmdbsa
# | KIND, either express or implied. See the License for the specific        |
# | language governing permissions and limitations under the License.        |
# +--------------------------------------------------------------------------+
# | Authors: Alex Pitigoi, Abhigyan Agrawal, Rahul Priyadarshi               |
# | Contributors: Jaimy Azle, Mike Bayer                                     |
# +--------------------------------------------------------------------------+

from .base import DB2ExecutionContext, DB2Dialect
from sqlalchemy import processors, types as sa_types, util
from sqlalchemy import __version__ as SA_Version
from sqlalchemy.exc import ArgumentError

if util.py3k:
    long = int

SA_Version = [long(ver_token) for ver_token in SA_Version.split('.')[0:2]]

if SA_Version < [0, 8]:
    from sqlalchemy.engine.base import ResultProxy
else:
    from sqlalchemy.engine import ResultProxy


class _IBM_Numeric_ibm_db(sa_types.Numeric):
    def result_processor(self, dialect, coltype):
        if self.asdecimal:
            return None
        else:
            return processors.to_float

コード例 #15
0
If you set *echo* to True, SQLAlchemy will print the SQL statements.

*convert_unicode* should always be True and you should always
use unicode strings with SQLAlchemy!

When you are at the interpreter you can do:

    from sqlalchemy_tool import configure_session_for_app
    configure_session_for_app(your_cherrypy_app)
"""


from sqlalchemy import MetaData, create_engine, __version__ as sa_version
from sqlalchemy.orm import scoped_session, sessionmaker

if sa_version.split(".") < ["0", "5", "0"]:
    raise ImportError("Version 0.5 or later of SQLAlchemy required.")

metadata = MetaData()
session = scoped_session(sessionmaker(autoflush=True, autocommit=False))
mapper = session.mapper

# A dict in which keys are connection strings and values are SA engine objects
_engines = {}


def configure_session(dburi="sqlite:///database.sqlite", echo=False, convert_unicode=True):
    """This function is called on each request.
    Tool configuration is automatically passed to it as arguments.
    It gets a *dburi*,
    creates a corresponding SQLAlchemy engine if it doesn't exist,
コード例 #16
0
ファイル: base.py プロジェクト: ZoranPavlovic/python-ibmdbsa
"""
import datetime, re
from sqlalchemy import types as sa_types
from sqlalchemy import schema as sa_schema
from sqlalchemy import util
from sqlalchemy.sql import compiler
from sqlalchemy.sql import operators
from sqlalchemy.engine import default
from sqlalchemy import __version__ as SA_Version
from . import reflection as ibm_reflection

from sqlalchemy.types import BLOB, CHAR, CLOB, DATE, DATETIME, INTEGER,\
    SMALLINT, BIGINT, DECIMAL, NUMERIC, REAL, TIME, TIMESTAMP,\
    VARCHAR, FLOAT

SA_Version = [int(ver_token) for ver_token in SA_Version.split('.')[0:2]]

# as documented from:
# http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com.ibm.db2.udb.doc/admin/r0001095.htm
RESERVED_WORDS = set(
   ['activate', 'disallow', 'locale', 'result', 'add', 'disconnect', 'localtime',
    'result_set_locator', 'after', 'distinct', 'localtimestamp', 'return', 'alias',
    'do', 'locator', 'returns', 'all', 'double', 'locators', 'revoke', 'allocate', 'drop',
    'lock', 'right', 'allow', 'dssize', 'lockmax', 'rollback', 'alter', 'dynamic',
    'locksize', 'routine', 'and', 'each', 'long', 'row', 'any', 'editproc', 'loop',
    'row_number', 'as', 'else', 'maintained', 'rownumber', 'asensitive', 'elseif',
    'materialized', 'rows', 'associate', 'enable', 'maxvalue', 'rowset', 'asutime',
    'encoding', 'microsecond', 'rrn', 'at', 'encryption', 'microseconds', 'run',
    'attributes', 'end', 'minute', 'savepoint', 'audit', 'end-exec', 'minutes', 'schema',
    'authorization', 'ending', 'minvalue', 'scratchpad', 'aux', 'erase', 'mode', 'scroll',
    'auxiliary', 'escape', 'modifies', 'search', 'before', 'every', 'month', 'second',
コード例 #17
0
###

import logging
from zope import interface, component
from zope.publisher.interfaces import IPublisherRequest, IPublishTraverse
from z3c.traverser.interfaces import ITraverserPlugin
from z3c.traverser.traverser import PluggableTraverser

from alchemist.traversal.interfaces import IManagedContainer
from alchemist.traversal.collection import CollectionTraverser

from ore.alchemist import sa2zs, interfaces

from sqlalchemy import orm, __version__ as sa_version
sa_version = map(int, sa_version.split("."))

#

logging_setup = False

import bungeni.models.interfaces
import bungeni.ui.content

def catalyst(_context, 
        class_,
        descriptor, 
        #view_module=None, # !+?
        interface_module=bungeni.models.interfaces,
        #container_module=None, # !+?
        ui_module=bungeni.ui.content,
コード例 #18
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from sqlalchemy import create_engine, __version__ as sqlalchemy_version
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
from sqlalchemy.orm.exc import ObjectDeletedError
from sqlalchemy.orm.session import object_session
from sqlalchemy.orm import object_mapper

from cms import config

# We need version 0.7.3 because of the __abstract__ keyword.
sqlalchemy_version = tuple(int(x) for x in sqlalchemy_version.split("."))
assert sqlalchemy_version >= (0, 7, 3), \
       "Please install SQLAlchemy >= 0.7.3."

db_string = config.database.replace("%s", config.data_dir)
db = create_engine(db_string, echo=config.database_debug,
                   pool_size=20, pool_recycle=120)

Session = sessionmaker(db, twophase=config.twophase_commit)
ScopedSession = scoped_session(Session)

# For two-phases transactions:
#Session = sessionmaker(db, twophase=True)


# TODO: decide which one of the following is better.
コード例 #19
0
ファイル: util.py プロジェクト: briandailey/alembic
class CommandError(Exception):
    pass


from sqlalchemy import __version__


def _safe_int(value):
    try:
        return int(value)
    except:
        return 0


_vers = tuple([_safe_int(x) for x in __version__.split(".")])
sqla_06 = _vers > (0, 6)
sqla_07 = _vers > (0, 7)
if not sqla_06:
    raise CommandError("SQLAlchemy 0.6 or greater is required. "
                       "Version 0.7 or above required for full featureset.")


def requires_07(feature):
    if not sqla_07:
        raise CommandError("The %s feature requires "
                           "SQLAlchemy 0.7 or greater." % feature)


try:
    width = int(os.environ['COLUMNS'])
コード例 #20
0
ファイル: __init__.py プロジェクト: anyexxx/uliweb
def after_init_apps(sender):
    from uliweb import orm
    from uliweb.utils.common import import_attr
    from uliweb.core.SimpleFrame import __app_alias__

    orm.set_debug_query(settings.get_var('ORM/DEBUG_LOG'))
    orm.set_auto_create(settings.get_var('ORM/AUTO_CREATE'))
    orm.set_pk_type(settings.get_var('ORM/PK_TYPE'))
    orm.set_auto_set_model(False)
    orm.set_lazy_model_init(True)
    orm.set_check_max_length(settings.get_var('ORM/CHECK_MAX_LENGTH'))
    orm.set_nullable(settings.get_var('ORM/NULLABLE'))
    orm.set_server_default(settings.get_var('ORM/SERVER_DEFAULT'))
    orm.set_manytomany_index_reverse(
        settings.get_var('ORM/MANYTOMANY_INDEX_REVERSE'))
    convert_path = settings.get_var('ORM/TABLENAME_CONVERTER')
    convert = import_attr(convert_path) if convert_path else None
    orm.set_tablename_converter(convert)

    patch_none = settings.get_var('ORM/PATCH_NONE')
    if patch_none:
        from sqlalchemy import __version__

        if tuple(map(int, __version__.split('.')[:2])) >= (0, 9):
            import sqlalchemy.sql.elements as exp
            if patch_none == 'empty':
                exp.and_ = and_empty(exp.and_)
            elif patch_none == 'exception':
                exp.and_ = and_exception(exp.and_)

    #judge if transaction middle has not install then set
    #AUTO_DOTRANSACTION is False
    if 'transaction' in settings.MIDDLEWARES:
        orm.set_auto_transaction_in_web(True)
    else:
        orm.set_auto_transaction_in_web(
            settings.get_var('ORM/AUTO_TRANSACTION_IN_WEB'))
    orm.set_auto_transaction_in_notweb(
        settings.get_var('ORM/AUTO_TRANSACTION_IN_NOTWEB'))

    d = {
        'connection_string': settings.get_var('ORM/CONNECTION'),
        'connection_type': settings.get_var('ORM/CONNECTION_TYPE'),
        'debug_log': settings.get_var('ORM/DEBUG_LOG'),
        'connection_args': settings.get_var('ORM/CONNECTION_ARGS'),
        'strategy': settings.get_var('ORM/STRATEGY'),
    }
    orm.engine_manager.add('default', d)

    for name, d in settings.get_var('ORM/CONNECTIONS').items():
        x = {
            'connection_string': d.get('CONNECTION', ''),
            'debug_log': d.get('DEBUG_LOG', None),
            'connection_args': d.get('CONNECTION_ARGS', {}),
            'strategy': d.get('STRATEGY', 'threadlocal'),
            'connection_type': d.get('CONNECTION_TYPE', 'long'),
            'duplication': d.get('DUPLICATION', False),
        }
        orm.engine_manager.add(name, x)

    if 'MODELS_CONFIG' in settings:
        for name, v in settings.MODELS_CONFIG.items():
            orm.set_model_config(name, v)

    if 'MODELS' in settings:
        for name, model_path in settings.MODELS.items():
            if not model_path: continue
            if isinstance(model_path, (str, unicode)):
                path = model_path
            else:
                raise Exception("Model path should be a string but %r found" %
                                model_path)

            for k, v in __app_alias__.iteritems():
                if path.startswith(k):
                    path = v + path[len(k):]
                    break
            orm.set_model(path, name)
コード例 #21
0
ファイル: __init__.py プロジェクト: chenke91/uliweb
def after_init_apps(sender):
    from uliweb import orm
    from uliweb.utils.common import import_attr
    from uliweb.core.SimpleFrame import __app_alias__
    
    orm.set_debug_query(settings.get_var('ORM/DEBUG_LOG'))
    orm.set_auto_create(settings.get_var('ORM/AUTO_CREATE'))
    orm.set_pk_type(settings.get_var('ORM/PK_TYPE'))
    orm.set_auto_set_model(False)
    orm.set_lazy_model_init(True)
    orm.set_check_max_length(settings.get_var('ORM/CHECK_MAX_LENGTH'))
    orm.set_nullable(settings.get_var('ORM/NULLABLE'))
    orm.set_server_default(settings.get_var('ORM/SERVER_DEFAULT'))
    orm.set_manytomany_index_reverse(settings.get_var('ORM/MANYTOMANY_INDEX_REVERSE'))
    convert_path = settings.get_var('ORM/TABLENAME_CONVERTER')
    convert = import_attr(convert_path) if convert_path else None
    orm.set_tablename_converter(convert)
    
    patch_none = settings.get_var('ORM/PATCH_NONE')
    if patch_none:
        from sqlalchemy import __version__
        
        if tuple(map(int, __version__.split('.')[:2])) >= (0, 9):
            import sqlalchemy.sql.elements as exp
            if patch_none == 'empty':
                exp.and_ = and_empty(exp.and_)
            elif patch_none == 'exception':
                exp.and_ = and_exception(exp.and_)
    
    #judge if transaction middle has not install then set
    #AUTO_DOTRANSACTION is False
    if 'transaction' in settings.MIDDLEWARES:
        orm.set_auto_transaction_in_web(True)
    else:
        orm.set_auto_transaction_in_web(settings.get_var('ORM/AUTO_TRANSACTION_IN_WEB'))
    orm.set_auto_transaction_in_notweb(settings.get_var('ORM/AUTO_TRANSACTION_IN_NOTWEB'))
    
    d = {'connection_string':settings.get_var('ORM/CONNECTION'),
        'connection_type':settings.get_var('ORM/CONNECTION_TYPE'),
        'debug_log':settings.get_var('ORM/DEBUG_LOG'),
        'connection_args':settings.get_var('ORM/CONNECTION_ARGS'),
        'strategy':settings.get_var('ORM/STRATEGY'),
        }
    orm.engine_manager.add('default', d)
    
    for name, d in settings.get_var('ORM/CONNECTIONS').items():
        x = {'connection_string':d.get('CONNECTION', ''),
            'debug_log':d.get('DEBUG_LOG', None),
            'connection_args':d.get('CONNECTION_ARGS', {}),
            'strategy':d.get('STRATEGY', 'threadlocal'),
            'connection_type':d.get('CONNECTION_TYPE', 'long')
        }
        orm.engine_manager.add(name, x)

    if 'MODELS_CONFIG' in settings:
        for name, v in settings.MODELS_CONFIG.items():
            orm.set_model_config(name, v)
    
    if 'MODELS' in settings:
        for name, model_path in settings.MODELS.items():
            if not model_path: continue
            if isinstance(model_path, (str, unicode)):
                path = model_path
            else:
                raise Exception("Model path should be a string but %r found" % model_path)
            
            for k, v in __app_alias__.iteritems():
                if path.startswith(k):
                    path = v + path[len(k):]
                    break
            orm.set_model(path, name)
コード例 #22
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from sqlalchemy import create_engine, __version__ as sqlalchemy_version
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
from sqlalchemy.orm.exc import ObjectDeletedError
from sqlalchemy.orm.session import object_session
from sqlalchemy.orm import object_mapper

from cms import config

# We need version 0.7.3 because of the __abstract__ keyword.
sqlalchemy_version = tuple(int(x) for x in sqlalchemy_version.split("."))
assert sqlalchemy_version >= (0, 7, 3), \
       "Please install SQLAlchemy >= 0.7.3."

db_string = config.database.replace("%s", config.data_dir)
db = create_engine(db_string,
                   echo=config.database_debug,
                   pool_size=20,
                   pool_recycle=120)

Session = sessionmaker(db, twophase=config.twophase_commit)
ScopedSession = scoped_session(Session)

# For two-phases transactions:
#Session = sessionmaker(db, twophase=True)
コード例 #23
0
"""
   This module extends SQLAlchemy and provides additional DDL [#]_
   support.

   .. [#] SQL Data Definition Language
"""
import re
import warnings

import sqlalchemy
from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

_sa_version = tuple(int(re.match("\d+", x).group(0))
                    for x in _sa_version.split("."))
SQLA_07 = _sa_version >= (0, 7)
SQLA_08 = _sa_version >= (0, 8)

del re
del _sa_version

from rhodecode.lib.dbmigrate.migrate.changeset.schema import *
from rhodecode.lib.dbmigrate.migrate.changeset.constraint import *

sqlalchemy.schema.Table.__bases__ += (ChangesetTable,)
sqlalchemy.schema.Column.__bases__ += (ChangesetColumn,)
sqlalchemy.schema.Index.__bases__ += (ChangesetIndex,)

sqlalchemy.schema.DefaultClause.__bases__ += (ChangesetDefaultClause,)
コード例 #24
0
""" SqlAlchemy version tools """

from sqlalchemy import __version__ as SA_VERSION

# SqlAlchemy version tuple
SA_VERSION_TUPLE: tuple[int, ...] = tuple(map(int, SA_VERSION.split('.')))

# SqlAlchemy minor version: 1.X or 2.X
SA_VERSION_MINOR: tuple[int, int] = SA_VERSION_TUPLE[:2]  # type: ignore

# SqlAlchemy version bools
SA_13 = SA_VERSION_MINOR == (1, 3)
SA_14 = SA_VERSION_MINOR == (1, 4)
SA_20 = SA_VERSION_MINOR == (2, 0)
コード例 #25
0
ファイル: __init__.py プロジェクト: lmamsen/rhodecode
"""
   This module extends SQLAlchemy and provides additional DDL [#]_
   support.

   .. [#] SQL Data Definition Language
"""
import re
import warnings

import sqlalchemy
from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

_sa_version = tuple(int(re.match("\d+", x).group(0)) 
                    for x in _sa_version.split("."))
SQLA_06 = _sa_version >= (0, 6)
SQLA_07 = _sa_version >= (0, 7)

del re
del _sa_version

from rhodecode.lib.dbmigrate.migrate.changeset.schema import *
from rhodecode.lib.dbmigrate.migrate.changeset.constraint import *

sqlalchemy.schema.Table.__bases__ += (ChangesetTable,)
sqlalchemy.schema.Column.__bases__ += (ChangesetColumn,)
sqlalchemy.schema.Index.__bases__ += (ChangesetIndex,)

sqlalchemy.schema.DefaultClause.__bases__ += (ChangesetDefaultClause,)
コード例 #26
0
ファイル: uuid.py プロジェクト: StdCarrot/sqlalchemy-utils
from __future__ import absolute_import

import uuid

from sqlalchemy import __version__, types, util
from sqlalchemy.dialects import mssql, postgresql

from .scalar_coercible import ScalarCoercible

sqlalchemy_version = tuple([int(v) for v in __version__.split(".")])


class UUIDType(ScalarCoercible, types.TypeDecorator):
    """
    Stores a UUID in the database natively when it can and falls back to
    a BINARY(16) or a CHAR(32) when it can't.

    ::

        from sqlalchemy_utils import UUIDType
        import uuid

        class User(Base):
            __tablename__ = 'user'

            # Pass `binary=False` to fallback to CHAR instead of BINARY
            id = sa.Column(
                UUIDType(binary=False),
                primary_key=True,
                default=uuid.uuid4
            )
コード例 #27
0
ファイル: sqlalchemy_tests.py プロジェクト: neoclust/mmc
def checkSqlalchemy():
    a_version = __version__.split('.')
    if len(a_version) > 2 and str(a_version[0]) == str(SA_MAJOR) and str(a_version[1]) <= str(SA_MINOR):
        return True
    else:
        return False
コード例 #28
0
ファイル: base.py プロジェクト: svarks/bind_config_manager
# Copyright (C) 2007 Alexandre Conrad, alexandre (dot) conrad (at) gmail (dot) com
#
# This module is part of FormAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

import cgi
import warnings
import logging
logger = logging.getLogger('formalchemy.' + __name__)

MIN_SA_VERSION = '0.4.5'
from sqlalchemy import __version__
if __version__.split('.') < MIN_SA_VERSION.split('.'):
    raise ImportError('Version %s or later of SQLAlchemy required' % MIN_SA_VERSION)

from sqlalchemy.orm.attributes import InstrumentedAttribute
from sqlalchemy.orm.properties import SynonymProperty
from sqlalchemy.orm import compile_mappers, object_session, class_mapper
from sqlalchemy.orm.session import Session
from sqlalchemy.orm.scoping import ScopedSession
from sqlalchemy.orm.dynamic import DynamicAttributeImpl
from sqlalchemy.util import OrderedDict

import fields, fatypes


compile_mappers() # initializes InstrumentedAttributes


try:
    # 0.5
コード例 #29
0
###

import logging
from zope import interface, component
from zope.publisher.interfaces import IPublisherRequest, IPublishTraverse
from z3c.traverser.interfaces import ITraverserPlugin
from z3c.traverser.traverser import PluggableTraverser

from alchemist.traversal.interfaces import IManagedContainer
from alchemist.traversal.collection import CollectionTraverser

from ore.alchemist import sa2zs, interfaces

from sqlalchemy import orm, __version__ as sa_version

sa_version = map(int, sa_version.split("."))

#

logging_setup = False

import bungeni.models.interfaces
import bungeni.ui.content


def catalyst(
        _context,
        class_,
        descriptor,
        #view_module=None, # !+?
        interface_module=bungeni.models.interfaces,
コード例 #30
0
def test_sqlalchemy_version():
    assert list(map(int, __version__.split('.')[:2])) == list(VERSION_INFO[:2])
    assert __version__.split('.')[:2] == VERSION.split('.')[:2]
コード例 #31
0
ファイル: __init__.py プロジェクト: A-Tran/Indecisive
"""
   This module extends SQLAlchemy and provides additional DDL [#]_
   support.

   .. [#] SQL Data Definition Language
"""
import re
import warnings

import sqlalchemy
from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

_sa_version = tuple(int(re.match("\d+", x).group(0)) for x in _sa_version.split("."))
SQLA_07 = _sa_version >= (0, 7)
SQLA_08 = _sa_version >= (0, 8)

del re
del _sa_version

from migrate.changeset.schema import *
from migrate.changeset.constraint import *

sqlalchemy.schema.Table.__bases__ += (ChangesetTable, )
sqlalchemy.schema.Column.__bases__ += (ChangesetColumn, )
sqlalchemy.schema.Index.__bases__ += (ChangesetIndex, )

sqlalchemy.schema.DefaultClause.__bases__ += (ChangesetDefaultClause, )
コード例 #32
0
ファイル: util.py プロジェクト: Lifto/alembic
import re
import inspect
import time
import random
import uuid

class CommandError(Exception):
    pass

from sqlalchemy import __version__
def _safe_int(value):
    try:
        return int(value)
    except:
        return 0
_vers = tuple([_safe_int(x) for x in __version__.split(".")])
sqla_06 = _vers > (0, 6)
sqla_07 = _vers > (0, 7)
if not sqla_06:
    raise CommandError(
            "SQLAlchemy 0.6 or greater is required. "
            "Version 0.7 or above required for full featureset.")

def requires_07(feature):
    if not sqla_07:
        raise CommandError(
            "The %s feature requires "
            "SQLAlchemy 0.7 or greater."
            % feature
        )
try:
コード例 #33
0
"""
   This module extends SQLAlchemy and provides additional DDL [#]_
   support.

   .. [#] SQL Data Definition Language
"""
import re
import warnings

import sqlalchemy
from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

_sa_version = tuple(
    int(re.match("\d+", x).group(0)) for x in _sa_version.split("."))
SQLA_06 = _sa_version >= (0, 6)
SQLA_07 = _sa_version >= (0, 7)

del re
del _sa_version

from migrate.changeset.schema import *
from migrate.changeset.constraint import *

sqlalchemy.schema.Table.__bases__ += (ChangesetTable, )
sqlalchemy.schema.Column.__bases__ += (ChangesetColumn, )
sqlalchemy.schema.Index.__bases__ += (ChangesetIndex, )

sqlalchemy.schema.DefaultClause.__bases__ += (ChangesetDefaultClause, )
コード例 #34
0
def test_sqlalchemy_version():
    sqla_version_info = list(map(int, __version__.split('.')[:2]))
    assert sqla_version_info >= list(VERSION_INFO[:2])
    assert __version__.split('.')[:2] >= VERSION.split('.')[:2]
コード例 #35
0
def sqla_version_tuple():
    from sqlalchemy import __version__

    return tuple(int(i) for i in __version__.split("."))
コード例 #36
0
If you set *echo* to True, SQLAlchemy will print the SQL statements.

*convert_unicode* should always be True and you should always
use unicode strings with SQLAlchemy!

When you are at the interpreter you can do:

    from sqlalchemy_tool import configure_session_for_app
    configure_session_for_app(your_cherrypy_app)
'''

from sqlalchemy import MetaData, create_engine, __version__ as sa_version
from sqlalchemy.orm import scoped_session, sessionmaker

if sa_version.split(".") < ["0", "5", "0"]:
    raise ImportError("Version 0.5 or later of SQLAlchemy required.")

metadata = MetaData()
session = scoped_session(sessionmaker(autoflush=True, autocommit=False))
#mapper = session.mapper

# A dict in which keys are connection strings and values are SA engine objects
_engines = {}


def configure_session(dburi='sqlite:///database.sqlite',
                      echo=False,
                      convert_unicode=True):
    """This function is called on each request.
    Tool configuration is automatically passed to it as arguments.