Something like ast.literal_eval to execute variable assignments

Question

I want to do something like:

import ast

def foo(common_stuff, assignment_str):
    common_stuff()
    ast.literal_eval(assignment_str) # assignment to unknown or passed variable

foo('a=1;b=2')

is this possible in Python?

I am trying to write a general function to (enforce DRY) for this:

    for f, i in zip(task_set, xrange(len(task_set))):
        cd = f.cleaned_data
        t_name = cd.get('t_name')
        start_date = cd.get('start_date')
        end_date = cd.get('end_date')
        project = Project.objects.get(pro_id=p.pro_id)
        task = Task(t_name=t_name, start_date=start_date,
                    end_date=end_date, project=project)
        task.save()
        tasks_list.append(task)

So I started writing the following:

def save_form(model, formset, foreignkey_assignment, *args){
    for f, i in zip(formset, xrange(len(formset))):
        cd = f.cleaned_data
        get_key_name = lambda x: cd.get(x)
        ast.literal_eval(foreignkey_assignment)
        m = model(**{k:get_key_name(k) for k in args})
        m.save()
}

If you already have the list of keys you need to get in `*args`, why do you need to assign anything with `literal_eval`? — Kevin, Sep 02 '16 at 15:05

score 3 · Answer 1 · answered Sep 02 '16 at 15:39

ast.literal_eval() 'executes' the AST parse tree of an evaluation, and limits this to a strict subset that only allows for standard Python literals. You could take the source code and add assignment support (where I'd use a separate dictionary to handle names).

You'd have to add Assign and Name node handling (Python 3 version):

def literal_eval(node_or_string, namespace):
    """
    Safely evaluate an expression node or a string containing a Python
    expression.  The string or node provided may only consist of the following
    Python literal structures: strings, bytes, numbers, tuples, lists, dicts,
    sets, booleans, and None.
    """
    if isinstance(node_or_string, str):
        node_or_string = ast.parse(node_or_string, mode='exec')
    if isinstance(node_or_string, ast.Module):
        node_or_string = node_or_string.body
    def _convert(node, ns=None):
        if isinstance(node, (ast.Str, ast.Bytes)):
            return node.s
        elif isinstance(node, ast.Num):
            return node.n
        elif isinstance(node, ast.Tuple):
            return tuple(map(_convert, node.elts))
        elif isinstance(node, ast.List):
            return list(map(_convert, node.elts))
        elif isinstance(node, ast.Set):
            return set(map(_convert, node.elts))
        elif isinstance(node, ast.Dict):
            return dict((_convert(k), _convert(v)) for k, v
                        in zip(node.keys, node.values))
        elif isinstance(node, ast.NameConstant):
            return node.value
        elif isinstance(node, ast.UnaryOp) and \
             isinstance(node.op, (ast.UAdd, ast.USub)) and \
             isinstance(node.operand, (ast.Num, ast.UnaryOp, ast.BinOp)):
            operand = _convert(node.operand)
            if isinstance(node.op, ast.UAdd):
                return + operand
            else:
                return - operand
        elif isinstance(node, ast.BinOp) and \
             isinstance(node.op, (ast.Add, ast.Sub)) and \
             isinstance(node.right, (ast.Num, ast.UnaryOp, ast.BinOp)) and \
             isinstance(node.left, (ast.Num, ast.UnaryOp, ast.BinOp)):
            left = _convert(node.left)
            right = _convert(node.right)
            if isinstance(node.op, ast.Add):
                return left + right
            else:
                return left - right
        elif isinstance(node, ast.Assign) and \
             len(node.targets) == 1 and \
             isinstance(node.targets[0], ast.Name):
                assert isinstance(ns, dict)  # will be None when not top-level
                ns[node.targets[0].id] = _convert(node.value)
                return
        raise ValueError('malformed node or string: ' + repr(node))
    return _convert(node_or_string, namespace)

Or you could use the asteval project, which does exactly that and a little more, supporting simple expressions and assignment, using AST tree interpretation.

score 0 · Answer 2 · edited May 23 '17 at 11:51

0

Yes you can

exec('a=1;b=2')

but you shouldn't. Why should exec() and eval() be avoided?

edited May 23 '17 at 11:51

Community

1
1

answered Sep 02 '16 at 15:36

Alexis Benichoux

790
4
13

Exactly, which is why the OP is asking for something like `ast.literal_eval()` that supports assignment. – Martijn Pieters Sep 02 '16 at 15:41

Something like ast.literal_eval to execute variable assignments

2 Answers2

Linked