'set_debug_query', 'set_auto_create', 'set_auto_set_model',

'get_model', 'set_model', 'engine_manager',

'set_auto_transaction_in_web', 'set_auto_transaction_in_notweb',

'set_tablename_converter', 'set_check_max_length', 'set_post_do',

'rawsql', 'Lazy', 'set_echo', 'Session', 'get_session', 'set_session',

'CHAR', 'BLOB', 'TEXT', 'DECIMAL', 'Index', 'datetime', 'decimal',

'Begin', 'Commit', 'Rollback', 'Reset', 'ResetAll', 'CommitAll', 'RollbackAll',

'PICKLE', 'BIGINT', 'set_pk_type', 'PKTYPE', 'FILE', 'INT', 'SMALLINT', 'DATE',

'TIME', 'DATETIME', 'FLOAT', 'BOOLEAN', 'UUID', 'BINARY', 'VARBINARY',

'JSON', 'UUID_B',

'BlobProperty', 'BooleanProperty', 'DateProperty', 'DateTimeProperty',

'TimeProperty', 'DecimalProperty', 'FloatProperty', 'SQLStorage',

'IntegerProperty', 'Property', 'StringProperty', 'CharProperty',

'TextProperty', 'UnicodeProperty', 'Reference', 'ReferenceProperty',

'PickleProperty', 'BigIntegerProperty', 'FileProperty', 'JsonProperty',

'UUIDBinaryProperty', 'UUIDProperty',

'SelfReference', 'SelfReferenceProperty', 'OneToOne', 'ManyToMany',

'ReservedWordError', 'BadValueError', 'DuplicatePropertyError',

'ModelInstanceError', 'KindError', 'ConfigurationError', 'SaveError',

'BadPropertyTypeError', 'set_lazy_model_init',

'begin_sql_monitor', 'close_sql_monitor', 'set_model_config', 'text',

'get_object', 'get_cached_object',

'set_server_default', 'set_nullable', 'set_manytomany_index_reverse',

'NotFound', 'reflect_table',

'get_field_type', 'create_model', 'get_metadata', 'migrate_tables',

'print_model', 'get_model_property',

def __init__(self, message, model, key):

self.message = message

self.model = model

self.key = key

def __str__(self):

"""

def __getattr__(self, key): return self[key]

def __setattr__(self, key, value):

if self.has_key(key):

raise SyntaxError('Object exists and cannot be redefined')

self[key] = value

global __default_tablename_converter__

c = __default_tablename_converter__

if not c:

c = lambda x:x.lower()

global Local

if not hasattr(Local, 'dispatch_send'):

Local.dispatch_send = default

global Local

Local.echo = flag

Local.echo_args = {'time':time, 'explain':explain, 'caller':caller,

if __pk_type__ == 'int':

return int

else:

if __pk_type__ == 'int':

return Integer

else:

def __init__(self, name, options):

self.name = name

d = SQLStorage({

'engine_name':name,

'connection_args':{},

'debug_log':None,

'connection_type':'long',

'duplication':False,

})

strategy = options.pop('strategy', None)

d.update(options)

if d.get('debug_log', None) is None:

d['debug_log'] = __debug_query__

if d.get('connection_type') == 'short':

d['connection_args']['poolclass'] = NullPool

if strategy:

d['connection_args']['strategy'] = strategy

self.options = d

self.engine_instance = None

self.metadata = MetaData()

self._models = {}

self.local = threading.local() #used to save thread vars

self._create()

def _get_models(self):

if self.options.duplication:

return engine_manager[self.options.duplication].models

else:

return self._models

models = property(fget=_get_models)

def _create(self, new=False):

c = self.options

db = self.engine_instance

if not self.engine_instance or new:

args = c.get('connection_args', {})

self.engine_instance = create_engine(c.get('connection_string'), **args)

self.engine_instance.echo = c['debug_log']

self.engine_instance.metadata = self.metadata

self.metadata.bind = self.engine_instance

return self.engine_instance

def session(self, create=True):

"""

if hasattr(self.local, 'session'):

return self.local.session

else:

if create:

s = Session(self.name)

self.local.session = s

return s

def set_session(self, session):

self.local.session = session

@property

def engine(self):

return self.engine_instance

def print_pool_status(self):

if self.engine.pool:

def __init__(self):

self.engines = {}

def add(self, name, connection_args):

self.engines[name] = engine = NamedEngine(name, connection_args)

