signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def parse_entry(self, name):
|
<EOL>alias = name<EOL>if '<STR_LIT::>' in name:<EOL><INDENT>name, alias = name.split('<STR_LIT::>')<EOL><DEDENT>if name.endswith('<STR_LIT>'):<EOL><INDENT>need_list = True<EOL>name = name[:-<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>need_list = False<EOL><DEDENT>return alias, name, need_list<EOL>
|
Parse query entry name, just like:
{
'User[]:user'
}
'User[]:user' is an entry name.
:param name:
:return:
|
f5774:c8:m2
|
def query_schema(self, name, param):
|
alias, name, need_list = self.parse_entry(name)<EOL>if not name:<EOL><INDENT>result = self.process_multiple_query(need_list, param)<EOL><DEDENT>else:<EOL><INDENT>result = self.process_single_query(name, need_list, param)<EOL><DEDENT>return alias, result<EOL>
|
If name includes '[]', then it'll return a list
:param name: schema name
:param param: json parameters
:return:
|
f5774:c8:m3
|
def parse_condition(self, schema, name, v):
|
S = schema<EOL>col = S.get_column(name)<EOL>condition = None<EOL>if col is not None: <EOL><INDENT>if isinstance(v, (str, unicode)):<EOL><INDENT>if v.startswith('<STR_LIT>'):<EOL><INDENT>condition = (col >= eval(v[<NUM_LIT:2>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT:>>'):<EOL><INDENT>condition = (col > eval(v[<NUM_LIT:1>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT>'):<EOL><INDENT>condition = (col <= eval(v[<NUM_LIT:2>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT:<>'):<EOL><INDENT>condition = (col < eval(v[<NUM_LIT:1>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT:=>'):<EOL><INDENT>condition = (col == eval(v[<NUM_LIT:1>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT>'):<EOL><INDENT>condition = (col != eval(v[<NUM_LIT:2>:].strip()))<EOL><DEDENT>elif v.startswith('<STR_LIT>'):<EOL><INDENT>condition = col.like(v[<NUM_LIT:4>:].strip())<EOL><DEDENT>elif v.startswith('<STR_LIT>'):<EOL><INDENT>_v = eval(v[<NUM_LIT:7>:].strip())<EOL>if not isinstance(_v, (tuple, list)):<EOL><INDENT>raise ValueError("<STR_LIT>".format(v))<EOL><DEDENT>condition = (col.between(*_v))<EOL><DEDENT>elif v.startswith('<STR_LIT>'):<EOL><INDENT>condition = (col.in_(eval(v[<NUM_LIT:2>:].strip())))<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT:%>' in v: <EOL><INDENT>condition = col.like(v)<EOL><DEDENT>else:<EOL><INDENT>condition = (col == v)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(v, (tuple, list)):<EOL><INDENT>condition = (col.in_(v))<EOL><DEDENT>else:<EOL><INDENT>condition = (col == v)<EOL><DEDENT><DEDENT>return condition<EOL>
|
Parse name = 'value' to condition
:param name: column name
:param schema: schema name
:param v: column value
:return:
|
f5774:c8:m4
|
def parse_param(self, name, param):
|
S = get_schema(name)<EOL>condition = true()<EOL>fields = []<EOL>columns = []<EOL>columns_param = {}<EOL>limit = __default_limit__<EOL>order_by = []<EOL>group_by = []<EOL>total = None<EOL>page = <NUM_LIT:0><EOL>table = S.__table__<EOL>relation = None<EOL>for k, v in param.items():<EOL><INDENT>if k.startswith('<STR_LIT:@>'):<EOL><INDENT>if k == '<STR_LIT>':<EOL><INDENT>fields = v[:]<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>limit = v<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>page = v<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>if isinstance(v, (str, unicode)):<EOL><INDENT>orders = v.split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>orders = v<EOL><DEDENT>for c in orders:<EOL><INDENT>if '<STR_LIT:.>' in c:<EOL><INDENT>col_name, dir = c.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>col_name = c<EOL>dir = '<STR_LIT>'<EOL><DEDENT>col = S.get_column(col_name)<EOL>if dir == '<STR_LIT>':<EOL><INDENT>order_by.append(col.desc())<EOL><DEDENT>else:<EOL><INDENT>order_by.append(col)<EOL><DEDENT><DEDENT><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>if isinstance(v, (str, unicode)):<EOL><INDENT>groups = v.split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>groups = v<EOL><DEDENT>for c in groups:<EOL><INDENT>col = S.get_column(c)<EOL>group_by.append(col)<EOL><DEDENT><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>total = v<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>relation_key = name, v<EOL>relation = get_relation_condition(relation_key)<EOL><DEDENT><DEDENT>elif k.startswith('<STR_LIT:$>'): <EOL><INDENT>c = self.parse_condition(S, k[<NUM_LIT:1>:], v)<EOL>if c is not None:<EOL><INDENT>condition = c & condition<EOL><DEDENT><DEDENT>elif isinstance(v, dict): <EOL><INDENT>nested_alias, nested_name, nested_need_list = self.parse_entry(k)<EOL>nested_config = self.parse_param(nested_name, value)<EOL>if nested_need_list:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>relation = name, nested_config.name<EOL>outerjoin_condition = get_relation_condition(relation)<EOL>if outerjoin_condition is None:<EOL><INDENT>raise RelationError("<STR_LIT>".format(relation))<EOL><DEDENT>table.outerjoin(nested_config.table, outerjoin_condition)<EOL>condition = nested_config.condition & condition<EOL>columns.extend(nested_config.columns)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if k not in fields:<EOL><INDENT>fields.append(k)<EOL><DEDENT><DEDENT><DEDENT>columns.extend([S.get_column(x) for x in fields or S._fields_list]) <EOL>config = Storage({})<EOL>config.table = table<EOL>config.condition = condition<EOL>config.columns = columns<EOL>config.columns_param = columns_param<EOL>config.total = total<EOL>config.limit = limit<EOL>config.page = page<EOL>config.order_by = order_by<EOL>config.group_by = group_by<EOL>config.name = name<EOL>config.schema = S<EOL>config.relation = relation<EOL>return config<EOL>
|
Parse schema parameter, it'll return
{
condition
columns
limit
order_by
group_by
total
page
table
name #schema name
}
:param name: schema name
:param param: schema query parameter
:return: dict
|
f5774:c8:m5
|
def get_hexdigest(algorithm, salt, raw_password):
|
if isinstance(salt, unicode):<EOL><INDENT>salt = salt.encode('<STR_LIT:utf8>')<EOL><DEDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>import crypt<EOL><DEDENT>except ImportError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return crypt.crypt(raw_password, salt)<EOL><DEDENT>try:<EOL><INDENT>import hashlib<EOL><DEDENT>except ImportError:<EOL><INDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>import md5<EOL>return md5.new(salt + raw_password).hexdigest()<EOL><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>import sha<EOL>return sha.new(salt + raw_password).hexdigest()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if algorithm == '<STR_LIT>':<EOL><INDENT>return hashlib.md5(salt + raw_password).hexdigest()<EOL><DEDENT>elif algorithm == '<STR_LIT>':<EOL><INDENT>return hashlib.sha1(salt + raw_password).hexdigest()<EOL><DEDENT><DEDENT>raise ValueError("<STR_LIT>")<EOL>
|
Returns a string of the hexdigest of the given plaintext password and salt
using the given algorithm ('md5', 'sha1' or 'crypt').
|
f5781:m0
|
def check_password(raw_password, enc_password):
|
l = enc_password.split('<STR_LIT:$>')<EOL>if len(l)==<NUM_LIT:3>:<EOL><INDENT>algo, salt, hsh = l<EOL>return hsh == get_hexdigest(algo, salt, raw_password)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>
|
Returns a boolean of whether the raw_password was correct. Handles
encryption formats behind the scenes.
|
f5781:m1
|
def get_auth_user():
|
from uliweb import request<EOL>from uliweb import settings<EOL>user_fieldname = settings.get_var('<STR_LIT>', '<STR_LIT:id>')<EOL>session_key = _get_auth_key()<EOL>user_id = request.session.get(session_key)<EOL>if user_id:<EOL><INDENT>if isinstance(user_id, dict):<EOL><INDENT>return user_id<EOL><DEDENT>else:<EOL><INDENT>User = get_model('<STR_LIT:user>')<EOL>user = User.get(User.c[user_fieldname]==user_id)<EOL>return user<EOL><DEDENT><DEDENT>
|
Find auth user
:return: user object could be a model instance or a dict
|
f5781:m4
|
def set_user_session(user):
|
from uliweb import settings, request<EOL>user_fieldname = settings.get_var('<STR_LIT>', '<STR_LIT:id>')<EOL>share_session = settings.get_var('<STR_LIT>', False)<EOL>if isinstance(user, dict):<EOL><INDENT>user_id = user[user_fieldname]<EOL><DEDENT>else:<EOL><INDENT>user_id = getattr(user, user_fieldname)<EOL><DEDENT>if share_session:<EOL><INDENT>cache = functions.get_cache()<EOL>key = get_user_session_key(user_id)<EOL>session_id = cache.get(key, None)<EOL>log.debug('<STR_LIT>'.format(user_id, session_id, key))<EOL>if not session_id:<EOL><INDENT>request.session.save()<EOL>log.debug('<STR_LIT>'<EOL>'<STR_LIT>'.format(user_id,<EOL>request.session.key,<EOL>request.session.expiry_time))<EOL>cache.set(key, request.session.key, expire=request.session.expiry_time)<EOL><DEDENT>elif session_id != request.session.key:<EOL><INDENT>log.debug('<STR_LIT>'.format(request.session.key, session_id))<EOL>request.session.delete()<EOL>request.session.load(session_id)<EOL><DEDENT><DEDENT>if isinstance(user, dict):<EOL><INDENT>request.session[_get_auth_key()] = user<EOL><DEDENT>else:<EOL><INDENT>request.session[_get_auth_key()] = user_id<EOL><DEDENT>request.user = user<EOL>
|
Set user session
:param user: user object chould be model instance or dict
:return:
|
f5781:m6
|
def create_user(username, password, **kwargs):
|
try:<EOL><INDENT>User = get_model('<STR_LIT:user>')<EOL>user = User.get(User.c.username==username)<EOL>if user:<EOL><INDENT>return False, {'<STR_LIT:username>':"<STR_LIT>"}<EOL><DEDENT>user = User(username=username, password=password, **kwargs)<EOL>user.set_password(password)<EOL>user.save()<EOL>return True, user<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.exception(e)<EOL>return False, {'<STR_LIT:_>': "<STR_LIT>"}<EOL><DEDENT>
|
return flag, result(result can be an User object or just True, {} for errors)
|
f5781:m9
|
def login(username):
|
from uliweb.utils.date import now<EOL>from uliweb import request<EOL>User = get_model('<STR_LIT:user>')<EOL>if isinstance(username, (str, unicode)):<EOL><INDENT>user = User.get(User.c.username==username)<EOL><DEDENT>else:<EOL><INDENT>user = username<EOL><DEDENT>user.last_login = now()<EOL>user.save()<EOL>set_user_session(user)<EOL>return True<EOL>
|
return user
|
f5781:m12
|
def logout():
|
from uliweb import request<EOL>delete_user_session()<EOL>request.session.delete()<EOL>request.user = None<EOL>return True<EOL>
|
Remove the authenticated user's ID from the request.
|
f5781:m13
|
def check_password(self, raw_password):
|
return check_password(raw_password, self.password)<EOL>
|
Returns a boolean of whether the raw_password was correct. Handles
encryption formats behind the scenes.
|
f5782:c0:m1
|
def parse_translation(f, lineno):
|
line = f.readline()<EOL>def get_line(f, line, need_keys, lineno, default='<STR_LIT>'):<EOL><INDENT>line = line.rstrip()<EOL>if not line:<EOL><INDENT>return lineno, need_keys[<NUM_LIT:0>], default, line<EOL><DEDENT>key, value = line.split('<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>if key not in need_keys:<EOL><INDENT>print('<STR_LIT>' % (need_keys, lineno, line))<EOL>raise RuntimeError("<STR_LIT>")<EOL><DEDENT>v = value<EOL>while <NUM_LIT:1>:<EOL><INDENT>line = f.readline()<EOL>line = line.rstrip()<EOL>lineno += <NUM_LIT:1><EOL>if not line or line[<NUM_LIT:0>] != '<STR_LIT:">':<EOL><INDENT>break<EOL><DEDENT>v += '<STR_LIT:\n>' + line[:]<EOL><DEDENT>return lineno, key, v, line<EOL><DEDENT>comments = []<EOL>while <NUM_LIT:1>:<EOL><INDENT>if not line:<EOL><INDENT>return lineno, None, None, None<EOL><DEDENT>if line.strip() == '<STR_LIT>':<EOL><INDENT>return lineno, comments, None, None<EOL><DEDENT>elif line[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>comments.append(line[:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT>line = f.readline()<EOL>lineno += <NUM_LIT:1><EOL><DEDENT>lineno, key, msgid, line = get_line(f, line, ['<STR_LIT>'], lineno)<EOL>lineno, key, value, line = get_line(f, line, ['<STR_LIT>', '<STR_LIT>'], lineno)<EOL>if key == '<STR_LIT>':<EOL><INDENT>msgid = (msgid, value)<EOL>lineno, key, v1, line = get_line(f, line, ['<STR_LIT>'], lineno)<EOL>lineno, key, v2, line = get_line(f, line, ['<STR_LIT>'], lineno)<EOL>msgstr = (v1, v2)<EOL><DEDENT>else:<EOL><INDENT>msgstr = value<EOL><DEDENT>if line != '<STR_LIT>':<EOL><INDENT>print('<STR_LIT>' % (f.name, line))<EOL>raise RuntimeError("<STR_LIT>")<EOL><DEDENT>return lineno, comments, msgid, msgstr<EOL>
|
Read a single translation entry from the file F and return a
tuple with the comments, msgid and msgstr. The comments is returned
as a list of lines which do not end in new-lines. The msgid and
msgstr are strings, possibly with embedded newlines
|
f5788:m0
|
def split_comments(comments):
|
flags = []<EOL>other = []<EOL>for c in comments:<EOL><INDENT>if len(c) > <NUM_LIT:1> and c[<NUM_LIT:1>] == '<STR_LIT:U+002C>':<EOL><INDENT>flags.append(c)<EOL><DEDENT>else:<EOL><INDENT>other.append(c)<EOL><DEDENT><DEDENT>return flags, other<EOL>
|
Split COMMENTS into flag comments and other comments. Flag
comments are those that begin with '#,', e.g. '#,fuzzy'.
|
f5788:m1
|
def merge(file1, file2, exact=False):
|
import shutil<EOL>if not os.path.exists(file1):<EOL><INDENT>shutil.copyfile(file2, file1)<EOL>return<EOL><DEDENT>source = {}<EOL>f2 = file(file2)<EOL>lineno = <NUM_LIT:1><EOL>while <NUM_LIT:1>:<EOL><INDENT>lineno, comments, msgid, msgstr = parse_translation(f2, lineno)<EOL>if comments is None and msgid is None and msgstr is None:<EOL><INDENT>break<EOL><DEDENT>if msgid is not None and msgid != '<STR_LIT>' and msgid != ('<STR_LIT>', '<STR_LIT>') :<EOL><INDENT>source[msgid] = msgstr, split_comments(comments)[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>f2.close()<EOL>infile = file1 + '<STR_LIT>'<EOL>shutil.copyfile(file1, infile)<EOL>outfile = open(file1, '<STR_LIT:w>')<EOL>string_count = <NUM_LIT:0><EOL>update_count = <NUM_LIT:0><EOL>untranslated = <NUM_LIT:0><EOL>removed = <NUM_LIT:0><EOL>f1 = file(infile)<EOL>lineno = <NUM_LIT:1><EOL>while <NUM_LIT:1>:<EOL><INDENT>lineno, comments, msgid, msgstr = parse_translation(f1, lineno)<EOL>if comments is None and msgid is None and msgstr is None:<EOL><INDENT>break<EOL><DEDENT>if msgid is None:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>if msgid != '<STR_LIT>' and msgid != ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>string_count += <NUM_LIT:1><EOL><DEDENT>if msgid != '<STR_LIT>':<EOL><INDENT>if msgid in source:<EOL><INDENT>new_flags, comments = split_comments(comments)<EOL>new_msgstr, new_comments = source[msgid]<EOL>del source[msgid]<EOL>if (new_msgstr != msgstr and new_msgstr != '<STR_LIT>' and new_msgstr != ('<STR_LIT>', '<STR_LIT>')) or new_comments != comments:<EOL><INDENT>if new_msgstr != msgstr and new_msgstr != '<STR_LIT>' and new_msgstr != ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>update_count += <NUM_LIT:1><EOL>msgstr = new_msgstr<EOL><DEDENT>else:<EOL><INDENT>comments = new_comments<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if exact:<EOL><INDENT>removed += <NUM_LIT:1><EOL>continue<EOL><DEDENT><DEDENT><DEDENT>outfile.write(write_msg(comments, msgid, msgstr))<EOL><DEDENT>if msgid != '<STR_LIT>' and (msgstr == '<STR_LIT>' or msgstr == ('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>untranslated += <NUM_LIT:1><EOL><DEDENT><DEDENT>_len = len(source)<EOL>if _len:<EOL><INDENT>update_count += _len<EOL>string_count += _len<EOL>for msgid, _v in source.items():<EOL><INDENT>msgstr, comments = _v<EOL>outfile.write(write_msg(comments, msgid, msgstr))<EOL>if msgid != '<STR_LIT>' and msgstr == '<STR_LIT>':<EOL><INDENT>untranslated += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>f1.close()<EOL>outfile.close()<EOL>if string_count == <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(update_count, removed, untranslated, string_count,<EOL><NUM_LIT> * untranslated / string_count)))<EOL><DEDENT>
|
@param file1: target filename
@param file2: source filename
@param exact: a flag, if True, then will remove all entries existed in target
but not existed in source
|
f5788:m3
|
def containsAny(str, set):
|
return <NUM_LIT:1> in [c in str for c in set]<EOL>
|
Check whether 'str' contains ANY of the chars in 'set
|
f5789:m5
|
def _visit_pyfiles(list, dirname, names):
|
<EOL>if '<STR_LIT>' not in globals():<EOL><INDENT>global _py_ext<EOL><INDENT>_py_ext = [triple[<NUM_LIT:0>] for triple in imp.get_suffixes()<EOL>if triple[<NUM_LIT:2>] == imp.PY_SOURCE][<NUM_LIT:0>]<EOL><DEDENT>_py_ext = [triple[<NUM_LIT:0>] for triple in imp.get_suffixes()<EOL>if triple[<NUM_LIT:2>] == imp.PY_SOURCE]<EOL><DEDENT>if '<STR_LIT>' in names:<EOL><INDENT>names.remove('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in names:<EOL><INDENT>names.remove('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in names:<EOL><INDENT>names.remove('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in names:<EOL><INDENT>names.remove('<STR_LIT>')<EOL><DEDENT>list.extend(<EOL>[os.path.join(dirname, file) for file in names<EOL>if os.path.splitext(file)[<NUM_LIT:1>] in _py_ext]<EOL>)<EOL>
|
Helper for getFilesForName().
|
f5789:m6
|
def _get_modpkg_path(dotted_name, pathlist=None):
|
<EOL>parts = dotted_name.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>file, pathname, description = imp.find_module(parts[<NUM_LIT:0>], pathlist)<EOL>if file: file.close()<EOL><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>if description[<NUM_LIT:2>] == imp.PKG_DIRECTORY:<EOL><INDENT>pathname = _get_modpkg_path(parts[<NUM_LIT:1>], [pathname])<EOL><DEDENT>else:<EOL><INDENT>pathname = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>file, pathname, description = imp.find_module(<EOL>dotted_name, pathlist)<EOL>if file:<EOL><INDENT>file.close()<EOL><DEDENT>if description[<NUM_LIT:2>] not in [imp.PY_SOURCE, imp.PKG_DIRECTORY]:<EOL><INDENT>pathname = None<EOL><DEDENT><DEDENT>except ImportError:<EOL><INDENT>pathname = None<EOL><DEDENT><DEDENT>return pathname<EOL>
|
Get the filesystem path for a module or a package.
Return the file system path to a file for a module, and to a directory for
a package. Return None if the name is not found, or is a builtin or
extension module.
|
f5789:m7
|
def getFilesForName(name):
|
if not os.path.exists(name):<EOL><INDENT>if containsAny(name, "<STR_LIT>"):<EOL><INDENT>files = glob.glob(name)<EOL>list = []<EOL>for file in files:<EOL><INDENT>list.extend(getFilesForName(file))<EOL><DEDENT>return list<EOL><DEDENT>name = _get_modpkg_path(name)<EOL>if not name:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>if os.path.isdir(name):<EOL><INDENT>list = []<EOL>os.path.walk(name, _visit_pyfiles, list)<EOL>return list<EOL><DEDENT>elif os.path.exists(name):<EOL><INDENT>return [name]<EOL><DEDENT>return []<EOL>
|
Get a list of module files for a filename, a module or package name,
or a directory.
|
f5789:m8
|
def encode_basestring(s):
|
def replace(match):<EOL><INDENT>return ESCAPE_DCT[match.group(<NUM_LIT:0>)]<EOL><DEDENT>return '<STR_LIT:">' + ESCAPE.sub(replace, s) + '<STR_LIT:">'<EOL>
|
Return a JSON representation of a Python string
|
f5800:m0
|
def encode_unicode(s):
|
return '<STR_LIT:">' + s.encode('<STR_LIT>') + '<STR_LIT:">'<EOL>
|
Return a JSON representation of a Python unicode
|
f5800:m1
|
def jsonp(data, **json_kwargs):
|
from uliweb import request<EOL>if '<STR_LIT>' in json_kwargs:<EOL><INDENT>cb = json_kwargs.pop('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>cb = '<STR_LIT>'<EOL><DEDENT>begin = str(request.GET.get(cb))<EOL>if not begin:<EOL><INDENT>raise BadRequest("<STR_LIT>" % cb)<EOL><DEDENT>if not r_callback.match(begin):<EOL><INDENT>raise BadRequest("<STR_LIT>")<EOL><DEDENT>if callable(data):<EOL><INDENT>@wraps(data)<EOL>def f(*arg, **kwargs):<EOL><INDENT>ret = data(*arg, **kwargs)<EOL>return Response(begin + '<STR_LIT:(>' + json_dumps(ret) + '<STR_LIT>', **json_kwargs)<EOL><DEDENT>return f<EOL><DEDENT>else:<EOL><INDENT>return Response(begin + '<STR_LIT:(>' + json_dumps(data) + '<STR_LIT>', **json_kwargs)<EOL><DEDENT>
|
jsonp is callback key name
|
f5802:m5
|
def CORS(func=None):
|
def w(r=None):<EOL><INDENT>from uliweb import request, response<EOL>if request.method == '<STR_LIT>':<EOL><INDENT>response = Response(status=<NUM_LIT>)<EOL>response.headers['<STR_LIT>'] = '<STR_LIT:true>'<EOL>response.headers['<STR_LIT>'] = request.headers['<STR_LIT>']<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = <NUM_LIT>*<NUM_LIT><EOL>response.headers['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = <NUM_LIT:0><EOL>return response<EOL><DEDENT>elif request.method in ('<STR_LIT:GET>', '<STR_LIT:POST>'):<EOL><INDENT>if isinstance(r, Response):<EOL><INDENT>response = r<EOL><DEDENT>response.headers['<STR_LIT>'] = '<STR_LIT:true>'<EOL>if '<STR_LIT>' in request.headers:<EOL><INDENT>response.headers['<STR_LIT>'] = request.headers['<STR_LIT>']<EOL><DEDENT>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT><DEDENT>if callable(func):<EOL><INDENT>@wraps(func)<EOL>def f(*arg, **kwargs):<EOL><INDENT>if request.method == '<STR_LIT>':<EOL><INDENT>return w()<EOL><DEDENT>ret = func(*arg, **kwargs)<EOL>w(ret)<EOL>return ret<EOL><DEDENT>return f<EOL><DEDENT>else:<EOL><INDENT>w()<EOL><DEDENT>
|
CORS support
|
f5802:m6
|
def get_url_adapter(_domain_name):
|
from werkzeug._compat import wsgi_decoding_dance<EOL>domain = application.domains.get(_domain_name, {})<EOL>server_name = None<EOL>if domain.get('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>server_name = domain['<STR_LIT>']<EOL>try:<EOL><INDENT>env = {}<EOL>environ = request.environ<EOL>env['<STR_LIT>'] = environ['<STR_LIT>']<EOL>env['<STR_LIT>'] = environ['<STR_LIT>']<EOL>def _get_wsgi_string(name):<EOL><INDENT>val = environ.get(name)<EOL>if val is not None:<EOL><INDENT>return wsgi_decoding_dance(val, "<STR_LIT:utf-8>")<EOL><DEDENT><DEDENT>env['<STR_LIT>'] = _get_wsgi_string('<STR_LIT>')<EOL>env['<STR_LIT>'] = _get_wsgi_string('<STR_LIT>')<EOL>env['<STR_LIT>'] = _get_wsgi_string('<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>env = {}<EOL><DEDENT>adapter = url_map.bind(server_name, **env)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>env = request.environ<EOL><DEDENT>except:<EOL><INDENT>env = {<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:127.0.0.1>',<EOL>'<STR_LIT>': '<STR_LIT:GET>',<EOL>'<STR_LIT>': '<STR_LIT:/>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:localhost>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': '<STR_LIT:http>',<EOL>'<STR_LIT>': (<NUM_LIT:1>, <NUM_LIT:0>),<EOL>}<EOL><DEDENT>adapter = url_map.bind_to_environ(env)<EOL><DEDENT>return adapter<EOL>
|
Fetch a domain url_adapter object, and bind it to according domain
|
f5802:m10
|
def get_app_dir(app):
|
path = __app_dirs__.get(app)<EOL>if path is not None:<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>p = app.split('<STR_LIT:.>')<EOL>try:<EOL><INDENT>path = pkg.resource_filename(p[<NUM_LIT:0>], '<STR_LIT>')<EOL><DEDENT>except ImportError as e:<EOL><INDENT>log.error("<STR_LIT>" % app)<EOL>log.exception(e)<EOL>path = '<STR_LIT>'<EOL><DEDENT>if len(p) > <NUM_LIT:1>:<EOL><INDENT>path = os.path.join(path, *p[<NUM_LIT:1>:])<EOL><DEDENT>__app_dirs__[app] = path<EOL>return path<EOL><DEDENT>
|
Get an app's directory
|
f5802:m14
|
def set_var(key, value):
|
from uliweb import settings<EOL>settings.set_var(key, value)<EOL>
|
Default set_var function
|
f5802:m16
|
def get_var(key, default=None):
|
from uliweb import settings<EOL>return settings.get_var(key, default)<EOL>
|
Default get_var function
|
f5802:m17
|
def json(self):
|
return jsn.loads(self.data)<EOL>
|
Return json data, need front send json data
:return: dict
|
f5802:c1:m0
|
def get(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT:GET>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to GET.
|
f5802:c5:m2
|
def patch(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to PATCH.
|
f5802:c5:m3
|
def post(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT:POST>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to POST.
|
f5802:c5:m4
|
def head(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to HEAD.
|
f5802:c5:m5
|
def put(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to PUT.
|
f5802:c5:m6
|
def delete(self, *args, **kw):
|
kw['<STR_LIT>'] = '<STR_LIT>'<EOL>return self.open(*args, **kw)<EOL>
|
Like open but method is enforced to DELETE.
|
f5802:c5:m7
|
def get_file(self, filename, dir='<STR_LIT>'):
|
if os.path.exists(filename):<EOL><INDENT>return filename<EOL><DEDENT>dirs = self.apps<EOL>if dir:<EOL><INDENT>fname = os.path.join(dir, filename)<EOL><DEDENT>else:<EOL><INDENT>fname = filename<EOL><DEDENT>for d in reversed(dirs):<EOL><INDENT>path = pkg.resource_filename(d, fname)<EOL>if os.path.exists(path):<EOL><INDENT>return path<EOL><DEDENT><DEDENT>return None<EOL>
|
get_file will search from apps directory
|
f5802:c7:m5
|
def install_global_objects(self):
|
import uliweb<EOL>for k, v in settings.GLOBAL_OBJECTS.items():<EOL><INDENT>setattr(uliweb, k, import_attr(v))<EOL><DEDENT>
|
Process [GLOBAL_OBJECTS], and inject all object to uliweb module, so
user can import from uliweb
|
f5802:c7:m26
|
def get_config(self, config_filename):
|
x = pyini.Ini(lazy=True, basepath=os.path.join(self.project_dir, '<STR_LIT>'))<EOL>for p in reversed(self.apps):<EOL><INDENT>app_path = get_app_dir(p)<EOL>filename = os.path.join(app_path, config_filename)<EOL>if os.path.exists(filename):<EOL><INDENT>x.read(filename)<EOL><DEDENT><DEDENT>x.freeze()<EOL>return x<EOL>
|
Collection all config file in all available apps, and merge them into ini object
:return: ini object
|
f5802:c7:m32
|
def get_template_dirs(self):
|
def if_not_empty(dir):<EOL><INDENT>if not os.path.exists(dir):<EOL><INDENT>return<EOL><DEDENT>for root, dirs, files in os.walk(dir):<EOL><INDENT>if dirs:<EOL><INDENT>return True<EOL><DEDENT>for f in files:<EOL><INDENT>if f != '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>template_dirs = [os.path.join(self.project_dir, x) for x in settings.GLOBAL.TEMPLATE_DIRS or []]<EOL>taglibs_dirs = []<EOL>for p in reversed(self.apps):<EOL><INDENT>app_path = get_app_dir(p)<EOL>path = os.path.join(app_path, '<STR_LIT>')<EOL>if if_not_empty(path):<EOL><INDENT>template_dirs.append(path)<EOL><DEDENT>path = os.path.join(app_path, '<STR_LIT>')<EOL>if if_not_empty(path):<EOL><INDENT>taglibs_dirs.append(path)<EOL><DEDENT><DEDENT>Dispatcher.template_dirs = template_dirs<EOL>Dispatcher.taglibs_dirs = taglibs_dirs<EOL>
|
Get templates directory from apps, but in reversed order, so the same named template
file will be overrided by latter defined app
|
f5802:c7:m33
|
def handle_default_options(options):
|
if options.pythonpath:<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, options.pythonpath)<EOL><DEDENT>
|
Include any default options that all commands should accept here
so that ManagementUtility can handle them before searching for
user commands.
|
f5803:m0
|
def get_answer(message, answers='<STR_LIT>', default='<STR_LIT:Y>', quit='<STR_LIT>'):
|
if quit and quit not in answers:<EOL><INDENT>answers = answers + quit<EOL><DEDENT>message = message + '<STR_LIT:(>' + '<STR_LIT:/>'.join(answers) + '<STR_LIT>' + default + '<STR_LIT>'<EOL>ans = input(message).strip().upper()<EOL>if default and not ans:<EOL><INDENT>ans = default.upper()<EOL><DEDENT>while ans not in answers.upper():<EOL><INDENT>ans = input(message).strip().upper()<EOL><DEDENT>if quit and ans == quit.upper():<EOL><INDENT>print("<STR_LIT>")<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>return ans<EOL>
|
Get an answer from stdin, the answers should be 'Y/n' etc.
If you don't want the user can quit in the loop, then quit should be None.
|
f5803:m1
|
def get_commands(mod):
|
import inspect<EOL>import types<EOL>commands = {}<EOL>def check(c):<EOL><INDENT>return (inspect.isclass(c) and<EOL>issubclass(c, Command) and c is not Command and not issubclass(c, CommandManager))<EOL><DEDENT>for name in dir(mod):<EOL><INDENT>c = getattr(mod, name)<EOL>if check(c):<EOL><INDENT>commands[c.name] = c<EOL><DEDENT><DEDENT>return commands<EOL>
|
Find commands from a module
|
f5803:m2
|
def get_input(prompt, default=None, choices=None, option_value=None):
|
if option_value is not None:<EOL><INDENT>return option_value<EOL><DEDENT>choices = choices or []<EOL>while <NUM_LIT:1>:<EOL><INDENT>r = input(prompt+'<STR_LIT:U+0020>').strip()<EOL>if not r and default is not None:<EOL><INDENT>return default<EOL><DEDENT>if choices:<EOL><INDENT>if r not in choices:<EOL><INDENT>r = None<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return r<EOL>
|
If option_value is not None, then return it. Otherwise get the result from
input.
|
f5803:m3
|
def create_parser(self, prog_name, subcommand):
|
return OptionParser(prog=prog_name,<EOL>usage=self.usage(subcommand),<EOL>version='<STR_LIT>',<EOL>add_help_option = False,<EOL>option_list=self.option_list)<EOL>
|
Create and return the ``OptionParser`` which will be used to
parse the arguments to this command.
|
f5803:c2:m0
|
def usage(self, subcommand):
|
if len(self.option_list) > <NUM_LIT:0>:<EOL><INDENT>usage = '<STR_LIT>' % (subcommand, self.args)<EOL><DEDENT>else:<EOL><INDENT>usage = '<STR_LIT>' % (subcommand, self.args)<EOL><DEDENT>if self.help:<EOL><INDENT>return '<STR_LIT>' % (usage, self.help)<EOL><DEDENT>else:<EOL><INDENT>return usage<EOL><DEDENT>
|
Return a brief description of how to use this command, by
default from the attribute ``self.help``.
|
f5803:c2:m2
|
def print_help(self, prog_name, subcommand):
|
parser = self.create_parser(prog_name, subcommand)<EOL>parser.print_help()<EOL>
|
Print the help message for this command, derived from
``self.usage()``.
|
f5803:c2:m3
|
def run_from_argv(self, prog, subcommand, global_options, argv):
|
self.prog_name = prog<EOL>if self.skip_options:<EOL><INDENT>parser = NewOptionParser(prog=self.prog_name,<EOL>usage=self.usage(subcommand),<EOL>version='<STR_LIT>',<EOL>formatter = NewFormatter(),<EOL>add_help_option = False,<EOL>option_list=self.option_list)<EOL><DEDENT>else:<EOL><INDENT>parser = self.create_parser(prog, subcommand)<EOL><DEDENT>options, args = parser.parse_args(argv)<EOL>self.execute(args, options, global_options)<EOL>
|
Set up any environment changes requested, then run this command.
|
f5803:c2:m6
|
def handle(self, options, global_options, *args):
|
raise NotImplementedError()<EOL>
|
The actual logic of the command. Subclasses must implement
this method.
|
f5803:c2:m8
|
def print_help_info(self, global_options):
|
usage = ['<STR_LIT>',"<STR_LIT>" % self.prog_name,'<STR_LIT>']<EOL>usage.append('<STR_LIT>')<EOL>commands = list(self.get_commands(global_options).keys())<EOL>commands.sort()<EOL>for cmd in commands:<EOL><INDENT>usage.append('<STR_LIT>' % cmd)<EOL><DEDENT>return '<STR_LIT:\n>'.join(usage)<EOL>
|
Returns the script's main help text, as a string.
|
f5803:c5:m2
|
def fetch_command(self, global_options, subcommand):
|
commands = self.get_commands(global_options)<EOL>try:<EOL><INDENT>klass = commands[subcommand]<EOL><DEDENT>except KeyError:<EOL><INDENT>sys.stderr.write("<STR_LIT>" %(subcommand, self.prog_name))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return klass<EOL>
|
Tries to fetch the given subcommand, printing a message with the
appropriate command called from the command line (usually
"uliweb") if it can't be found.
|
f5803:c5:m3
|
def execute(self, callback=None):
|
<EOL>self.parser = parser = NewOptionParser(prog=self.prog_name,<EOL>usage=self.usage_info,<EOL>version=self.get_version(),<EOL>formatter = NewFormatter(),<EOL>add_help_option = False,<EOL>option_list=self.option_list)<EOL>if not self.global_options:<EOL><INDENT>global_options, args = parser.parse_args(self.argv)<EOL>global_options.apps_dir = os.path.normpath(os.path.join(global_options.project, '<STR_LIT>'))<EOL>handle_default_options(global_options)<EOL>args = args[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>global_options = self.global_options<EOL>args = self.argv<EOL><DEDENT>if global_options.envs:<EOL><INDENT>for x in global_options.envs:<EOL><INDENT>if '<STR_LIT:=>' in x:<EOL><INDENT>k, v = x.split('<STR_LIT:=>')<EOL>os.environ[k.strip()] = v.strip()<EOL><DEDENT>else:<EOL><INDENT>print(('<STR_LIT>'<EOL>'<STR_LIT>' % x))<EOL><DEDENT><DEDENT><DEDENT>global_options.settings = global_options.settings or os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>global_options.local_settings = global_options.local_settings or os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>if callback:<EOL><INDENT>callback(global_options)<EOL><DEDENT>if len(args) == <NUM_LIT:0>:<EOL><INDENT>if global_options.version:<EOL><INDENT>print(self.get_version())<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>self.print_help(global_options)<EOL>sys.ext(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>self.do_command(args, global_options)<EOL>
|
Given the command-line arguments, this figures out which subcommand is
being run, creates a parser appropriate to that command, and runs it.
|
f5803:c5:m4
|
def set_urlroute_rules(rules=None):
|
global __url_route_rules__<EOL>__url_route_rules__ = []<EOL>for k, v in (rules or {}).values():<EOL><INDENT>__url_route_rules__.append((re.compile(k), v))<EOL><DEDENT>
|
rules should be (pattern, replace)
e.g.: ('/admin', '/demo')
|
f5804:m4
|
def to_attrs(args, nocreate_if_none=['<STR_LIT:id>', '<STR_LIT>', '<STR_LIT:class>']):
|
if not args:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>s = ['<STR_LIT>']<EOL>for k, v in sorted(args.items()):<EOL><INDENT>k = u_str(k)<EOL>v = u_str(v)<EOL>if k.startswith('<STR_LIT:_>'):<EOL><INDENT>k = k[<NUM_LIT:1>:]<EOL><DEDENT>if v is None:<EOL><INDENT>if k not in nocreate_if_none:<EOL><INDENT>s.append(k)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if k.lower() in __noescape_attrs__:<EOL><INDENT>t = u_str(v)<EOL><DEDENT>else:<EOL><INDENT>t = cgi.escape(u_str(v))<EOL><DEDENT>t = '<STR_LIT>' % t.replace('<STR_LIT:">', '<STR_LIT>')<EOL>s.append('<STR_LIT>' % (k, t))<EOL><DEDENT><DEDENT>return '<STR_LIT:U+0020>'.join(s)<EOL>
|
Make python dict to k="v" format
|
f5805:m2
|
def xhtml_escape(value):
|
return _XHTML_ESCAPE_RE.sub(lambda match: _XHTML_ESCAPE_DICT[match.group(<NUM_LIT:0>)],<EOL>to_basestring(value))<EOL>
|
Escapes a string so it is valid within HTML or XML.
Escapes the characters ``<``, ``>``, ``"``, ``'``, and ``&``.
When used in attribute values the escaped strings must be enclosed
in quotes.
.. versionchanged:: 3.2
Added the single quote to the list of escaped characters.
|
f5806:m0
|
def xhtml_unescape(value):
|
return re.sub(r"<STR_LIT>", _convert_entity, _unicode(value))<EOL>
|
Un-escapes an XML-escaped string.
|
f5806:m1
|
def json_encode(value):
|
<EOL>return json.dumps(value).replace("<STR_LIT>", "<STR_LIT>")<EOL>
|
JSON-encodes the given Python object.
|
f5806:m2
|
def json_decode(value):
|
return json.loads(to_basestring(value))<EOL>
|
Returns Python objects for the given JSON string.
|
f5806:m3
|
def squeeze(value):
|
return re.sub(r"<STR_LIT>", "<STR_LIT:U+0020>", value).strip()<EOL>
|
Replace all sequences of whitespace chars with a single space.
|
f5806:m4
|
def url_escape(value, plus=True):
|
quote = urllib_parse.quote_plus if plus else urllib_parse.quote<EOL>return quote(utf8(value))<EOL>
|
Returns a URL-encoded version of the given value.
If ``plus`` is true (the default), spaces will be represented
as "+" instead of "%20". This is appropriate for query strings
but not for the path component of a URL. Note that this default
is the reverse of Python's urllib module.
.. versionadded:: 3.1
The ``plus`` argument
|
f5806:m5
|
def utf8(value):
|
if isinstance(value, _UTF8_TYPES):<EOL><INDENT>return value<EOL><DEDENT>elif isinstance(value, unicode_type):<EOL><INDENT>return value.encode("<STR_LIT:utf-8>")<EOL><DEDENT>else:<EOL><INDENT>return str(value)<EOL><DEDENT>
|
Converts a string argument to a byte string.
If the argument is already a byte string or None, it is returned unchanged.
Otherwise it must be a unicode string and is encoded as utf8.
|
f5806:m6
|
def to_unicode(value):
|
if isinstance(value, _TO_UNICODE_TYPES):<EOL><INDENT>return value<EOL><DEDENT>if not isinstance(value, bytes_type):<EOL><INDENT>raise TypeError(<EOL>"<STR_LIT>" % type(value)<EOL>)<EOL><DEDENT>return value.decode("<STR_LIT:utf-8>")<EOL>
|
Converts a string argument to a unicode string.
If the argument is already a unicode string or None, it is returned
unchanged. Otherwise it must be a byte string and is decoded as utf8.
|
f5806:m7
|
def to_basestring(value):
|
if value is None:<EOL><INDENT>return '<STR_LIT:None>'<EOL><DEDENT>if isinstance(value, _BASESTRING_TYPES):<EOL><INDENT>return value<EOL><DEDENT>elif isinstance(value, unicode_type):<EOL><INDENT>return value.decode("<STR_LIT:utf-8>")<EOL><DEDENT>else:<EOL><INDENT>return str(value)<EOL><DEDENT>
|
Converts a string argument to a subclass of basestring.
In python2, byte and unicode strings are mostly interchangeable,
so functions that deal with a user-supplied argument in combination
with ascii string constants can use either and should return the type
the user supplied. In python3, the two types are not interchangeable,
so this method is needed to convert byte strings to unicode.
|
f5806:m8
|
def recursive_unicode(obj):
|
if isinstance(obj, dict):<EOL><INDENT>return dict((recursive_unicode(k), recursive_unicode(v)) for (k, v) in obj.items())<EOL><DEDENT>elif isinstance(obj, list):<EOL><INDENT>return list(recursive_unicode(i) for i in obj)<EOL><DEDENT>elif isinstance(obj, tuple):<EOL><INDENT>return tuple(recursive_unicode(i) for i in obj)<EOL><DEDENT>elif isinstance(obj, bytes_type):<EOL><INDENT>return to_unicode(obj)<EOL><DEDENT>else:<EOL><INDENT>return obj<EOL><DEDENT>
|
Walks a simple data structure, converting byte strings to unicode.
Supports lists, tuples, and dictionaries.
|
f5806:m9
|
def linkify(text, shorten=False, extra_params="<STR_LIT>",<EOL>require_protocol=False, permitted_protocols=["<STR_LIT:http>", "<STR_LIT>"]):
|
if extra_params and not callable(extra_params):<EOL><INDENT>extra_params = "<STR_LIT:U+0020>" + extra_params.strip()<EOL><DEDENT>def make_link(m):<EOL><INDENT>url = m.group(<NUM_LIT:1>)<EOL>proto = m.group(<NUM_LIT:2>)<EOL>if require_protocol and not proto:<EOL><INDENT>return url <EOL><DEDENT>if proto and proto not in permitted_protocols:<EOL><INDENT>return url <EOL><DEDENT>href = m.group(<NUM_LIT:1>)<EOL>if not proto:<EOL><INDENT>href = "<STR_LIT>" + href <EOL><DEDENT>if callable(extra_params):<EOL><INDENT>params = "<STR_LIT:U+0020>" + extra_params(href).strip()<EOL><DEDENT>else:<EOL><INDENT>params = extra_params<EOL><DEDENT>max_len = <NUM_LIT:30><EOL>if shorten and len(url) > max_len:<EOL><INDENT>before_clip = url<EOL>if proto:<EOL><INDENT>proto_len = len(proto) + <NUM_LIT:1> + len(m.group(<NUM_LIT:3>) or "<STR_LIT>") <EOL><DEDENT>else:<EOL><INDENT>proto_len = <NUM_LIT:0><EOL><DEDENT>parts = url[proto_len:].split("<STR_LIT:/>")<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>url = url[:proto_len] + parts[<NUM_LIT:0>] + "<STR_LIT:/>" +parts[<NUM_LIT:1>][:<NUM_LIT:8>].split('<STR_LIT:?>')[<NUM_LIT:0>].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL><DEDENT>if len(url) > max_len * <NUM_LIT>: <EOL><INDENT>url = url[:max_len]<EOL><DEDENT>if url != before_clip:<EOL><INDENT>amp = url.rfind('<STR_LIT:&>')<EOL>if amp > max_len - <NUM_LIT:5>:<EOL><INDENT>url = url[:amp]<EOL><DEDENT>url += "<STR_LIT>"<EOL>if len(url) >= len(before_clip):<EOL><INDENT>url = before_clip<EOL><DEDENT>else:<EOL><INDENT>params += '<STR_LIT>' % href<EOL><DEDENT><DEDENT><DEDENT>return u('<STR_LIT>') % (href, params, url)<EOL><DEDENT>text = _unicode(xhtml_escape(text))<EOL>return _URL_RE.sub(make_link, text)<EOL>
|
Converts plain text into HTML with links.
For example: ``linkify("Hello http://tornadoweb.org!")`` would return
``Hello <a href="http://tornadoweb.org">http://tornadoweb.org</a>!``
Parameters:
* ``shorten``: Long urls will be shortened for display.
* ``extra_params``: Extra text to include in the link tag, or a callable
taking the link as an argument and returning the extra text
e.g. ``linkify(text, extra_params='rel="nofollow" class="external"')``,
or::
def extra_params_cb(url):
if url.startswith("http://example.com"):
return 'class="internal"'
else:
return 'class="external" rel="nofollow"'
linkify(text, extra_params=extra_params_cb)
* ``require_protocol``: Only linkify urls which include a protocol. If
this is False, urls such as www.facebook.com will also be linkified.
* ``permitted_protocols``: List (or set) of protocols which should be
linkified, e.g. ``linkify(text, permitted_protocols=["http", "ftp",
"mailto"])``. It is very unsafe to include protocols such as
``javascript``.
|
f5806:m10
|
def __init__(self, template_string,<EOL>begin_tag=BEGIN_TAG, end_tag=END_TAG,<EOL>name="<STR_LIT>", loader=None,<EOL>compress_whitespace=None, filename=None,<EOL>_compile=None, debug=False, see=None,<EOL>skip_extern=False, log=None, multilines=False,<EOL>comment=True):
|
self.name = name<EOL>self.begin_tag = begin_tag<EOL>self.end_tag = end_tag<EOL>self.filename = filename or self.name<EOL>self._compile = _compile or compile<EOL>self.debug = debug<EOL>self.see = see<EOL>self.has_links = False<EOL>self.skip_extern = skip_extern<EOL>self.log = log<EOL>self.multilines = multilines<EOL>self.comment = comment<EOL>if compress_whitespace is None:<EOL><INDENT>compress_whitespace = name.endswith("<STR_LIT>") orname.endswith("<STR_LIT>")<EOL><DEDENT>self.autoescape = None<EOL>self.namespace = loader.namespace if loader else {}<EOL>self.depends = {} <EOL>reader = _TemplateReader(name, native_str(template_string))<EOL>self.file = _File(self, _parse(reader, self, begin_tag=self.begin_tag,<EOL>end_tag=self.end_tag, debug=self.debug,<EOL>see=self.see))<EOL>self.code = self._generate_python(loader, compress_whitespace)<EOL>self.loader = loader<EOL>try:<EOL><INDENT>self.compiled = self._compile(<EOL>to_unicode(self.code),<EOL>self.name,<EOL>"<STR_LIT>", dont_inherit=True)<EOL>self.compiled_time = time()<EOL><DEDENT>except Exception:<EOL><INDENT>formatted_code = _format_code(self.code).rstrip()<EOL>if self.log:<EOL><INDENT>self.log.error("<STR_LIT>", self.name, formatted_code)<EOL><DEDENT>raise<EOL><DEDENT>
|
:param filename: used to store the real filename
|
f5806:c1:m0
|
def generate(self, vars=None, env=None):
|
def defined(v, default=None):<EOL><INDENT>_v = default<EOL>if v in vars:<EOL><INDENT>_v = vars[v]<EOL><DEDENT>elif v in env:<EOL><INDENT>_v = env[v]<EOL><DEDENT>return _v<EOL><DEDENT>namespace = {<EOL>"<STR_LIT>": defined,<EOL>"<STR_LIT>": self.name.replace('<STR_LIT:.>', '<STR_LIT:_>'),<EOL>"<STR_LIT>": ObjectDict(get_source=lambda name: self.code),<EOL>}<EOL>namespace.update(default_namespace)<EOL>namespace.update(env or {})<EOL>namespace.update(self.namespace)<EOL>namespace.update(vars or {})<EOL>namespace['<STR_LIT>'] = vars<EOL>exec_in(self.compiled, namespace)<EOL>execute = namespace["<STR_LIT>"]<EOL>linecache.clearcache()<EOL>return execute()<EOL>
|
Generate this template with the given arguments.
|
f5806:c1:m1
|
def clear(self):
|
self.__values.clear()<EOL>self.__access_keys = []<EOL>self.__modified_times.clear()<EOL>
|
Clears the dict.
|
f5806:c2:m2
|
def has(self, key, mtime=None):
|
v = self.__values.get(key, None)<EOL>if not v:<EOL><INDENT>return False<EOL><DEDENT>if self.check_modified_time:<EOL><INDENT>mtime = self._get_mtime(key, mtime)<EOL>if mtime != self.__modified_times[key]:<EOL><INDENT>del self[key]<EOL>return False<EOL><DEDENT><DEDENT>return True<EOL>
|
This method should almost NEVER be used. The reason is that between the time
has_key is called, and the key is accessed, the key might vanish.
|
f5806:c2:m4
|
def reset(self):
|
with self.lock:<EOL><INDENT>if self.cache:<EOL><INDENT>if self.use_tmp:<EOL><INDENT>shutil.rmtree(self.tmp_dir, ignore_errors=True)<EOL><DEDENT>else:<EOL><INDENT>self.templates = {}<EOL><DEDENT><DEDENT><DEDENT>
|
Resets the cache of compiled templates.
|
f5806:c3:m1
|
def load(self, name, skip='<STR_LIT>', skip_original='<STR_LIT>', default_template=None, layout=None):
|
filename = self.resolve_path(name, skip=skip, skip_original=skip_original,<EOL>default_template=default_template)<EOL>if not filename:<EOL><INDENT>raise ParseError("<STR_LIT>" % name)<EOL><DEDENT>with self.lock:<EOL><INDENT>if layout:<EOL><INDENT>_filename = filename + '<STR_LIT>' + layout<EOL>mtime = os.path.getmtime(filename)<EOL><DEDENT>else:<EOL><INDENT>mtime = None<EOL>_filename = filename<EOL><DEDENT>if self.cache:<EOL><INDENT>if not self.use_tmp:<EOL><INDENT>t = self.templates.get(_filename, mtime=mtime)<EOL>if t:<EOL><INDENT>check = self.check_expiration(t)<EOL>if not check:<EOL><INDENT>return t<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>t = self._create_template(name, filename, layout=layout)<EOL>if self.cache:<EOL><INDENT>if not self.use_tmp:<EOL><INDENT>self.templates.set(_filename, t, mtime)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return t<EOL><DEDENT>
|
Loads a template.
|
f5806:c3:m2
|
def resolve_path(self, filename, skip='<STR_LIT>', skip_original='<STR_LIT>',<EOL>default_template=None):
|
def _file(filename, dirs):<EOL><INDENT>for d in dirs:<EOL><INDENT>_f = os.path.normpath(os.path.join(d, filename))<EOL>if os.path.exists(_f):<EOL><INDENT>yield _f<EOL><DEDENT><DEDENT>raise StopIteration<EOL><DEDENT>filename = os.path.normpath(filename)<EOL>skip = os.path.normpath(skip)<EOL>skip_original = os.path.normpath(skip_original)<EOL>if os.path.exists(filename):<EOL><INDENT>return filename<EOL><DEDENT>if filename and self.dirs:<EOL><INDENT>_files = _file(filename, self.dirs)<EOL>if skip_original == filename:<EOL><INDENT>for f in _files:<EOL><INDENT>if f == skip:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>for f in _files:<EOL><INDENT>if f != skip:<EOL><INDENT>return f<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>if default_template:<EOL><INDENT>if not isinstance(default_template, (tuple, list)):<EOL><INDENT>default_template = [default_template]<EOL><DEDENT>for x in default_template:<EOL><INDENT>filename = self.resolve_path(x)<EOL>if filename:<EOL><INDENT>return filename<EOL><DEDENT><DEDENT><DEDENT>
|
Fetch the template filename according dirs
:para skip: if the searched filename equals skip, then using the one before.
|
f5806:c3:m3
|
def bind(topic, signal=None, kind=MIDDLE, nice=-<NUM_LIT:1>):
|
def f(func):<EOL><INDENT>if not topic in _receivers:<EOL><INDENT>receivers = _receivers[topic] = []<EOL><DEDENT>else:<EOL><INDENT>receivers = _receivers[topic]<EOL><DEDENT>if nice == -<NUM_LIT:1>:<EOL><INDENT>if kind == MIDDLE:<EOL><INDENT>n = <NUM_LIT><EOL><DEDENT>elif kind == HIGH:<EOL><INDENT>n = <NUM_LIT:100><EOL><DEDENT>else:<EOL><INDENT>n = <NUM_LIT><EOL><DEDENT><DEDENT>else:<EOL><INDENT>n = nice<EOL><DEDENT>if callable(func):<EOL><INDENT>func_name = func.__module__ + '<STR_LIT:.>' + func.__name__<EOL>func = func<EOL><DEDENT>else:<EOL><INDENT>func_name = func<EOL>func = None<EOL><DEDENT>_f = (n, {'<STR_LIT>':func, '<STR_LIT>':signal, '<STR_LIT>':func_name})<EOL>receivers.append(_f)<EOL>return func<EOL><DEDENT>return f<EOL>
|
This is a decorator function, so you should use it as:
@bind('init')
def process_init(a, b):
...
|
f5807:m1
|
def unbind(topic, func):
|
if topic in _receivers:<EOL><INDENT>receivers = _receivers[topic]<EOL>for i in range(len(receivers)-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>nice, f = receivers[i]<EOL>if (callable(func) and f['<STR_LIT>'] == func) or (f['<STR_LIT>'] == func):<EOL><INDENT>del receivers[i]<EOL>return<EOL><DEDENT><DEDENT><DEDENT>
|
Remove receiver function
|
f5807:m2
|
def call(sender, topic, *args, **kwargs):
|
if not topic in _receivers:<EOL><INDENT>return<EOL><DEDENT>items = _receivers[topic]<EOL>def _cmp(x, y):<EOL><INDENT>return cmp(x[<NUM_LIT:0>], y[<NUM_LIT:0>])<EOL><DEDENT>items.sort(_cmp)<EOL>i = <NUM_LIT:0><EOL>while i<len(items):<EOL><INDENT>nice, f = items[i]<EOL>i = i + <NUM_LIT:1><EOL>_f = f['<STR_LIT>']<EOL>if not _f:<EOL><INDENT>try:<EOL><INDENT>_f = import_attr(f['<STR_LIT>'])<EOL><DEDENT>except (ImportError, AttributeError) as e:<EOL><INDENT>logging.error("<STR_LIT>" % f['<STR_LIT>'])<EOL>raise<EOL><DEDENT>f['<STR_LIT>'] = _f<EOL><DEDENT>if callable(_f):<EOL><INDENT>kw = kwargs.copy()<EOL>if not _test(kw, f):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>_f(sender, *args, **kw)<EOL><DEDENT>except:<EOL><INDENT>func = _f.__module__ + '<STR_LIT:.>' + _f.__name__<EOL>logging.exception('<STR_LIT>' % (topic, func, args, kw))<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception("<STR_LIT>" % (topic, _f))<EOL><DEDENT><DEDENT>
|
Invoke receiver functions according topic, it'll invoke receiver functions one by one,
and it'll not return anything, so if you want to return a value, you should
use get function.
|
f5807:m4
|
def get(sender, topic, *args, **kwargs):
|
if not topic in _receivers:<EOL><INDENT>return<EOL><DEDENT>items = _receivers[topic]<EOL>def _cmp(x, y):<EOL><INDENT>return cmp(x[<NUM_LIT:0>], y[<NUM_LIT:0>])<EOL><DEDENT>items.sort(_cmp)<EOL>for i in range(len(items)):<EOL><INDENT>nice, f = items[i]<EOL>_f = f['<STR_LIT>']<EOL>if not _f:<EOL><INDENT>try:<EOL><INDENT>_f = import_attr(f['<STR_LIT>'])<EOL><DEDENT>except ImportError:<EOL><INDENT>logging.error("<STR_LIT>" % f['<STR_LIT>'])<EOL>raise<EOL><DEDENT>f['<STR_LIT>'] = _f<EOL><DEDENT>if callable(_f):<EOL><INDENT>if not _test(kwargs, f):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>v = _f(sender, *args, **kwargs)<EOL><DEDENT>except:<EOL><INDENT>func = _f.__module__ + '<STR_LIT:.>' + _f.__name__<EOL>logging.exception('<STR_LIT>' % (topic, func, args, kwargs))<EOL>raise<EOL><DEDENT>if v is not None:<EOL><INDENT>return v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise "<STR_LIT>" % (topic, _f)<EOL><DEDENT><DEDENT>
|
Invoke receiver functions according topic, it'll invoke receiver functions one by one,
and if one receiver function return non-None value, it'll return it and break
the loop.
|
f5807:m6
|
def get_connection(connection='<STR_LIT>', engine_name=None, connection_type='<STR_LIT>', **args):
|
engine_name = engine_name or __default_engine__<EOL>if '<STR_LIT>' in connection:<EOL><INDENT>d = {<EOL>'<STR_LIT>':connection,<EOL>'<STR_LIT>':args,<EOL>'<STR_LIT>':connection_type,<EOL>}<EOL>return engine_manager.add(engine_name, d).engine<EOL><DEDENT>else:<EOL><INDENT>connection = connection or __default_engine__<EOL>if connection in engine_manager:<EOL><INDENT>return engine_manager[connection].engine<EOL><DEDENT>else:<EOL><INDENT>raise Error("<STR_LIT>" % connection)<EOL><DEDENT><DEDENT>
|
Creating an NamedEngine or just return existed engine instance
if '://' include in connection parameter, it'll create new engine object
otherwise return existed engine isntance
|
f5808:m20
|
def get_metadata(engine_name=None):
|
dispatch.get(None, '<STR_LIT>')<EOL>engine = engine_manager[engine_name]<EOL>for tablename, m in list(engine.models.items()):<EOL><INDENT>get_model(tablename, engine_name, signal=False)<EOL>if hasattr(m, '<STR_LIT>') and getattr(m, '<STR_LIT>'):<EOL><INDENT>m.table.__mapping_only__ = True<EOL><DEDENT><DEDENT>return engine.metadata<EOL>
|
get metadata according used for alembic
It'll import all tables
|
f5808:m21
|
def get_session(ec=None, create=True):
|
ec = ec or __default_engine__<EOL>if isinstance(ec, str):<EOL><INDENT>session = engine_manager[ec].session(create=True)<EOL><DEDENT>elif isinstance(ec, Session):<EOL><INDENT>session = ec<EOL><DEDENT>else:<EOL><INDENT>raise Error("<STR_LIT>" % ec)<EOL><DEDENT>return session<EOL>
|
ec - engine_name or connection
|
f5808:m22
|
def rawsql(query, ec=None):
|
if isinstance(query, Result):<EOL><INDENT>query = query.get_query()<EOL><DEDENT>ec = ec or __default_engine__<EOL>if isinstance(ec, str):<EOL><INDENT>engine = engine_manager[ec]<EOL>dialect = engine.engine.dialect<EOL><DEDENT>else:<EOL><INDENT>dialect = ec.dialect<EOL><DEDENT>if isinstance(query, str):<EOL><INDENT>return query<EOL><DEDENT>compiler = query._compiler(dialect)<EOL>class LiteralCompiler(compiler.__class__):<EOL><INDENT>def visit_bindparam(<EOL>self, bindparam, within_columns_clause=False,<EOL>literal_binds=False, **kwargs<EOL>):<EOL><INDENT>return super(LiteralCompiler, self).render_literal_bindparam(<EOL>bindparam, within_columns_clause=within_columns_clause,<EOL>literal_binds=literal_binds, **kwargs<EOL>)<EOL><DEDENT>def render_literal_value(self, value, type_):<EOL><INDENT>"""<STR_LIT>"""<EOL>return repr_value(value)<EOL><DEDENT><DEDENT>compiler = LiteralCompiler(dialect, query)<EOL>return str(compiler.process(query)).replace('<STR_LIT:\n>', '<STR_LIT>')<EOL>
|
ec could be engine name or engine instance
|
f5808:m28
|
def get_engine_name(ec=None):
|
ec = ec or __default_engine__<EOL>if isinstance(ec, str):<EOL><INDENT>return ec<EOL><DEDENT>elif isinstance(ec, Session):<EOL><INDENT>return ec.engine_name<EOL><DEDENT>else:<EOL><INDENT>raise Error("<STR_LIT>" % ec)<EOL><DEDENT>
|
Get the name of a engine or session
|
f5808:m29
|
def do_(query, ec=None, args=None):
|
from time import time<EOL>from uliweb.utils.common import get_caller<EOL>conn = get_session(ec)<EOL>b = time()<EOL>result = conn.execute(query, *(args or ()))<EOL>t = time() - b<EOL>dispatch.call(ec, '<STR_LIT>', query, conn, t)<EOL>flag = False<EOL>sql = '<STR_LIT>'<EOL>if hasattr(Local, '<STR_LIT>') and Local.echo:<EOL><INDENT>if hasattr(Local, '<STR_LIT>'):<EOL><INDENT>_ec = Local.echo_args.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>_ec = None<EOL><DEDENT>engine_name = get_engine_name(ec)<EOL>_e = get_engine_name(_ec)<EOL>if not _ec or _ec and _ec == _e:<EOL><INDENT>if hasattr(Local, '<STR_LIT>') and Local.echo_args['<STR_LIT:time>']:<EOL><INDENT>if t >= Local.echo_args['<STR_LIT:time>']:<EOL><INDENT>sql = rawsql(query)<EOL>flag = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>sql = rawsql(query)<EOL>flag = True<EOL><DEDENT><DEDENT>if flag:<EOL><INDENT>print('<STR_LIT>' % engine_name, end='<STR_LIT:U+0020>')<EOL>if hasattr(Local, '<STR_LIT>') and Local.echo_args['<STR_LIT>']:<EOL><INDENT>v = get_caller(skip=__file__)<EOL>print('<STR_LIT>' % v)<EOL><DEDENT>else:<EOL><INDENT>print()<EOL><DEDENT>print(sql+'<STR_LIT:;>')<EOL>if hasattr(Local, '<STR_LIT>') and Local.echo_args['<STR_LIT>'] and sql:<EOL><INDENT>r = conn.execute('<STR_LIT>'+sql).fetchone()<EOL>print('<STR_LIT>' % '<STR_LIT>'.join(["<STR_LIT>" % (k, v) for k, v in list(r.items())]))<EOL><DEDENT>print('<STR_LIT>' % t)<EOL><DEDENT><DEDENT>return result<EOL>
|
Execute a query
|
f5808:m31
|
def save_file(result, filename, encoding='<STR_LIT:utf8>', headers=None,<EOL>convertors=None, visitor=None, writer=None, **kwargs):
|
import os<EOL>from uliweb.utils.common import simple_value<EOL>convertors = convertors or {}<EOL>headers = headers or []<EOL>writer_class = Writer<EOL>if isinstance(filename, str):<EOL><INDENT>ext = os.path.splitext(filename)[<NUM_LIT:1>]<EOL>if ext == '<STR_LIT>':<EOL><INDENT>writer_class = Writer<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>writer_class = DictWriter<EOL><DEDENT>elif ext == '<STR_LIT>':<EOL><INDENT>writer_class = XlsxWriter<EOL><DEDENT><DEDENT>def convert(k, v, data):<EOL><INDENT>f = convertors.get(k)<EOL>if f:<EOL><INDENT>v = f(v, data)<EOL><DEDENT>return v<EOL><DEDENT>if isinstance(result, str):<EOL><INDENT>result = text(safe_unicode(result))<EOL><DEDENT>if isinstance(result, (Select, TextClause)):<EOL><INDENT>result = do_(result)<EOL><DEDENT>_header = []<EOL>for k in list(result.keys()):<EOL><INDENT>flag = False<EOL>for x in headers:<EOL><INDENT>if x['<STR_LIT:name>'] == k:<EOL><INDENT>_header.append(x)<EOL>flag = True<EOL>break<EOL><DEDENT><DEDENT>if not flag:<EOL><INDENT>_header.append({'<STR_LIT:name>':k, '<STR_LIT:title>':k})<EOL><DEDENT><DEDENT>def _data():<EOL><INDENT>for row in result:<EOL><INDENT>if visitor and callable(visitor):<EOL><INDENT>_row = visitor(list(result.keys()), list(row.values()), encoding)<EOL><DEDENT>else:<EOL><INDENT>_row = [convert(k, v, row) for k, v in zip(list(result.keys()), list(row.values()))]<EOL><DEDENT>yield _row<EOL><DEDENT><DEDENT>writer = writer_class(filename, header=_header, data=_data(), **kwargs)<EOL>writer.save()<EOL>
|
save query result to a csv file
visitor can used to convert values, all value should be convert to string
visitor function should be defined as:
def visitor(keys, values, encoding):
#return new values []
convertors is used to convert single column value, for example:
convertors = {'field1':convert_func1, 'fields2':convert_func2}
def convert_func1(value, data):
value is value of field1
data is the record
if visitor and convertors all provided, only visitor is available.
headers used to convert column to a provided value
|
f5808:m32
|
def CommitAll(close=None):
|
if close:<EOL><INDENT>warnings.simplefilter('<STR_LIT:default>')<EOL>warnings.warn("<STR_LIT>", DeprecationWarning)<EOL><DEDENT>for k, v in list(engine_manager.items()):<EOL><INDENT>session = v.session(create=False)<EOL>if session:<EOL><INDENT>session.commit()<EOL><DEDENT><DEDENT>
|
Commit all transactions according Local.conn
|
f5808:m35
|
def RollbackAll(close=None):
|
if close:<EOL><INDENT>warnings.simplefilter('<STR_LIT:default>')<EOL>warnings.warn("<STR_LIT>", DeprecationWarning)<EOL><DEDENT>for k, v in list(engine_manager.items()):<EOL><INDENT>session = v.session(create=False)<EOL>if session:<EOL><INDENT>session.rollback()<EOL><DEDENT><DEDENT>
|
Rollback all transactions, according Local.conn
|
f5808:m37
|
def set_model(model, tablename=None, created=None, appname=None, model_path=None):
|
if isinstance(model, type) and issubclass(model, Model):<EOL><INDENT>tablename = model._alias or model.tablename<EOL><DEDENT>tablename = tablename.lower()<EOL>d = __models__.setdefault(tablename, {})<EOL>engines = d.get('<STR_LIT>', {}).pop('<STR_LIT>', ['<STR_LIT:default>'])<EOL>if isinstance(engines, str):<EOL><INDENT>engines = [engines]<EOL><DEDENT>d['<STR_LIT>'] = engines<EOL>item = {}<EOL>if created is not None:<EOL><INDENT>item['<STR_LIT>'] = created<EOL><DEDENT>else:<EOL><INDENT>item['<STR_LIT>'] = None<EOL><DEDENT>if isinstance(model, str):<EOL><INDENT>if model_path is None:<EOL><INDENT>model_path = model<EOL><DEDENT>else:<EOL><INDENT>model_path = model_path<EOL><DEDENT>if not appname:<EOL><INDENT>appname = model.rsplit('<STR_LIT:.>', <NUM_LIT:2>)[<NUM_LIT:0>]<EOL><DEDENT>model = None<EOL><DEDENT>else:<EOL><INDENT>appname = model.__module__.rsplit('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if model_path is None:<EOL><INDENT>model_path = model.__module__ + '<STR_LIT:.>' + model.__name__<EOL><DEDENT>else:<EOL><INDENT>model_path = '<STR_LIT>'<EOL><DEDENT>model.__engines__ = engines<EOL><DEDENT>item['<STR_LIT>'] = model<EOL>item['<STR_LIT>'] = model_path<EOL>item['<STR_LIT>'] = appname<EOL>d['<STR_LIT>'] = model_path<EOL>d['<STR_LIT>'] = appname<EOL>for name in engines:<EOL><INDENT>if not isinstance(name, str):<EOL><INDENT>raise BadValueError('<STR_LIT>' % name)<EOL><DEDENT>engine_manager[name].models[tablename] = item.copy()<EOL><DEDENT>
|
Register an model and tablename to a global variable.
model could be a string format, i.e., 'uliweb.contrib.auth.models.User'
:param appname: if no appname, then archive according to model
item structure
created
model
model_path
appname
For dynamic model you should pass model_path with '' value
|
f5808:m39
|
def set_model_config(model_name, config, replace=False):
|
assert isinstance(model_name, str)<EOL>assert isinstance(config, dict)<EOL>d = __models__.setdefault(model_name, {})<EOL>if replace:<EOL><INDENT>d['<STR_LIT>'] = config<EOL><DEDENT>else:<EOL><INDENT>c = d.setdefault('<STR_LIT>', {})<EOL>c.update(config)<EOL><DEDENT>
|
This function should be only used in initialization phrase
:param model_name: model name it's should be string
:param config: config should be dict. e.g.
{'__mapping_only__', '__tablename__', '__ext_model__'}
:param replace: if True, then replace original config, False will update
|
f5808:m40
|
def create_model(modelname, fields, indexes=None, basemodel=None, **props):
|
assert not props or isinstance(props, dict)<EOL>assert not indexes or isinstance(indexes, list)<EOL>props = SortedDict(props or {})<EOL>props['<STR_LIT>'] = True<EOL>props['<STR_LIT>'] = False<EOL>for p in fields:<EOL><INDENT>kwargs = p.copy()<EOL>name = kwargs.pop('<STR_LIT:name>')<EOL>_type = kwargs.pop('<STR_LIT:type>')<EOL>for k in list(kwargs.keys()):<EOL><INDENT>if k.startswith('<STR_LIT:_>'):<EOL><INDENT>kwargs.pop(k, None)<EOL><DEDENT><DEDENT>field_type = get_field_type(_type)<EOL>prop = field_type(**kwargs)<EOL>props[name] = prop<EOL><DEDENT>if basemodel:<EOL><INDENT>model = import_attr(basemodel)<EOL><DEDENT>else:<EOL><INDENT>model = Model<EOL><DEDENT>cls = type(str(modelname.title()), (model,), props)<EOL>tablename = props.get('<STR_LIT>', modelname)<EOL>set_model(cls, tablename, appname=__name__, model_path='<STR_LIT>')<EOL>get_model(modelname, signal=False, reload=True)<EOL>indexes = indexes or []<EOL>for x in indexes:<EOL><INDENT>kwargs = x.copy()<EOL>name = kwargs.pop('<STR_LIT:name>')<EOL>fields = kwargs.pop('<STR_LIT>')<EOL>for k in list(kwargs.keys()):<EOL><INDENT>if k.startswith('<STR_LIT:_>'):<EOL><INDENT>kwargs.pop(k, None)<EOL><DEDENT><DEDENT>if not isinstance(fields, (list, tuple)):<EOL><INDENT>raise ValueError("<STR_LIT>" % indexes)<EOL><DEDENT>props = []<EOL>for y in fields:<EOL><INDENT>props.append(cls.c[y])<EOL><DEDENT>Index(name, *props, **kwargs)<EOL><DEDENT>return cls<EOL>
|
Create model dynamically
:param fields: Just format like [
{'name':name, 'type':type, ...},
...
]
type should be a string, eg. 'str', 'int', etc
kwargs will be passed to Property.__init__() according field type,
it'll be a dict
:param props: Model attributes, such as '__mapping_only__', '__replace__'
:param indexes: Multiple fields index, single index can be set directly using `index=True`
to a field, the value format should be:
[
{'name':name, 'fields':[...], ...},
]
e.g. [
{'name':'audit_idx', 'fields':['table_id', 'obj_id']}
]
for kwargs can be ommited.
:param basemodel: Will be the new Model base class, so new Model can inherited
parent methods, it can be a string or a real class object
|
f5808:m41
|
def find_metadata(model):
|
engine_name = model.get_engine_name()<EOL>engine = engine_manager[engine_name]<EOL>return engine.metadata<EOL>
|
:param model: Model instance
|
f5808:m45
|
def get_model(model, engine_name=None, signal=True, reload=False):
|
if isinstance(model, type) and issubclass(model, Model):<EOL><INDENT>return model<EOL><DEDENT>if not isinstance(model, str):<EOL><INDENT>raise Error("<STR_LIT>" % model)<EOL><DEDENT>model = model.lower()<EOL>model_item = __models__.get(model)<EOL>if not model_item:<EOL><INDENT>model_item = dispatch.get(None, '<STR_LIT>', model_name=model)<EOL><DEDENT>if model_item:<EOL><INDENT>if not engine_name:<EOL><INDENT>engines = model_item['<STR_LIT>']<EOL>if len(engines) > <NUM_LIT:1>:<EOL><INDENT>engine_name = __default_engine__<EOL><DEDENT>else:<EOL><INDENT>engine_name = engines[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>engine = engine_manager[engine_name]<EOL>item = engine._models.get(model)<EOL>if not item and engine.options.duplication:<EOL><INDENT>_item = engine.models.get(model)<EOL>if _item:<EOL><INDENT>item = _item.copy()<EOL>item['<STR_LIT>'] = None<EOL>engine._models[model] = item<EOL><DEDENT><DEDENT>if item:<EOL><INDENT>loaded = False <EOL>m = item['<STR_LIT>']<EOL>m_config = __models__[model].get('<STR_LIT>', {})<EOL>if isinstance(m, type) and issubclass(m, Model):<EOL><INDENT>loaded = True<EOL>if reload:<EOL><INDENT>loaded = False<EOL><DEDENT>if signal:<EOL><INDENT>model_inst = dispatch.get(None, '<STR_LIT>', model_name=model, model_inst=m,<EOL>model_info=item, model_config=m_config) or m<EOL>if m is not model_inst:<EOL><INDENT>loaded = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>model_inst = m<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if signal:<EOL><INDENT>model_inst = dispatch.get(None, '<STR_LIT>', model_name=model, model_inst=None,<EOL>model_info=item, model_config=m_config)<EOL><DEDENT>else:<EOL><INDENT>model_inst = None<EOL><DEDENT>if not model_inst:<EOL><INDENT>if item['<STR_LIT>']:<EOL><INDENT>mod_path, name = item['<STR_LIT>'].rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>mod = __import__(mod_path, fromlist=['<STR_LIT:*>'])<EOL>model_inst = getattr(mod, name)<EOL><DEDENT><DEDENT>if not model_inst:<EOL><INDENT>raise ModelNotFound("<STR_LIT>" % (model, engine_name))<EOL><DEDENT><DEDENT>if not loaded:<EOL><INDENT>if model_inst._bound_classname == model and not reload:<EOL><INDENT>model_inst = model_inst._use(engine_name)<EOL>item['<STR_LIT>'] = model_inst<EOL><DEDENT>else:<EOL><INDENT>config = __models__[model].get('<STR_LIT>', {})<EOL>if config:<EOL><INDENT>for k, v in list(config.items()):<EOL><INDENT>setattr(model_inst, k, v)<EOL><DEDENT><DEDENT>item['<STR_LIT>'] = model_inst<EOL>model_inst._alias = model<EOL>model_inst._engine_name = engine_name<EOL>if __lazy_model_init__:<EOL><INDENT>for k, v in list(model_inst.properties.items()):<EOL><INDENT>v.__property_config__(model_inst, k)<EOL><DEDENT><DEDENT><DEDENT>if reload:<EOL><INDENT>reset = True<EOL><DEDENT>else:<EOL><INDENT>reset = False<EOL><DEDENT>model_inst.bind(engine.metadata, reset=reset)<EOL><DEDENT>if signal:<EOL><INDENT>dispatch.call(None, '<STR_LIT>', model_name=model, model_inst=model_inst,<EOL>model_info=item, model_config=m_config)<EOL><DEDENT>return model_inst<EOL><DEDENT><DEDENT>raise ModelNotFound("<STR_LIT>" % (model, engine_name))<EOL>
|
Return a real model object, so if the model is already a Model class, then
return it directly. If not then import it.
if engine_name is None, then if there is multi engines defined, it'll use
'default', but if there is only one engine defined, it'll use this one
:param dispatch: Used to switch dispatch signal
|
f5808:m46
|
def get_object(table, id=None, condition=None, cache=False, fields=None, use_local=False,<EOL>engine_name=None, session=None):
|
from uliweb import functions, settings<EOL>model = get_model(table, engine_name)<EOL>if isinstance(id, Model):<EOL><INDENT>return id<EOL><DEDENT>if cache:<EOL><INDENT>if use_local:<EOL><INDENT>s = get_session(session)<EOL>key = get_object_id(s.engine_name, model.tablename, id)<EOL>value = s.get_local_cache(key)<EOL>if value:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>obj = model.get(id, condition=condition, fields=fields, cache=True)<EOL>if use_local:<EOL><INDENT>value = s.get_local_cache(key, obj)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>obj = model.get(id, condition=condition, fields=fields)<EOL><DEDENT>return obj<EOL>
|
Get obj in Local.object_caches first and also use get(cache=True) function if
not found in object_caches
|
f5808:m48
|
def reflect_table_data(table, mapping=None, engine_name='<STR_LIT:default>'):
|
table = reflect_table(table, engine_name)<EOL>mapping = mapping or {}<EOL>from uliweb.utils.sorteddict import SortedDict<EOL>field_type_map = {'<STR_LIT>':'<STR_LIT:str>', '<STR_LIT>':'<STR_LIT:str>', '<STR_LIT>':'<STR_LIT:int>', '<STR_LIT>':'<STR_LIT:float>'}<EOL>meta = {}<EOL>columns = SortedDict()<EOL>_primary_key = None<EOL>for k, v in list(table.columns.items()):<EOL><INDENT>column_type = v.type<EOL>type_name = column_type.__class__.__name__.lower()<EOL>kwargs = SortedDict()<EOL>field_type = type_name.upper()<EOL>if type_name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>kwargs['<STR_LIT:max_length>'] = column_type.length<EOL><DEDENT>elif type_name in ('<STR_LIT:text>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:float>', '<STR_LIT>'):<EOL><INDENT>pass<EOL><DEDENT>elif type_name == '<STR_LIT>':<EOL><INDENT>field_type = '<STR_LIT>'<EOL><DEDENT>elif type_name in ('<STR_LIT>',):<EOL><INDENT>field_type = '<STR_LIT>'<EOL><DEDENT>elif type_name in ('<STR_LIT>', '<STR_LIT:float>'):<EOL><INDENT>kwargs['<STR_LIT>'] = v.type.precision<EOL>kwargs['<STR_LIT>'] = v.type.scale<EOL><DEDENT>elif type_name == '<STR_LIT>': <EOL><INDENT>field_type = '<STR_LIT>'<EOL>kwargs['<STR_LIT:max_length>'] = column_type.length<EOL><DEDENT>elif type_name == '<STR_LIT>':<EOL><INDENT>if v.type.scale:<EOL><INDENT>kwargs['<STR_LIT>'] = v.type.precision<EOL>kwargs['<STR_LIT>'] = v.type.scale<EOL>field_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>field_type = '<STR_LIT:int>'<EOL><DEDENT><DEDENT>elif type_name == '<STR_LIT>':<EOL><INDENT>field_type = '<STR_LIT>'<EOL>kwargs['<STR_LIT>'] = v.type.precision<EOL>kwargs['<STR_LIT>'] = v.type.scale<EOL><DEDENT>elif type_name in ('<STR_LIT>',):<EOL><INDENT>field_type = '<STR_LIT>'<EOL><DEDENT>elif type_name in ('<STR_LIT>', '<STR_LIT:date>', '<STR_LIT:time>'):<EOL><INDENT>pass<EOL><DEDENT>elif type_name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>field_type = '<STR_LIT:bool>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError("<STR_LIT>".format(k, type_name, table.name))<EOL><DEDENT>if v.primary_key:<EOL><INDENT>kwargs['<STR_LIT:primary_key>'] = True<EOL>_primary_key = k<EOL>if v.autoincrement:<EOL><INDENT>kwargs['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>if not v.nullable:<EOL><INDENT>kwargs['<STR_LIT>'] = False<EOL><DEDENT>if v.server_default:<EOL><INDENT>server_default = v.server_default.arg<EOL>kwargs['<STR_LIT>'] = server_default<EOL><DEDENT>if v.index:<EOL><INDENT>kwargs['<STR_LIT:index>'] = True<EOL><DEDENT>if v.unique:<EOL><INDENT>kwargs['<STR_LIT>'] = True<EOL><DEDENT>if sa_version >= '<STR_LIT>' and v.comment:<EOL><INDENT>kwargs['<STR_LIT>'] = v.comment<EOL><DEDENT>field_type = field_type_map.get(field_type, field_type)<EOL>columns[k] = field_type, kwargs<EOL><DEDENT>meta['<STR_LIT>'] = columns<EOL>indexes = []<EOL>indexes_names = []<EOL>for index in table.indexes:<EOL><INDENT>cols = list(index.columns)<EOL>_len = len(cols)<EOL>if _len == <NUM_LIT:1>:<EOL><INDENT>column_name = cols[<NUM_LIT:0>].name<EOL>d = {'<STR_LIT:index>':True}<EOL>if index.unique:<EOL><INDENT>d['<STR_LIT>'] = index.unique<EOL><DEDENT>columns[column_name][<NUM_LIT:1>].update(d)<EOL><DEDENT>else:<EOL><INDENT>if not index.name in indexes_names:<EOL><INDENT>indexes.append({'<STR_LIT:name>':index.name, '<STR_LIT>':[x.name for x in index.columns],<EOL>'<STR_LIT>':index.unique})<EOL>indexes_names.append(index.name)<EOL><DEDENT><DEDENT><DEDENT>meta['<STR_LIT>'] = indexes<EOL>return meta<EOL>
|
Write table to Model dict
|
f5808:m53
|
def reflect_table_model(table, mapping=None, without_id=False, engine_name='<STR_LIT:default>'):
|
table = reflect_table(table, engine_name)<EOL>mapping = mapping or {}<EOL>meta = reflect_table_data(table)<EOL>code = ['<STR_LIT>'.format(table.name.title())]<EOL>code.append('''<STR_LIT>'''.format(table.name))<EOL>if sa_version >= '<STR_LIT>' and table.comment:<EOL><INDENT>code.append('<STR_LIT>'.format(dumps(table.comment, bool_int=False)))<EOL><DEDENT>if '<STR_LIT:id>' not in meta['<STR_LIT>'] and without_id:<EOL><INDENT>code.append('<STR_LIT>')<EOL><DEDENT>for k, v in list(meta['<STR_LIT>'].items()):<EOL><INDENT>kw = list(v[<NUM_LIT:1>].items())<EOL>x_v = mapping.get(v[<NUM_LIT:0>])<EOL>kwargs = '<STR_LIT:U+002CU+0020>'.join([v[<NUM_LIT:0>]] + ['<STR_LIT>'.format(x, dumps(y, bool_int=False)) for x, y in kw])<EOL>if x_v:<EOL><INDENT>type_class = '<STR_LIT>'.format(x_v)<EOL><DEDENT>else:<EOL><INDENT>type_class = '<STR_LIT>'<EOL><DEDENT>txt = "<STR_LIT:U+0020>"*<NUM_LIT:4> + "<STR_LIT>".format(k, kwargs, type_class)<EOL>code.append(txt)<EOL><DEDENT>if meta['<STR_LIT>']:<EOL><INDENT>code.append("""<STR_LIT>""")<EOL><DEDENT>for index in meta['<STR_LIT>']:<EOL><INDENT>buf = []<EOL>buf.append(index['<STR_LIT:name>'])<EOL>for c in index['<STR_LIT>']:<EOL><INDENT>buf.append('<STR_LIT>'.format(c))<EOL><DEDENT>if index['<STR_LIT>']:<EOL><INDENT>buf.append('<STR_LIT>')<EOL><DEDENT>code.append('<STR_LIT:U+0020>'*<NUM_LIT:8> + '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(buf)))<EOL><DEDENT>return '<STR_LIT:\n>'.join(code)<EOL>
|
Write table to Model class
|
f5808:m54
|
def migrate_tables(tables, engine_name=None):
|
from alembic.migration import MigrationContext<EOL>engine = engine_manager[engine_name]<EOL>mc = MigrationContext.configure(engine.session().connection)<EOL>script = get_migrate_script(mc, tables, engine.metadata)<EOL>run_migrate_script(mc, script)<EOL>
|
Used to migrate dynamic table to database
:param tables: tables name list, such as ['user']
|
f5808:m57
|
def SelfReferenceProperty(label=None, collection_name=None, **attrs):
|
if '<STR_LIT>' in attrs:<EOL><INDENT>raise ConfigurationError(<EOL>'<STR_LIT>')<EOL><DEDENT>return ReferenceProperty(_SELF_REFERENCE, label, collection_name, **attrs)<EOL>
|
Create a self reference.
|
f5808:m59
|
def session(self, create=True):
|
if hasattr(self.local, '<STR_LIT>'):<EOL><INDENT>return self.local.session<EOL><DEDENT>else:<EOL><INDENT>if create:<EOL><INDENT>s = Session(self.name)<EOL>self.local.session = s<EOL>return s<EOL><DEDENT><DEDENT>
|
Used to created default session
|
f5808:c13:m3
|
def __init__(self, engine_name=None, auto_transaction=None,<EOL>auto_close=True, post_commit=None, post_commit_once=None):
|
self.engine_name = engine_name or __default_engine__<EOL>self.auto_transaction = auto_transaction<EOL>self.auto_close = auto_close<EOL>self.engine = engine_manager[engine_name]<EOL>self._conn = None<EOL>self._trans = None<EOL>self.local_cache = {}<EOL>self.post_commit = post_commit or []<EOL>self.post_commit_once = post_commit_once or []<EOL>
|
If auto_transaction is True, it'll automatically start transacation
in web environment, it'll be commit or rollback after the request finished
and in no-web environment, you should invoke commit or rollback yourself.
|
f5808:c15:m0
|
def __init__(self, filename, encoding='<STR_LIT:utf8>', header=None, data=None, **kwargs):
|
self.filename = filename<EOL>self.encoding = encoding<EOL>self.data = data or []<EOL>self.header = header<EOL>self.kwargs = kwargs<EOL>
|
:param filename: Could be string or file-like object
|
f5808:c16:m0
|
def get_parameters(self):
|
d = {}<EOL>for k in ['<STR_LIT:label>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT:default>', '<STR_LIT>', '<STR_LIT:max_length>']:<EOL><INDENT>d[k] = getattr(self, k)<EOL><DEDENT>return d<EOL>
|
Get common attributes and it'll used for Model.relationship clone process
|
f5808:c22:m1
|
def __init__(self, reference_class=None, label=None, collection_name=None,<EOL>reference_fieldname=None, required=False, engine_name=None, **attrs):
|
super(ReferenceProperty, self).__init__(label, **attrs)<EOL>self._collection_name = collection_name<EOL>if reference_class and isinstance(reference_class, type) and issubclass(reference_class, Model):<EOL><INDENT>self.reference_fieldname = reference_fieldname or reference_class._primary_field<EOL><DEDENT>else:<EOL><INDENT>self.reference_fieldname = reference_fieldname<EOL><DEDENT>self.required = required<EOL>self.engine_name = engine_name<EOL>self.reference_class = reference_class<EOL>if __lazy_model_init__:<EOL><INDENT>if inspect.isclass(self.reference_class) and issubclass(self.reference_class, Model):<EOL><INDENT>warnings.simplefilter('<STR_LIT:default>')<EOL>warnings.warn("<STR_LIT>" % self.reference_class.__name__, DeprecationWarning)<EOL><DEDENT><DEDENT>
|
Construct ReferenceProperty.
Args:
reference_class: Which model class this property references.
verbose_name or label: User friendly name of property.
collection_name: If provided, alternate name of collection on
reference_class to store back references. Use this to allow
a Model to have multiple fields which refer to the same class.
reference_fieldname used to specify which fieldname of reference_class
should be referenced
|
f5808:c45:m0
|
def __property_config__(self, model_class, property_name):
|
super(ReferenceProperty, self).__property_config__(model_class, property_name)<EOL>if not (<EOL>(isinstance(self.reference_class, type) and issubclass(self.reference_class, Model)) or<EOL>self.reference_class is _SELF_REFERENCE or<EOL>valid_model(self.reference_class, self.engine_name)):<EOL><INDENT>raise KindError('<STR_LIT>' % self.reference_class)<EOL><DEDENT>if self.reference_class is _SELF_REFERENCE or self.reference_class is None:<EOL><INDENT>self.reference_class = model_class<EOL><DEDENT>else:<EOL><INDENT>self.reference_class = get_model(self.reference_class, self.engine_name,<EOL>signal=False)<EOL><DEDENT>self.reference_fieldname = self.reference_fieldname or self.reference_class._primary_field<EOL>self.collection_name = self.reference_class.get_collection_name(model_class.tablename, self._collection_name, model_class.tablename)<EOL>setattr(self.reference_class, self.collection_name,<EOL>_ReverseReferenceProperty(model_class, property_name, self._id_attr_name(), self.collection_name))<EOL>
|
Loads all of the references that point to this model.
|
f5808:c45:m3
|
def __get__(self, model_instance, model_class):
|
if model_instance is None:<EOL><INDENT>return self<EOL><DEDENT>if hasattr(model_instance, self._attr_name()):<EOL><INDENT>reference_id = getattr(model_instance, self._attr_name())<EOL>
|
Get reference object.
This method will fetch unresolved entities from the datastore if
they are not already loaded.
Returns:
ReferenceProperty to Model object if property is set, else None.
|
f5808:c45:m4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.