Produits Entr'ouvert » Authentic 2

                 'authentic2.attributes_ng.sources.expression',

import itertools

from django.core.exceptions import ImproperlyConfigured

from safe_expression import SafeExpression, InvalidExpression

from ...decorators import to_list

AUTHORIZED_KEYS = set(('name', 'label', 'condition', 'expression'))

REQUIRED_KEYS = set(('name', 'expression'))

UNEXPECTED_KEYS_ERROR = \

        '{0}: unexpected key(s) {1} in configuration'

MISSING_KEYS_ERROR = \

        '{0}: missing key(s) {1} in configuration'

BAD_CONFIG_ERROR = \

        '{0}: expression attribute source must contain a name and an expression'

NOT_CALLABLE_ERROR = \

        '{0}: function attribute must be callable'

def config_error(fmt, *args):

    raise ImproperlyConfigured(fmt.format(__name__, *args))

@to_list

def get_instances(ctx):

    '''

    Retrieve instances from settings

    '''

    from django.conf import settings

    all_sources = itertools.chain(

            getattr(settings, 'ATTRIBUTE_SOURCES', []),

            ctx.get('__attribute_sources__', []))

    for kind, d in all_sources:

        if kind != 'expression':

            continue

        if not d.get('__validated'):

            keys = set(d.keys())

            if not keys <= AUTHORIZED_KEYS:

                unexpected = keys - AUTHORIZED_KEYS

                config_error(UNEXPECTED_KEYS_ERROR, unexpected)

            if not REQUIRED_KEYS <= keys:

                missing = REQUIRED_KEYS - keys

                config_error(MISSING_KEYS_ERROR, missing)

            d['__dependencies'] = set()

            if 'condition' in d:

                d['__condition'] = SafeExpression(d['condition'])

                try:

                    d['__condition'].validate(raises=True)

                except InvalidExpression, e:

                    raise ImproperlyConfigured('invalid condition expression', e)

                d['__dependencies'].update(d['__condition'].names())

            d['__expression'] = SafeExpression(d['expression'])

            try:

                d['__expression'].validate(raises=True)

            except InvalidExpression, e:

                raise ImproperlyConfigured('invalid expression', e)

            d['__dependencies'].update(d['__expression'].names())

        d['__validated'] = True

        yield d

def get_attribute_names(instance, ctx):

    name = instance['name']

    return ((name, instance.get('label', name)),)

def get_dependencies(instance, ctx):

    return instance['__dependencies']

def get_attributes(instance, ctx):

    if '__condition' in instance and not instance['__condition'](**ctx):

        return {}

    return {instance['name']: instance['__expression'](**ctx)}

from safe_expression import SafeExpression, InvalidExpression

def safe_python_expression(value):

    try:

        SafeExpression(value).validate(raises=True)

    except InvalidExpression, e:

        raise ValidationError(e.args[0])

safe-expression

        'safe-expression',