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(... | 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:@... | 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>impo... | 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><INDEN... | 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 ... | 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><... | 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_sessi... | 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('<... | 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 msgs... | @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]<... | 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>] =... | 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... | 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... | 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>'<EO... | 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>'... | 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>p... | 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><INDEN... | 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.p... | 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 answ... | 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... | 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<... | 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(pr... | 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>g... | 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><D... | 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... | 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 type... | 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... | 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... | 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 th... | 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>sel... | :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... | 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(... | 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.normp... | 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><... | 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><DE... | 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 n... | 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>... | 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__<EO... | 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 eng... | 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>retu... | 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:<E... | 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... | 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_fun... | 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><INDEN... | 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:typ... | 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,
... | 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>... | 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 ... | 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 =... | 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.co... | 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 = pos... | 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><IND... | 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. U... | 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('<S... | 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.