def evaluate_context(self, context, verbose=True, allowed_missing=()):
evaluator = SimpleEval(
functions={
**DEFAULT_FUNCTIONS,
'log': np.log,
'log2': np.log2,
'log10': np.log10,
'sqrt': np.sqrt,
'abs': np.abs,
'ord': ord,
})
evaluator.names.update(context)
evaluator.names.update(self._constants)
allowed_missing = set(allowed_missing)
for name, code in self._evaluables.items():
try:
result = evaluator.eval(code) if isinstance(code,
str) else code
except NameNotDefined as error:
if error.name in allowed_missing:
allowed_missing.add(name)
log.debug(f'Skipped evaluating: {name}')
continue
else:
raise
if verbose:
log.debug(f'Evaluated: {name} = {repr(result)}')
evaluator.names[name] = context[name] = result
def visit_typedecl(self, node):
"""
Visit a node.
"""
if node.declname in self.names:
c_gen = c_generator.CGenerator()
pins = {}
operators = DEFAULT_OPERATORS
operators[ast.BitOr] = lambda a, b: a | b
operators[ast.LShift] = lambda a, b: a << b
operators[ast.RShift] = lambda a, b: a << b
evaluator = SimpleEval(DEFAULT_OPERATORS)
for pin in node.type.values.enumerators:
expr = c_gen.visit(pin.value)
if "(int)" in expr:
expr = expr.replace('(int)', '')
if expr in pins:
pins[pin.name] = pins[expr]
else:
pins[pin.name] = evaluator.eval(expr.strip())
return pins
class AnswerSelector:
_operators = {
ast.Add: operator.add,
ast.Sub: operator.sub,
ast.Mult: operator.mul,
ast.Div: operator.truediv
}
_evaluator = SimpleEval(operators=_operators)
@classmethod
def get_and_validate_answer(cls, source_id: str, text: str) -> int:
question = get_object_or_404(Question, source_id=source_id)
cls._validate_formula(text)
cls._validate_numbers(question.numbers, text)
return cls._evaluator.eval(text)
@staticmethod
def _validate_formula(text: str):
non_formula_text = re.search(r'[^ ()*+\-/0-9]', text)
if non_formula_text is not None:
raise UnknownCommandException
@staticmethod
def _validate_numbers(numbers: tuple, text: str):
text_numbers = re.split(r'[^0-9]', text)
text_numbers = filter(None, text_numbers)
text_numbers = (int(text) for text in text_numbers)
numbers = sorted(numbers)
text_numbers = sorted(text_numbers)
if numbers != text_numbers:
raise UnknownCommandException
def parse_entry(self, parsed_data):
if parsed_data[0] == 0: # concatenation
if len(parsed_data) == 1:
return
element = parsed_data[1]
remainder = parsed_data[2:]
remainder.insert(0, 0)
if type(element) is str:
result = None
for result in self.parse_entry(remainder):
yield element + result
if result is None:
yield element
else:
element_result = None
for element_result in self.parse_entry(element):
remainder_result = None
for remainder_result in self.parse_entry(remainder):
yield element_result + remainder_result
if remainder_result is None:
yield element_result
if element_result is None:
for remainder_result in self.parse_entry(remainder):
yield remainder_result
elif parsed_data[0] == 1: # random choice [a,b,c]
element = parsed_data[random.randint(1, len(parsed_data) - 1)]
if type(element) is not str:
for result in self.parse_entry(element):
yield result
else:
yield element
elif parsed_data[0] == 2: # multiple response {a,b,c}
for element in parsed_data[1:]:
if type(element) is str:
yield element
else:
for result in self.parse_entry(element):
yield result
elif parsed_data[0] == 3: # dynamic variable ${variable}
variable_name = parsed_data[1]
if type(variable_name) is not str:
variable_name = next(self.parse_entry(variable_name), '')
evaluator = SimpleEval(names=self.variables.copy(),
functions=EVAL_FUNCTIONS,
operators=EVAL_OPERATORS)
evaluator.names['variables'] = evaluator.names
evaluator.functions['eval'] = evaluator.eval
try:
yield str(evaluator.eval(variable_name))
except GeneratorExit:
pass
except:
yield '[Error: {0}]'.format(''.join(
traceback.format_exception_only(
sys.exc_info()[0],
sys.exc_info()[1])).strip())
def test_no_names(self):
# does not work on current Py3, True et al. are keywords now
self.s.eval('True')
# with self.assertRaises(NameNotDefined):
s = SimpleEval(names={})
if sys.version_info < (3, ):
with self.assertRaises(NameNotDefined):
s.eval('True')
else:
s.eval('True')
def __init__(self, name, electric_or_magnetic, expression_x, expression_y,
expression_z):
super().__init__(name, electric_or_magnetic)
self.expression_x = expression_x
self.expression_y = expression_y
self.expression_z = expression_z
self._ev = SimpleEval(functions={
"sin": math.sin,
"cos": math.cos,
"sqrt": math.sqrt
})
def test_functions_are_disallowed_at_init(self):
DISALLOWED = [type, isinstance, eval, getattr, setattr, help, repr, compile, open]
if simpleeval.PYTHON3:
exec('DISALLOWED.append(exec)') # exec is not a function in Python2...
for f in simpleeval.DISALLOW_FUNCTIONS:
assert f in DISALLOWED
for x in DISALLOWED:
with self.assertRaises(FeatureNotAvailable):
s = SimpleEval(functions ={'foo': x})
def __init__(
self,
card_pile_id,
mat_center,
mat_size,
mat_boundary,
card_size,
card_offset,
mat_color,
size_scaler,
update_event_handle,
per_deck_cards, #initial_num_of_decks=None,
face_down=True,
enable_generation=None,
num_of_decks_per_generation=1,
enable_auto_distribution=None,
destination_piles_and_cards=None,
title_property=None,
other_properties=None,
*args,
**kwargs):
super().__init__(card_pile_id,
mat_center,
mat_size,
mat_boundary,
card_size,
card_offset,
mat_color,
size_scaler,
sorting_rule=None,
auto_sort_setting=None,
enable_sort_button=False,
enable_recover_last_removed_cards=False,
update_event_handle=update_event_handle,
title_property=title_property,
other_properties=other_properties,
*args,
**kwargs)
self._simple_eval = SimpleEval()
self.enable_auto_distribution = enable_auto_distribution
self._destination_piles_and_cards = destination_piles_and_cards
self._ui_destination_piles_and_cards = {}
self.per_deck_cards = per_deck_cards
#self.initial_num_of_decks=initial_num_of_decks
self._enable_generation = enable_generation
self._num_of_decks_per_generation = num_of_decks_per_generation
self._ui_num_of_decks_per_generation = None
self._enable_auto_distribution = enable_auto_distribution
self._per_deck_cards = per_deck_cards
self.face_down = face_down
self._generation_button = None
self._auto_distribution_button = None
self.setup_vertical_ui_elements()
def __init__(self):
super().__init__()
# Create a sandboxed evaluator allowing to use the Q object,
# and the "|", "&" and "~" operators.
# See: https://github.com/danthedeckie/simpleeval
self.evaluator = SimpleEval(
functions={"Q": Q},
operators={
ast.BitOr: operator.or_,
ast.BitAnd: operator.and_,
ast.Invert: operator.invert,
},
)
def __init__(self, condition, daemon=None, watcher=None, alerter=None):
"""
Create Reminder object.
:param str condition:
An expression to indicate that an alert should be sent.
Should evaluate to True or False only.
:param ReminderDaemon daemon:
A ReminderDaemon instance where jobs will be scheduled.
:param Watcher watcher:
A Watcher instance to handle resource monitoring.
:param Alerter alerter:
An Alerter instance to handle sending notifications for Reminder.
"""
self._logger = logging.getLogger(__name__)
self._daemon = daemon
try:
self._logger.setLevel(self._daemon.logger.level)
except AttributeError:
pass
self.jobs = []
self.job_ids = []
self.condition = condition
if watcher:
self._logger.debug('creating watcher from: %s', watcher)
watcher['reminder'] = self
WatcherClass = getattr(
importlib.import_module('reminders.watchers'),
watcher.get('type'))
self.watcher = WatcherClass(**watcher)
jobs = self.watcher.schedules
for job in jobs:
job['func'] = self.check
self._logger.debug('added job to jobs: %s', job)
self.jobs.append(job)
if alerter:
self._logger.debug('creating alerter from: %s', alerter)
alerter['reminder'] = self
AlerterClass = getattr(
importlib.import_module('reminders.alerters'),
alerter.get('type'))
self.alerter = AlerterClass(**alerter)
self.simple_eval = SimpleEval()
self.simple_eval.names.update({
'status': self.status,
'now': self.now,
})
self.simple_eval.functions = {
'pendulum': pendulum,
'date': pendulum.instance
}
def eval_statements(statement, variable_context):
"""Evaluates math statements and returns the value
args
statement: a simple python-like math statement
variable_context: a dict with variable names as key and assigned values as dict values
"""
# variable values should be numbers
var_types = set(type(value) for value in variable_context.values())
if not var_types.issubset({int, float, long, Decimal, date, datetime, NoneType, bool}):
raise InvalidExpression
evaluator = SimpleEval(operators=SAFE_OPERATORS, names=variable_context, functions=FUNCTIONS)
return evaluator.eval(statement)
def __init__(self):
# Load the skins template.xml file
self.templatepath = os.path.join(SKIN_SHORTCUTS_PATH, "template.xml")
self.other_templates = []
try:
self.tree = ETree.parse(self.templatepath)
log("Loaded template.xml file")
# Pull out the names and includes of the 'other' templates -
# used to generate accurate progress and to build empty
# 'other' templates if necessary
for other_template in self.tree.getroot().findall("other"):
include_name = "skinshortcuts-template"
if "include" in other_template.attrib:
include_name = "skinshortcuts-template-%s" % \
(other_template.attrib.get("include"))
if include_name not in self.other_templates:
self.other_templates.append(include_name)
except:
# We couldn't load the template.xml file
if xbmcvfs.exists(self.templatepath):
# Unable to parse template.xml
log("Unable to parse template.xml. Invalid xml?")
else:
# No template.xml
self.tree = None
# Empty variable which will contain our base elementree (passed from buildxml)
self.includes = None
# Empty progress which will contain the Kodi progress dialog gui (passed from buildxml)
self.progress = None
self.percent = None
self.current = None
# List which will contain 'other' elements we will need to finalize (we won't have all the
# visibility conditions until the end)
self.finalize = []
# Initialize simple eval
self.simple_eval = SimpleEval()
self.simple_eval.operators[ast.In] = operator.contains
self.hashable = set()
self.hashable.add(self.templatepath)
def test_functions_are_disallowed_in_expressions(self):
DISALLOWED = [type, isinstance, eval, getattr, setattr, help, repr, compile, open]
if simpleeval.PYTHON3:
exec('DISALLOWED.append(exec)') # exec is not a function in Python2...
for f in simpleeval.DISALLOW_FUNCTIONS:
assert f in DISALLOWED
DF = simpleeval.DEFAULT_FUNCTIONS.copy()
for x in DISALLOWED:
simpleeval.DEFAULT_FUNCTIONS = DF.copy()
with self.assertRaises(FeatureNotAvailable):
s = SimpleEval()
s.functions['foo'] = x
s.eval('foo(42)')
simpleeval.DEFAULT_FUNCTIONS = DF.copy()
def __init__(self,
name,
electric_or_magnetic,
expression_x,
expression_y,
expression_z,
xp=numpy):
super().__init__(name, electric_or_magnetic)
self._xp = xp
self.expression_x = expression_x
self.expression_y = expression_y
self.expression_z = expression_z
self._ev = SimpleEval(functions={
"sin": xp.sin,
"cos": xp.cos,
"sqrt": xp.sqrt
},
operators={
ast.Add: op.add,
ast.Sub: op.sub,
ast.Mult: op.mul,
ast.Div: op.truediv,
ast.FloorDiv: op.floordiv,
ast.Pow: op.pow,
ast.Mod: op.mod,
ast.Eq: op.eq,
ast.NotEq: op.ne,
ast.Gt: op.gt,
ast.Lt: op.lt,
ast.GtE: op.ge,
ast.LtE: op.le,
ast.Not: op.not_,
ast.USub: op.neg,
ast.UAdd: op.pos,
ast.In: lambda x, y: op.contains(y, x),
ast.NotIn:
lambda x, y: not op.contains(y, x),
ast.Is: lambda x, y: x is y,
ast.IsNot: lambda x, y: x is not y,
})
'int': int,
'float': float,
'type': type,
'list': toArray,
'toArray': transformToArray,
'toSet': transformToSet,
'toBitarray': transformToBitwiseArray,
'sorted': mysorted,
'cover': cover,
'max': max,
'min': min,
'intersection': intersection,
'union': union
}
evaluator = SimpleEval(functions=FUNCTIONS_MAP)
def evaluateExpression(expression,
record,
workflow_stats={},
others=None): #data may be a simple record
evalResults = None
evaluator.names = record
evaluator.names.update(workflow_stats)
if others is not None:
evaluator.names.update(others)
try:
try: #BRICOLAAAGE!
int(expression)
evalResults = expression
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# pip install simpleeval
from simpleeval import SimpleEval
def get_from_url(value):
import requests
rs = requests.get('https://httpbin.org/get', params={'value': value})
return rs.json()['args']['value']
my_eval = SimpleEval()
my_eval.functions['get'] = get_from_url
print(my_eval.eval("get('123') + get('45')")) # '12345'
print(my_eval.eval("int(get('123')) + int(get('45'))")) # 168
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# SOURCE: https://github.com/danthedeckie/simpleeval#operators
# pip install simpleeval
from simpleeval import SimpleEval
import ast
import operator as op
s = SimpleEval()
s.operators[ast.BitXor] = op.xor
# # OR:
# s.operators[ast.BitXor] = lambda a, b: a ^ b
print(s.eval("2 ^ 10")) # 8
def __init__(self, app, setup_data, custom_functions={}):
#we keep the 'main' application class to call some functions there
self.app = app
#load the config
self.setup_data = setup_data
self.cfg = Configer(path + self.setup_data['basic']['config_file'])
#setup the window for the launcher
wp = WindowProperties.getDefault()
wp.setFixedSize(True)
wp.setFullscreen(False)
wp.setUndecorated(self.setup_data['basic']['undecorated'])
wp.setOrigin(-2, -2)
wp.setTitle(self.setup_data['basic']['title'])
wp.setSize(self.setup_data['basic']['window_size'][0],
self.setup_data['basic']['window_size'][1])
base.openMainWindow(props=wp)
base.win.setCloseRequestEvent('exit_program')
#a root node for ell the widgets
self.root = pixel2d.attachNewNode('launcher_root')
#set the bacground image
self.background = DirectFrame(
frameSize=_rec2d(self.setup_data['basic']['window_size'][0],
self.setup_data['basic']['window_size'][1]),
frameColor=(1, 1, 1, 1),
frameTexture=path + self.setup_data['basic']['background'],
parent=self.root)
_resetPivot(self.background)
self.background.setPos(_pos2d(0, 0))
#some vars used later
self.last_click_time = 0.0
self.shouldExit = False
self.last_button = None
self.last_select_button = None
self.last_select = None
self.last_button_group = 0
self.fonts = {}
self.buttons = []
self.last_slider_config_name = None
self.last_slider_name = None
#make the needed buttons
#needed for the updater part...
self.update_label = self.makeLabel("", 'wait')
x = self.setup_data['basic']["window_size"][0] / 2
x -= self.setup_data['style']['default']["size"][0] / 2
y = self.setup_data['basic']["window_size"][
1] - self.setup_data['style']['default']["size"][1] * 1.5
pos = [x, y]
self.update_done_button = self.makeButton(
self.setup_data['basic']['msg']['ok'], {
"style": "default",
"pos": pos,
"func": "updateDone()"
})
self.update_done_button.hide()
#needed for the loadscreen
self.loading_label = self.makeLabel(
self.setup_data['basic']['msg']['loading'], 'loading')
#needed for the slider screen
self.slider = DirectSlider(
frameSize=_rec2d(
self.setup_data['style']['slider']["size"][0] * 0.8,
self.setup_data['style']['slider']["size"][1]),
range=(0.0, 1.0),
value=0.5,
thumb_relief=DGG.FLAT,
thumb_frameTexture=path +
self.setup_data['style']['slider']['thumb_img'],
thumb_frameSize=(
self.setup_data['style']['slider']['thumb_size'][0] / 2,
-self.setup_data['style']['slider']['thumb_size'][0] / 2,
-self.setup_data['style']['slider']['thumb_size'][1] / 2,
self.setup_data['style']['slider']['thumb_size'][1] / 2),
frameTexture=path + self.setup_data['style']['slider']['img'],
frameVisibleScale=(1.25, 1),
command=self.setSliderValue,
parent=self.root)
x = self.setup_data['basic']["window_size"][0] / 2
x += (self.setup_data['style']['slider']["size"][0] * 0.8) / 2
y = self.setup_data['basic']["window_size"][1] / 2
y += self.setup_data['style']['slider']["size"][1] / 2
self.slider.setPos(_pos2d(x, y))
self.slider.setTransparency(TransparencyAttrib.MDual)
self.slider.hide()
self.slider_done_button = self.makeButton(
self.setup_data['basic']['msg']['ok'], {
"style": "default",
"pos": pos,
"func": "sliderDone()"
})
self.slider_done_button.hide()
self.slider_label = self.makeLabel("")
#needed for key input
self.key_input_label = self.makeLabel("")
self.key_input_current_label = self.makeLabel("", "key_input")
self.key_input_done = self.makeButton(
self.setup_data['basic']['msg']['ok'], {
"style": "default",
"pos": pos,
"func": "keyInputDone()"
})
self.key_input_done.hide()
#the rest
self.select_screens = {}
self.select_names = {}
self.select_labels = {}
for select_group in self.setup_data["select"]:
self.select_screens[select_group] = []
self.select_names[select_group] = {}
for label in self.setup_data["select"][select_group]:
self.select_names[select_group][self.setup_data["select"]
[select_group][label]] = label
self.select_screens[select_group].append(
self.makeSelectButton(label))
self.packSelectButtons(self.select_screens[select_group])
i = 0
for button_group in self.setup_data["buttons"]:
self.buttons.append({})
for button_name in button_group:
self.buttons[i][button_name] = self.makeButton(
button_name, button_group[button_name])
if i != 0:
self.buttons[i][button_name].hide()
i += 1
#SimpleEval stuff
names = {'None': None}
functions = {
'Vec3': Vec3,
'startGame': self.startGame,
'exitGame': self.exitGame,
'updateGame': self.updateGame,
'updateDone': self.updateDone,
'toggleButtonGroup': self.toggleButtonGroup,
'showButton': self.showButton,
'select': self.showSelectScreen,
'slide': self.showSlideScreen,
'key': self.showKeyInputScreen,
'keyInputDone': self.keyInputDone,
'sliderDone': self.sliderDone,
'selectItem': self.selectItem,
'saveConfig': self.saveConfig
}
for key in custom_functions:
functions[key] = custom_functions[key]
self.simple_eval = SimpleEval(names=names, functions=functions)
#events
self.accept('exit_program', self.exitGame)
base.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
self.accept('buttonDown', self.getKey)
#tasks
taskMgr.add(self.update, 'launcher_update')
def evaluate_context(self, context):
evaluator = SimpleEval()
evaluator.names.update(context)
for name, code in self._evaluables.items():
result = evaluator.eval(code) if isinstance(code, str) else code
evaluator.names[name] = context[name] = result
def test_no_functions(self):
self.s.eval('int(42)')
with self.assertRaises(FunctionNotDefined):
s = SimpleEval(functions={})
s.eval('int(42)')
def setUp(self):
""" initialize a SimpleEval """
self.s = SimpleEval()
def test_no_operators(self):
self.s.eval('1+2')
with self.assertRaises(OperatorNotDefined):
s = SimpleEval(operators={})
s.eval('1+2')
def setUp(self):
''' initialize a SimpleEval '''
self.s = SimpleEval()
import ast
import operator as op
SUPPORTED_OPERATORS = {
ast.Add: op.add,
ast.Sub: op.sub,
}
print(simple_eval("2 + 2 - 1", operators=SUPPORTED_OPERATORS)) # 3
try:
print(simple_eval(
"2 + 2 * 2",
operators=SUPPORTED_OPERATORS)) # KeyError: <class '_ast.Mult'>
except Exception as e:
print(repr(e))
print()
s = SimpleEval(operators=SUPPORTED_OPERATORS)
# # OR:
# s = SimpleEval()
# s.operators = SUPPORTED_OPERATORS
print(s.eval("2 + 2 - 1")) # 3
try:
print(s.eval("2 + 2 * 2")) # KeyError: <class '_ast.Mult'>
except Exception as e:
print(repr(e))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# pip install simpleeval
from simpleeval import simple_eval
my_functions = {
'my_pos': lambda: {
'x': 12,
'y': 10
},
'map': map,
'str': str,
}
print(simple_eval('my_pos()["x"] * my_pos()["y"]', functions=my_functions)) # 120
print(simple_eval('"x".join(map(str, my_pos().values()))', functions=my_functions)) # 12x10
print()
# OR:
from simpleeval import SimpleEval
my_eval = SimpleEval(functions=my_functions)
print(my_eval.eval('my_pos()["x"] * my_pos()["y"]')) # 120
print(my_eval.eval('"x".join(map(str, my_pos().values()))')) # 12x10
'round': round,
'abs': abs,
'sign': lambda x: -1 if x < 0 else 1 if x > 0 else 0,
# Number theory
'gcd': math.gcd,
# Statistics
'min': min,
'max': max,
'sum': sum,
'avg': lambda *x: sum(x) / len(x)
}
SIMPLE_EVAL = SimpleEval(functions=MATH_FUNCTIONS,
names={
'e': math.e,
'pi': math.pi,
'inf': math.inf,
'True': True,
'False': False
})
@make_pipe(
{
'expr':
Par(
str, None,
'The mathematical expression to evaluate. Use {} notation to insert items into the expression.'
)
},
command=True)
@many_to_one
