Gecko [ oric.aiou.edu.pk ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	2.55 KB	-rw-r--r--
_compat.py	2.54 KB	-rw-r--r--
_identifier.py	1.69 KB	-rw-r--r--
asyncfilters.py	4.05 KB	-rw-r--r--
asyncsupport.py	7.69 KB	-rw-r--r--
bccache.py	12.49 KB	-rw-r--r--
compiler.py	63.85 KB	-rw-r--r--
constants.py	1.59 KB	-rw-r--r--
debug.py	11.76 KB	-rw-r--r--
defaults.py	1.37 KB	-rw-r--r--
environment.py	49.66 KB	-rw-r--r--
exceptions.py	4.32 KB	-rw-r--r--
ext.py	23.93 KB	-rw-r--r--
filters.py	36.19 KB	-rw-r--r--
idtracking.py	8.98 KB	-rw-r--r--
lexer.py	27.95 KB	-rw-r--r--
loaders.py	16.97 KB	-rw-r--r--
meta.py	4.24 KB	-rw-r--r--
nativetypes.py	7.14 KB	-rw-r--r--
nodes.py	30.2 KB	-rw-r--r--
optimizer.py	1.68 KB	-rw-r--r--
parser.py	35.03 KB	-rw-r--r--
runtime.py	27.22 KB	-rw-r--r--
sandbox.py	16.92 KB	-rw-r--r--
tests.py	4.2 KB	-rw-r--r--
utils.py	20.48 KB	-rw-r--r--
visitor.py	3.24 KB	-rw-r--r--

Code Editor : asyncfilters.py

from functools import wraps

from jinja2.asyncsupport import auto_aiter
from jinja2 import filters

async def auto_to_seq(value):
    seq = []
    if hasattr(value, '__aiter__'):
        async for item in value:
            seq.append(item)
    else:
        for item in value:
            seq.append(item)
    return seq

async def async_select_or_reject(args, kwargs, modfunc, lookup_attr):
    seq, func = filters.prepare_select_or_reject(
        args, kwargs, modfunc, lookup_attr)
    if seq:
        async for item in auto_aiter(seq):
            if func(item):
                yield item

def dualfilter(normal_filter, async_filter):
    wrap_evalctx = False
    if getattr(normal_filter, 'environmentfilter', False):
        is_async = lambda args: args[0].is_async
        wrap_evalctx = False
    else:
        if not getattr(normal_filter, 'evalcontextfilter', False) and \
           not getattr(normal_filter, 'contextfilter', False):
            wrap_evalctx = True
        is_async = lambda args: args[0].environment.is_async

@wraps(normal_filter)
    def wrapper(*args, **kwargs):
        b = is_async(args)
        if wrap_evalctx:
            args = args[1:]
        if b:
            return async_filter(*args, **kwargs)
        return normal_filter(*args, **kwargs)

if wrap_evalctx:
        wrapper.evalcontextfilter = True

wrapper.asyncfiltervariant = True

return wrapper

def asyncfiltervariant(original):
    def decorator(f):
        return dualfilter(original, f)
    return decorator

@asyncfiltervariant(filters.do_first)
async def do_first(environment, seq):
    try:
        return await auto_aiter(seq).__anext__()
    except StopAsyncIteration:
        return environment.undefined('No first item, sequence was empty.')

@asyncfiltervariant(filters.do_groupby)
async def do_groupby(environment, value, attribute):
    expr = filters.make_attrgetter(environment, attribute)
    return [filters._GroupTuple(key, await auto_to_seq(values))
            for key, values in filters.groupby(sorted(
                await auto_to_seq(value), key=expr), expr)]

@asyncfiltervariant(filters.do_join)
async def do_join(eval_ctx, value, d=u'', attribute=None):
    return filters.do_join(eval_ctx, await auto_to_seq(value), d, attribute)

@asyncfiltervariant(filters.do_list)
async def do_list(value):
    return await auto_to_seq(value)

@asyncfiltervariant(filters.do_reject)
async def do_reject(*args, **kwargs):
    return async_select_or_reject(args, kwargs, lambda x: not x, False)

@asyncfiltervariant(filters.do_rejectattr)
async def do_rejectattr(*args, **kwargs):
    return async_select_or_reject(args, kwargs, lambda x: not x, True)

@asyncfiltervariant(filters.do_select)
async def do_select(*args, **kwargs):
    return async_select_or_reject(args, kwargs, lambda x: x, False)

@asyncfiltervariant(filters.do_selectattr)
async def do_selectattr(*args, **kwargs):
    return async_select_or_reject(args, kwargs, lambda x: x, True)

@asyncfiltervariant(filters.do_map)
async def do_map(*args, **kwargs):
    seq, func = filters.prepare_map(args, kwargs)
    if seq:
        async for item in auto_aiter(seq):
            yield func(item)

@asyncfiltervariant(filters.do_sum)
async def do_sum(environment, iterable, attribute=None, start=0):
    rv = start
    if attribute is not None:
        func = filters.make_attrgetter(environment, attribute)
    else:
        func = lambda x: x
    async for item in auto_aiter(iterable):
        rv += func(item)
    return rv

@asyncfiltervariant(filters.do_slice)
async def do_slice(value, slices, fill_with=None):
    return filters.do_slice(await auto_to_seq(value), slices, fill_with)

ASYNC_FILTERS = {
    'first':        do_first,
    'groupby':      do_groupby,
    'join':         do_join,
    'list':         do_list,
    # we intentionally do not support do_last because that would be
    # ridiculous
    'reject':       do_reject,
    'rejectattr':   do_rejectattr,
    'map':          do_map,
    'select':       do_select,
    'selectattr':   do_selectattr,
    'sum':          do_sum,
    'slice':        do_slice,
}

${this.title}

Code Editor : asyncfilters.py