# The list of symbols that are included by default in the generated
# function's environment
SAFE_SYMBOLS = ["list", "dict", "tuple", "set", "long", "float", "object",
"bool", "callable", "True", "False", "dir",
"frozenset", "getattr", "hasattr", "abs", "cmp", "complex",
"divmod", "id", "pow", "round", "slice", "vars",
"hash", "hex", "int", "isinstance", "issubclass", "len",
"map", "filter", "max", "min", "oct", "chr", "ord", "range",
"reduce", "repr", "str", "type", "zip", "xrange", "None",
"Exception", "KeyboardInterrupt"]
# Also add the standard exceptions
__bi = __builtins__
if type(__bi) is not dict:
__bi = __bi.__dict__
for k in __bi:
if k.endswith("Error") or k.endswith("Warning"):
SAFE_SYMBOLS.append(k)
del __bi
def createFunction(sourceCode, args="", additional_symbols=dict()):
"""
Create a python function from the given source code
\param sourceCode A python string containing the core of the
function. Might include the return statement (or not), definition of
local functions, classes, etc. Indentation matters !
\param args The string representing the arguments to put in the function's
prototype, such as "a, b", or "a=12, b",
or "a=12, b=dict(akey=42, another=5)"
\param additional_symbols A dictionary variable name =>
variable/funcion/object to include in the generated function's
closure
The sourceCode will be executed in a restricted environment,
containing only the python builtins that are harmless (such as map,
hasattr, etc.). To allow the function to access other modules or
functions or objects, use the additional_symbols parameter. For
example, to allow the source code to access the re and sys modules,
as well as a global function F named afunction in the sourceCode and
an object OoO named ooo in the sourceCode, specify:
additional_symbols = dict(re=re, sys=sys, afunction=F, ooo=OoO)
\return A python function implementing the source code. It can be
recursive: the (internal) name of the function being defined is:
__TheFunction__. Its docstring is the initial sourceCode string.
Tests show that the resulting function does not have any calling
time overhead (-3% to +3%, probably due to system preemption aleas)
compared to normal python function calls.
"""
# Include the sourcecode as the code of a function __TheFunction__:
s = "def __TheFunction__(%s):\n" % args
s += "\t" + "\n\t".join(sourceCode.split('\n')) + "\n"
# Byte-compilation (optional)
byteCode = compile(s, "<string>", 'exec')
# Setup the local and global dictionaries of the execution
# environment for __TheFunction__
bis = dict() # builtins
globs = dict()
locs = dict()
# Setup a standard-compatible python environment
bis["locals"] = lambda: locs
bis["globals"] = lambda: globs
globs["__builtins__"] = bis
globs["__name__"] = "SUBENV"
globs["__doc__"] = sourceCode
# Determine how the __builtins__ dictionary should be accessed
if type(__builtins__) is dict:
bi_dict = __builtins__
else:
bi_dict = __builtins__.__dict__
# Include the safe symbols
for k in SAFE_SYMBOLS:
# try from current locals
try:
locs[k] = locals()[k]
continue
except KeyError:
pass
# Try from globals
try:
globs[k] = globals()[k]
continue
except KeyError:
pass
# Try from builtins
try:
bis[k] = bi_dict[k]
except KeyError:
# Symbol not available anywhere: silently ignored
pass
# Include the symbols added by the caller, in the globals dictionary
globs.update(additional_symbols)
# Finally execute the def __TheFunction__ statement:
eval(byteCode, globs, locs)
# As a result, the function is defined as the item __TheFunction__
# in the locals dictionary
fct = locs["__TheFunction__"]
# Attach the function to the globals so that it can be recursive
del locs["__TheFunction__"]
globs["__TheFunction__"] = fct
# Attach the actual source code to the docstring
fct.__doc__ = sourceCode
return fct
##################################################################
### Some tests
def test():
# -----------------------------------------------------
# Code to execute as function 'f' (as a string):
s = """
if a == "BE RECURSIVE":
print "In the recursion 1"
return __TheFunction__("THE END", 54)
elif a == "THE END":
print "In the recursion 2"
return 54
print a
print b
x = True
def sayhello(s):
print "I say hello that way: %s" % s
class SayHello(object):
def __init__(self, s):
self.__s = s
print "ctor says %s" % self.__s
def s(self):
return self.__s
try:
1/0
except ZeroDivisionError, ex:
print "GOT EX", ex
print "ooo in here says", ooo.mouf()
result = a + b +1
afunction(a+1)
c = re.compile("^a").search("ba", 1)
d = re.compile("a").match("ba", 1)
sayhello("I am so happy today %s,%s" % (c, d))
o = SayHello("this works")
vvv = range(42)
print vvv
sys.stderr.write("writing to stderr\\n")
print __TheFunction__
print "============ BEGIN docstring ==========="
print __TheFunction__.__doc__
print "============ END docstring ==========="
return a*b + __TheFunction__("BE RECURSIVE", 33)
"""
# End of source code string
# -----------------------------------------------------
# Create objects, functions, etc.
class OOO:
def __init__(self, id):
self.__id = id
def mouf(self):
return "OOO: My ID is %s" % self.__id
def F(n):
print "F: my parameter is", n
# Generate a first function, f, which needs the re and sys modules
import sys, re
OoO = OOO(64)
f = createFunction(s, "a=3, b=4",
additional_symbols = dict(re=re, sys=sys,
afunction=F, ooo=OoO))
# Generate another function
OoO = OOO("FOR G")
g = createFunction("print 'G: my parameter is ', p, 'and o says', o.mouf()\nreturn p",
"p='undefined'", dict(o=OoO))
# Test them
print "call f():", f()
print "call g():", g()
print "call f(42):", f(42)
print "call g(22):", g(22)
print "call f(b=42):", f(b=42)
print "call f(b=7, a=8):", f(b=7, a=8)
print "call f(9, 10):", f(9, 10)
# Do some basic profiling
def nothing(a):
return a*42
import time
ITER=10000000
time.sleep(1.) # force preemption
st = time.time()
for i in xrange(ITER):
x = nothing(i)
et = time.time()
print "Basic: %fs" % (et-st)
t = et-st
time.sleep(1.) # force preemption
f = createFunction("return a*42", "a")
st = time.time()
for i in xrange(ITER):
x = f(i)
et = time.time()
print "FromString: %fs" % (et-st)
print "FromString time = Basic%+f%%" % ((((et-st) - t) / t)*100.)