return engine

def get(self, name=None):

name = name or __default_engine__

engine = self.engines.get(name)

if not engine:

raise Error('Engine %s is not exists yet' % name)

return engine

def __getitem__(self, name=None):

return self.get(name)

def __setitem__(self, name, connection_args):

return self.add(name, connection_args)

def __contains__(self, name):

return name in self.engines

def items(self):

"""

def __init__(self, engine_name=None, auto_transaction=None,

auto_close=True, post_commit=None, post_commit_once=None):

"""

self.engine_name = engine_name or __default_engine__

self.auto_transaction = auto_transaction

self.auto_close = auto_close

self.engine = engine_manager[engine_name]

self._conn = None

self._trans = None

self.local_cache = {}

self.post_commit = post_commit or []

self.post_commit_once = post_commit_once or []

def __str__(self):

return '<Session engine_name:%s, auto_transaction=%r, auto_close=%r>' % (

self.engine_name, self.auto_transaction, self.auto_close)

@property

def need_transaction(self):

from uliweb import is_in_web

global __auto_transaction_in_notweb__, __auto_transaction_in_web__

if self.auto_transaction is not None:

return self.auto_transaction

else:

#distinguish in web or not web environment

if is_in_web():

return __auto_transaction_in_web__

else:

return __auto_transaction_in_notweb__

@property

def connection(self):

if self._conn:

return self._conn

else:

self._conn = self.engine.engine.connect()

return self._conn

def execute(self, query, *args):

t = self.need_transaction

try:

if t:

self.begin()

return self.connection.execute(query, *args)

except:

if t:

self.rollback()

raise

def set_echo(self, flag, time=None, explain=False, caller=True):

global set_echo

set_echo(flag, time, explain, caller, self)

def do_(self, query, args=None):

global do_

return do_(query, self, args)

def begin(self):

if not self._trans:

self.connection

self._trans = self._conn.begin()

return self._trans

def commit(self):

if self._trans and self._conn.in_transaction():

self._trans.commit()

self._trans = None

if self.auto_close:

self._close()

#add post commit hook

if self.post_commit:

if not isinstance(self.post_commit, (list, tuple)):

self.post_commit = [self.post_commit]

for c in self.post_commit:

c()

#add post commit once hook

if self.post_commit_once:

if not isinstance(self.post_commit_once, (list, tuple)):

post_commit_once = [self.post_commit_once]

else:

post_commit_once = self.post_commit_once

self.post_commit_once = []

for c in post_commit_once:

c()

def in_transaction(self):

if not self._conn:

return False

return self._conn.in_transaction()

def rollback(self):

if self._trans and self._conn.in_transaction():

self._trans.rollback()

self._trans = None

if self.auto_close:

self._close()

def _close(self):

if self._conn:

self._conn.close()

self._conn = None

self.local_cache = {}

if self.engine.options.connection_type == 'short':

self.engine.engine.dispose()

def close(self):

self.rollback()

self._close()

def get_local_cache(self, key, creator=None):

value = self.local_cache.get(key)

if value:

return value

if callable(creator):

value = creator()

else:

value = creator

if value:

self.local_cache[key] = value

"""

engine_name = engine_name or __default_engine__

if '://' in connection:

d = {

'connection_string':connection,

'connection_args':args,

'connection_type':connection_type,

}

return engine_manager.add(engine_name, d).engine

else:

connection = connection or __default_engine__

if connection in engine_manager:

return engine_manager[connection].engine

else:

"""

dispatch.get(None, 'load_models')

engine = engine_manager[engine_name]

for tablename, m in engine.models.items():

get_model(tablename, engine_name, signal=False)

if hasattr(m, '__dynamic__') and getattr(m, '__dynamic__'):

m.table.__mapping_only__ = True

"""

ec = ec or __default_engine__

if isinstance(ec, (str, unicode)):

session = engine_manager[ec].session(create=True)

elif isinstance(ec, Session):

session = ec

else:

raise Error("Connection %r should be existed engine name or Session object" % ec)

if not session:

session = Session()

engine_manager[engine_name].set_session(session)

for k, v in engine_manager.items():

session = v.session(create=False)

if session:

"""

if isinstance(query, Result):

query = query.get_query()

ec = ec or __default_engine__

if isinstance(ec, (str, unicode)):

engine = engine_manager[ec]

dialect = engine.engine.dialect

else:

dialect = ec.dialect

