Use user provided python code during runtime_问答_开发者

I'm developing a system that operates on (arbitrary) data from databases. The data may need some preprocessing before the system can work with it. To allow the user the specify possibly complex rules I though of giving the user the possibility to input Python code which is used to do this task. The system is pure Python.

My plan is to introduce the tables and columns as variables and let the user to anything Python can do (including access to the standard libs). Now to my problem:

How do I take a string (the user entered), compile it to Python (after adding code to provide the input data) and get the output. I think the easiest way would be to use the user-entered data a the body of a method and take the return value of that function a my new data.

Is this possible? If yes, how? I开发者_开发问答t's unimportant that the user may enter malicious code since the worst thing that could happen is, that he screws up his own system, which is thankfully not my problem ;)

Python provides an exec() statement which should do what you want. You will want to pass in the variables that you want available as the second and/or third arguments to the function (globals and locals respectively) as those control the environment that the exec is run in.

For example:

env = {'somevar': 'somevalue'}
exec(code, env)

Alternatively, execfile() can be used in a similar way, if the code that you want executed is stored in its own file.

If you only have a single expression that you want to execute, you can also use eval.

Is this possible?

If it doesn't involve time travel, anti-gravity or perpetual motion the answer to this question is always "YES". You don't need to ask that.

The right way to proceed is as follows.

You build a framework with some handy libraries and packages.

You build a few sample applications that implement this requirement: "The data may need some preprocessing before the system can work with it."

You write documentation about how that application imports and uses modules from your framework.

You turn the framework, the sample applications and the documentation over to users to let them build these applications.

Don't waste time on "take a string (the user entered), compile it to Python (after adding code to provide the input data) and get the output".

The user should write applications like this.

from your_framework import the_file_loop
def their_function( one_line_as_dict ):
    one_line_as_dict['field']= some stuff
the_file_loop( their_function )

That can actually be the entire program.

You'll have to write the_file_loop, which will look something like this.

def the_file_loop( some_function ):
    with open('input') as source:
        with open('output') as target:
            for some_line in source:
                the_data = make_a_dictionary( some_line )
                some_function( the_data )
                target.write( make_a_line( the_data ) )

By creating a framework, and allowing users to write their own programs, you'll be a lot happier with the results. Less magic.

2 choices:

You take his input and put it in a file, then you execute it.
You use exec()

If you just want to set some local values and then provide a python shell, check out the code module.

You can start an instance of a shell that is similar to the python shell, as well as initialize it with whatever local variables you want. This would assume that whatever functionality you want to use the resulting values is built into the classes you are passing in as locals.

Example:

shell = code.InteractiveConsole({'foo': myVar1, 'bar': myVar2})

What you actually want is exec, since eval is limited to taking an expression and returning a value. With exec, you can have code blocks (statements) and work on arbitrarily complex data, passed in as the globals and locals of the code.

The result is then returned by the code via some convention (like binding it to result).

well, you're describing compile()

But... I think I'd still implement this using regular python source files. Add a special location to the path, say '~/.myapp/plugins', and just __import__ everything there. Probably you'll want to provide some convenient base classes that expose the interface you're trying to offer, so that your users can inherit from them.