Question

I have an existing python application (limited deployment) that requires the ability to run batches/macros (ie do foo 3 times, change x, do y). Currently I have this implemented as exec running through a text file which contains simple python code to do all the required batching.

However exec is messy (ie security issues) and there are also some cases where it doesn’t act exactly the same as actually having the same code in your file. How can I get around using exec? I don’t want to write my own mini-macro language, and users need to use multiple different macros per session, so I can’t setup it such that the macro is a python file that calls the software and then runs itself or something similar.

Is there a cleaner/better way to do this?

Pseudocode: In the software it has something like:
-when a macro gets called

for line in macrofile:
   exec line

and the macrofiles are python, ie something like:

property_of_software_obj = "some str"
software_function(some args)

etc.

Answer 1

Have you considered using a serialized data format like JSON? It’s lightweight, can easily translate to Python dictionaries, and all the cool kids are using it.

You could construct the data in a way that is meaningful, but doesn’t require containing actual code. You could then read in that construct, grab the parts you want, and then pass it to a function or class.

Edit: Added a pass at a cheesy example of a possible JSON spec.

Your JSON:

{
    "macros": [
        {
            "function": "foo_func", 
            "args": {
                "x": "y", 
                "bar": null
            }, 
            "name": "foo", 
            "iterations": 3
        }, 
        {
            "function": "bar_func", 
            "args": {
                "x": "y", 
                "bar": null
            }, 
            "name": "bar", 
            "iterations": 1
        }
    ]
}

Then you parse it with Python’s json lib:

import json

# Get JSON data from elsewhere and parse it
macros = json.loads(json_data)

# Do something with the macros
for macro in macros:
    run_macro(macro) # For example

And the resulting Python data is almost identical syntactically to JSON aside from some of the keywords like True, False, None (true, false, null in JSON).

{
    'macros': [
        {
            'args': 
            {
                'bar': None, 
                'x': 'y'
            },
             'function': 'foo_func',
             'iterations': 3,
             'name': 'foo'
        },
        {
            'args': 
            {
                'bar': None, 
                'x': 'y'
            },
             'function': 'bar_func',
             'iterations': 1,
             'name': 'bar'
        }
    ]
}