if isinstance(query, (str, unicode)):

return query

#return str(query.compile(compile_kwargs={"literal_binds": True})).replace('\n', '') + ';'

comp = query.compile(dialect=dialect)

b = re_placeholder.search(comp.string)

if b:

return comp.string % comp.params

else:

if dialect.name == 'postgresql':

return comp.string

else:

params = []

for k in comp.positiontup:

v = comp.params[k]

params.append(repr(simple_value(v)))

line = comp.string.replace('?', '%s') % tuple(params)

"""

ec = ec or __default_engine__

if isinstance(ec, (str, unicode)):

return ec

elif isinstance(ec, Session):

return ec.engine_name

else:

from sqlalchemy.schema import CreateTable, CreateIndex

engine = engine_manager[engine_name].engine

M = get_model(model)

t = M.table

s = []

s.append("%s;" % str(CreateTable(t).compile(dialect=engine.dialect)).rstrip())

for x in t.indexes:

s.append("%s;" % CreateIndex(x))

sql = '\n'.join(s)

if skipblank:

return re.sub('[\t\n]+', '', sql)

else:

"""

from time import time

from uliweb.utils.common import get_caller

conn = get_session(ec)

b = time()

result = conn.execute(query, *(args or ()))

t = time() - b

dispatch.call(ec, 'post_do', query, conn, t)

flag = False

sql = ''

if hasattr(Local, 'echo') and Local.echo:

if hasattr(Local, 'echo_args'):

_ec = Local.echo_args.get('session')

else:

_ec = None

engine_name = get_engine_name(ec)

_e = get_engine_name(_ec)

if not _ec or _ec and _ec == _e:

if hasattr(Local, 'echo_args') and Local.echo_args['time']:

if t >= Local.echo_args['time']:

sql = rawsql(query)

flag = True

else:

sql = rawsql(query)

flag = True

if flag:

print '\n===>>>>> [%s]' % engine_name,

if hasattr(Local, 'echo_args') and Local.echo_args['caller']:

v = get_caller(skip=__file__)

print '(%s:%d:%s)' % v

else:

print

print sql+';'

if hasattr(Local, 'echo_args') and Local.echo_args['explain'] and sql:

r = conn.execute('explain '+sql).fetchone()

print '\n----\nExplain: %s' % ''.join(["%s=%r, " % (k, v) for k, v in r.items()])

print '===<<<<< time used %fs\n' % t

convertors=None, visitor=None, **kwargs):

"""

import csv

from uliweb.utils.common import simple_value

convertors = convertors or {}

headers = headers or {}

def convert(k, v, data):

f = convertors.get(k)

if f:

v = f(v, data)

return v

def convert_header(k):

return headers.get(k, k)

def _r(x):

if isinstance(x, (str, unicode)):

return re.sub('\r\n|\r|\n', ' ', x)

else:

return x

if isinstance(filename, (str, unicode)):

f = open(filename, 'wb')

need_close = True

else:

f = filename

need_close = False

try:

w = csv.writer(f, **kwargs)

w.writerow([simple_value(convert_header(x), encoding=encoding) for x in result.keys()])

for row in result:

if visitor and callable(visitor):

_row = visitor(result.keys, row.values(), encoding)

else:

_row = [convert(k, v, row) for k, v in zip(result.keys(), row.values())]

r = [simple_value(_r(x), encoding=encoding) for x in _row]

w.writerow(r)

finally:

if need_close:

if close:

warnings.simplefilter('default')

warnings.warn("close parameter will not need at all.", DeprecationWarning)

session = get_session(ec, False)

if session:

"""

if close:

warnings.simplefilter('default')

warnings.warn("close parameter will not need at all.", DeprecationWarning)

for k, v in engine_manager.items():

session = v.session(create=False)

if session:

if close:

warnings.simplefilter('default')

warnings.warn("close parameter will not need at all.", DeprecationWarning)

session = get_session(ec, False)

if session:

"""

if close:

warnings.simplefilter('default')

warnings.warn("close parameter will not need at all.", DeprecationWarning)

for k, v in engine_manager.items():

session = v.session(create=False)

if session:

if f in ['put', 'save', 'table', 'tablename', 'c', 'columns', 'manytomany'] or f in dir(Model):

raise ReservedWordError(

"Cannot define property using reserved word '%s'. " % f

"""

if isinstance(model, type) and issubclass(model, Model):

#use alias first

tablename = model._alias or model.tablename

tablename = tablename.lower()

#set global __models__

d = __models__.setdefault(tablename, {})

engines = d.get('config', {}).pop('engines', ['default'])

if isinstance(engines, (str, unicode)):

engines = [engines]

d['engines'] = engines

item = {}

if created is not None:

item['created'] = created

else:

item['created'] = None

if isinstance(model, (str, unicode)):

if model_path is None:

model_path = model

else:

model_path = model_path

if not appname:

appname = model.rsplit('.', 2)[0]

#for example 'uliweb.contrib.auth.models.User'

model = None

else:

appname = model.__module__.rsplit('.', 1)[0]

if model_path is None:

model_path = model.__module__ + '.' + model.__name__

else:

model_path = ''

#for example 'uliweb.contrib.auth.models'

model.__engines__ = engines

item['model'] = model

item['model_path'] = model_path

item['appname'] = appname

d['model_path'] = model_path

d['appname'] = appname

for name in engines:

if not isinstance(name, (str, unicode)):

raise BadValueError('Engine name should be string type, but %r found' % name)

"""

assert isinstance(model_name, str)

assert isinstance(config, dict)

d = __models__.setdefault(model_name, {})

if replace:

d['config'] = config

else:

c = d.setdefault('config', {})

"""

assert not props or isinstance(props, dict)

assert not indexes or isinstance(indexes, list)

props = SortedDict(props or {})

props['__dynamic__'] = True

props['__config__'] = False

for p in fields:

kwargs = p.copy()

name = kwargs.pop('name')

_type = kwargs.pop('type')

#if the key is start with '_', then remove it

for k in kwargs.keys():

if k.startswith('_'):

kwargs.pop(k, None)

field_type = get_field_type(_type)

prop = field_type(**kwargs)

props[name] = prop

if basemodel:

model = import_attr(basemodel)

# model.clear_relation()

else:

model = Model

# try:

# old = get_model(modelname, signal=False)

# old.clear_relation()

# except ModelNotFound as e:

# pass

cls = type(str(modelname.title()), (model,), props)

tablename = props.get('__tablename__', modelname)

set_model(cls, tablename, appname=__name__, model_path='')

get_model(modelname, signal=False, reload=True)

indexes = indexes or []

for x in indexes:

kwargs = x.copy()

name = kwargs.pop('name')

fields = kwargs.pop('fields')

#if the key is start with '_', then remove it

for k in kwargs.keys():

if k.startswith('_'):

kwargs.pop(k, None)

if not isinstance(fields, (list, tuple)):

raise ValueError("Index value format is not right, the value is %r" % indexes)

props = []

for y in fields:

props.append(cls.c[y])

Index(name, *props, **kwargs)

if isinstance(model, type) and issubclass(model, Model):

return True

if engine_name:

engine = engine_manager[engine_name]

return model in engine.models

else:

#check dynamic flag

if getattr(model_cls, "__dynamic__", False):

return True

#check the model_path

model_path = model_cls.__module__ + '.' + model_cls.__name__

_path = __models__.get(model_cls.tablename, {}).get('model_path', '')

if _path and model_path != _path:

return False

"""

engine_name = model.get_engine_name()

engine = engine_manager[engine_name]

"""

if isinstance(model, type) and issubclass(model, Model):

return model

if not isinstance(model, (str, unicode)):

raise Error("Model %r should be string or unicode type" % model)

#make model name is lower case

model = model.lower()

model_item = __models__.get(model)

if not model_item:

model_item = dispatch.get(None, 'find_model', model_name=model)

if model_item:

if not engine_name:

#search according model_item, and it should has only one engine defined

engines = model_item['engines']

if len(engines) > 1:

engine_name = __default_engine__

else:

engine_name = engines[0]

engine = engine_manager[engine_name]

item = engine._models.get(model)

#process duplication

if not item and engine.options.duplication:

_item = engine.models.get(model)

if _item:

item = _item.copy()

item['model'] = None

engine._models[model] = item

if item:

loaded = False #True, model is already loaded, so consider if it needs be cached

m = item['model']

m_config = __models__[model].get('config', {})

if isinstance(m, type) and issubclass(m, Model):

loaded = True

if reload:

loaded = False

#add get_model previous hook

if signal:

model_inst = dispatch.get(None, 'get_model', model_name=model, model_inst=m,

model_info=item, model_config=m_config) or m

if m is not model_inst: