def test_readonly_symbols(self): def foo(): return 31 usersyms = { "a": 10, "b": 11, "c": 12, "d": 13, "foo": foo, "bar": foo, "x": 5, "y": 7 } aeval = Interpreter(usersyms=usersyms, readonly_symbols={"a", "b", "c", "d", "foo", "bar"}) aeval("a = 20") aeval("def b(): return 100") aeval("c += 1") aeval("del d") aeval("def foo(): return 55") aeval("bar = None") aeval("x = 21") aeval("y += a") assert(aeval("a") == 10) assert(aeval("b") == 11) assert(aeval("c") == 12) assert(aeval("d") == 13) assert(aeval("foo()") == 31) assert(aeval("bar()") == 31) assert(aeval("x") == 21) assert(aeval("y") == 17) assert(aeval("abs(8)") == 8) assert(aeval("abs(-8)") == 8) aeval("def abs(x): return x*2") assert(aeval("abs(8)") == 16) assert(aeval("abs(-8)") == -16) aeval2 = Interpreter(builtins_readonly=True) assert(aeval2("abs(8)") == 8) assert(aeval2("abs(-8)") == 8) aeval2("def abs(x): return x*2") assert(aeval2("abs(8)") == 8) assert(aeval2("abs(-8)") == 8)
def match_rule(rule, expression, pre_context, post_context): symbols = {} aeval = Interpreter() if not obtain_symbols(symbols, rule[1], expression): return False if not obtain_symbols(symbols, rule[0], pre_context): return False if not obtain_symbols(symbols, rule[2], post_context): return False aeval.symtable = symbols if rule[3] != None: conditions = rule[3].replace(" ", "").split(",") for cond in conditions: if not aeval(cond): return False sfinal = "" res_split = split_symbols(rule[4]) for r in res_split: if r.find("(") >= 0: sfinal += r[:r.find("(") + 1] temp = aeval(r[r.find("(") + 1:-1]) if type(temp) == tuple: sfinal += str(temp[0]) for t in temp[1:]: sfinal += "," sfinal += str(t) else: sfinal += str(temp) sfinal += ")" else: sfinal += r return sfinal
def __call__(self, parents, accumulator) -> str: """ Execute an action and ship its result """ parent_symbols = { k: ParentSymbol(accumulator[v.id_]) for k, v in self.format_node_names(parents).items() } # children_symbols = {k: ChildSymbol(v.id_) for k, v in self.format_node_names(children).items()} syms = make_symbol_table(use_numpy=False, **parent_symbols) aeval = Interpreter(usersyms=syms, no_while=True, no_try=True, no_functiondef=True, no_ifexp=False, no_augassign=True, no_assert=True, no_delete=True, no_raise=True, no_print=True, use_numpy=False, builtins_readonly=True) aeval(self.transform) output = aeval.symtable.get("result", None) if len(aeval.error) > 0: raise TransformException return output
def determine_category(self, relation_list, app_data_dict, attr_keys_search_mongo, server): ''' determine category by relation :param principal: the value user input :return: category_id ''' aeval = Interpreter() category_id = None for rl in relation_list: agg_cmp = [] relation_dict = json.loads( rl['relation']) # convert the 'relation' json to dict if set(list(relation_dict.keys())) != set(attr_keys_search_mongo): continue for kk, vv in relation_dict.items(): # evaluation the relation using the value of application if kk not in app_data_dict: agg_cmp.append(False) else: aeval.symtable['VALUE'] = app_data_dict.get(kk) agg_cmp.append(aeval(vv)) if np.array(agg_cmp).all(): category_id = rl['category_id'] break if category_id is not None: return category_id else: # cannot match the relation, just return the default one logging.warning('cannot match category, load default category_id') res_out = self.category_ID_access.read_default_category_id(server) return res_out['category_id']
def evaluate_dice_list(self): """ Evaluates each dice in the dice list, constructs and evaluates final string """ if self.verbosity: print(f"--> evaluate_dice_list") self.eval_expression = "" for i in range(len(self.dice_list)): if isinstance(self.dice_list[i], Die): if self.verbosity: print(f"dice_list[{i}] is Die") roll_result = self.dice_list[i].evaluate() if self.verbosity: print(f"roll_result: {roll_result}") self.eval_expression += str(roll_result) else: if self.verbosity: print(f"dice_list[{i}] is not Die") self.eval_expression += self.dice_list[i] # Evaluate the constructed string aeval = Interpreter() self.result = aeval.eval(self.eval_expression) if self.verbosity: print(f"result: {self.result}")
def test_stringio(self): """ test using stringio for output/errors """ out = StringIO() err = StringIO() intrep = Interpreter(writer=out, err_writer=err) intrep("print('out')") self.assertEqual(out.getvalue(), 'out\n')
def _eval(s, error=None, usersyms=None, **kwargs): error = error or 'cannot be eval!' from asteval import Interpreter usersyms = sh.combine_dicts(_usersyms, usersyms or {}) return Or(And(str, Use(Interpreter(usersyms=usersyms).eval), s), s, error=error)
def _process(self,): with open(self.prism_result_file, "r") as fptr: lines = fptr.readlines() max_param_idx = 0 aeval = Interpreter() for line in lines: if len(line) > 7: if line[0:6] == 'Result': param_idx, bscc_str = self.process_result_line(line) if param_idx > max_param_idx: max_param_idx = param_idx try: bscc_expr = aeval.parse(bscc_str) except Exception as ex: raise(ex) # sys.exit(ex) self.bscc_str_pfuncs.append(bscc_str) self.bscc_ast_pfuncs.append(bscc_expr) elif line[0:30] == 'Parametric model checking: P=?': pattern = re.compile(r'\[ F (.*?)\]') sbscc = re.search(pattern, line).group(1) sbscc = sbscc.rstrip().lstrip() bscc_label, _ = self.process_bscc_label(sbscc) self.bscc_labels.append(bscc_label) self.params_count = max_param_idx + 1
def __init__(self, asteval=None, usersyms=None): """ Arguments --------- asteval : :class:`asteval.Interpreter`, optional Instance of the `asteval.Interpreter` to use for constraint expressions. If None (default), a new interpreter will be created. **Warning: deprecated**, use `usersyms` if possible! usersyms : dict, optional Dictionary of symbols to add to the :class:`asteval.Interpreter` (default is None). """ super().__init__(self) self._asteval = asteval if asteval is None: self._asteval = Interpreter() else: msg = ("The use of the 'asteval' argument for the Parameters class" " was deprecated in lmfit v0.9.12 and will be removed in a " "later release. Please use the 'usersyms' argument instead!") warnings.warn(FutureWarning(msg)) self._asteval = asteval _syms = {} _syms.update(SCIPY_FUNCTIONS) if usersyms is not None: _syms.update(usersyms) for key, val in _syms.items(): self._asteval.symtable[key] = val
def __init__(self, asteval=None, usersyms=None, *args, **kwds): """ Arguments --------- asteval : :class:`asteval.Interpreter`, optional Instance of the asteval Interpreter to use for constraint expressions. If None, a new interpreter will be created. Warning: *deprecated, use usersyms if possible* usersyms : dictionary of symbols to add to the :class:`asteval.Interpreter`. *args : optional Arguments. **kwds : optional Keyword arguments. """ super(Parameters, self).__init__(self) self._asteval = asteval if self._asteval is None: self._asteval = Interpreter() _syms = {} _syms.update(SCIPY_FUNCTIONS) if usersyms is not None: _syms.update(usersyms) for key, val in _syms.items(): self._asteval.symtable[key] = val self.update(*args, **kwds)
def post(self, text): import pprint pp = pprint.PrettyPrinter(indent=4, depth=9) odds = self.config.get("behaviour", "reply_to_last_tweet_odds", fallback="0") import asteval from asteval import Interpreter aeval = Interpreter() odds = aeval(odds) pp.pprint(odds) import random if random.random() < odds: print("replying to last tweet") # randomly reply to last tweet tweets = self.twitter.statuses.user_timeline( screen_name=self.username, count=1) last_tweet_id = tweets[0]["id"] self.twitter.statuses.update(status=text, in_reply_to_status_id=last_tweet_id) else: print("not replying to last tweet") self.twitter.statuses.update(status=text)
def setUp(self): self.interp = Interpreter() self.symtable = self.interp.symtable self.set_stdout() self.set_stderr() if not HAS_NUMPY: self.interp("arange = range")
def recalculate(dataset): """Recalculate parameterized relationships within a dataset. Modifies values in place. Creates a ``TolerantParameterSet``, populates it with named parameters with a dataset, and then gets the evaluation order the graph of parameter relationships. After reevaluating all named parameters, creates an ``Interpreter`` with named parameters and all of numpy in its namespace. This interpreter is used to evaluate all other formulas in the dataset. Formulas that divide by zero are evaluated to zero. Returns the modified dataset.""" interpreter = Interpreter() parameter_set = TolerantParameterSet(extract_named_parameters(dataset)) for key, value in list(parameter_set.evaluate().items()): interpreter.symtable[key] = value for exc in iterate_all_parameters(dataset): if 'formula' in exc: try: exc['amount'] = interpreter(exc['formula']) except ZeroDivisionError: exc['amount'] = 0 elif 'variable' in exc: exc['amount'] = interpreter.symtable[exc['variable']] else: raise ValueError # https://github.com/OcelotProject/Ocelot/issues/111 for obj in iterate_all_uncertainties(dataset): if obj.get('uncertainty'): get_uncertainty_class(obj).repair(obj) return dataset
def evaluate(eval_code, input_variables={}, output_variables=[]): """Evaluates a given expression, with the timeout given as decorator. Args: eval_code (str): The code to be evaluated. input_variables (dict): dictionary of input variables and their values. output_variables (array): array of names of output variables. Returns: dict: the output variables or empty. """ # FIXME: use_numpy the process blocks infinitely at the return statement import time sym = make_symbol_table(time=time, use_numpy=False, range=range, **input_variables) aeval = Interpreter( symtable = sym, use_numpy = False, no_if = False, no_for = False, no_while = False, no_try = True, no_functiondef = True, no_ifexp = False, no_listcomp = True, no_augassign = False, # e.g., a += 1 no_assert = True, no_delete = True, no_raise = True, no_print = False) aeval(eval_code) symtable = {x: sym[x] for x in sym if x in output_variables} return symtable
def eval_bscc_pfuncs(self, ): aeval = Interpreter() if config.models['use_old_model']: aeval.symtable['p'] = self.params else: aeval.symtable['r'] = self.params return [aeval.run(f) for f in self.bscc_ast_pfuncs]
def test_custom_symtable(self): "test making and using a custom symbol table" if HAS_NUMPY: def cosd(x): "cos with angle in degrees" return np.cos(np.radians(x)) def sind(x): "sin with angle in degrees" return np.sin(np.radians(x)) def tand(x): "tan with angle in degrees" return np.tan(np.radians(x)) sym_table = make_symbol_table(cosd=cosd, sind=sind, tand=tand) aeval = Interpreter(symtable=sym_table) aeval("x1 = sind(30)") aeval("x2 = cosd(30)") aeval("x3 = tand(45)") x1 = aeval.symtable['x1'] x2 = aeval.symtable['x2'] x3 = aeval.symtable['x3'] assert_allclose(x1, 0.50, rtol=0.001) assert_allclose(x2, 0.866025, rtol=0.001) assert_allclose(x3, 1.00, rtol=0.001)
def test_eval(): aeval = Interpreter() expr_str = "r[0]**4 * r[1]**2 +" * 10000 + '2*r[2]' with DeepRecursionCtx(): expr = aeval.parse(expr_str) aeval.symtable['r'] = [1, 2, 3] res = aeval.eval(expr) assert not math.isnan(res)
async def clear(self, ctx): """Clear the state of your personal interpreter.""" try: del self.interpreters[ctx.author.id] except KeyError: await ctx.message.add_reaction("👍") self.interpreters[ctx.author.id] = Interpreter(no_print=True) await ctx.message.add_reaction("👍")
async def calc(self, ctx, *, expression: str): """ Evaluates a math expression. """ terp = Interpreter() result = terp.eval(expression) if result != '' and result is not None: await ctx.send(result) else: await ctx.send('Empty result.')
def expr(expression, context=None): if context is None: context = dict() interpreter = Interpreter() for variable, value in context.items(): interpreter.symtable[variable] = value return interpreter(expression)
def do_conversion(in_val, expr): aeval = Interpreter() try: aeval.symtable['x'] = in_val aeval(expr) value = aeval.symtable['Value'] except (KeyError, SyntaxError) as e: print(str(e)) value = None return value
def evaluate(self): """A helper method to check if submitted answer for the provided question is correct or not. This helper function uses asteval to perform check """ expression_interpreter = Interpreter() correct = SubmissionEvaluator.remove_exponent( Decimal("{:.3f}".format(expression_interpreter( self.expression))[:-1])) return str(correct) == self.submitted_result
def _objective_function(self, x): """ Abstract Objective Function Call :param x: Input Variable :return: Function Value of Objective """ aeval = Interpreter() exprc = aeval.parse(self.objective) aeval.symtable['x'] = x return aeval.run(exprc)
def __init__(self, usersyms=None): """ Arguments --------- usersyms : dictionary of symbols to add to the :class:`asteval.Interpreter`. """ super(Parameters, self).__init__(self) self._asteval = Interpreter(usersyms=usersyms)
def eval_pmc_pfuncs(self, ): aeval = Interpreter() if config.models['use_old_model']: aeval.symtable['p'] = self.params else: aeval.symtable['r'] = self.params for i in range(0, self.state_count): self.init_eval[i] = aeval.run(self.init_ast_pfuncs[i]) for i in range(0, self.state_count): for j in range(0, self.state_count): self.trans_eval[i][j] = aeval.run(self.trans_ast_pfuncs[i][j])
def __init__(self, first_pass_eq_name = None, eq_name = None, default_eq_name = 'aesthetics', verbose = False, ): """ Basic search results re-ranking model. Allows you to specify a simple custom re-ranking equation. NOTE: See here for the restrictions / features of asteval: https://newville.github.io/asteval/basics.html Equation `eq_name` can use any features provided by asteval, in addition to numpy via `np`. Args: first_pass_eq_name: (Optional) Equation run for first-pass, which can view the whole dataset. eq_name: String name (TODO or python callable?) to use as the re-ranking equation. Operates per-item. TODO: Intentionally not supporting python callables for now. Strings only. """ self.first_pass_eq_name = first_pass_eq_name if eq_name is None: ## Done this way, instead of default args on the function, so that mc_web can pass in `None` to indicate default: eq_name = default_eq_name self.eq_name = eq_name if verbose: print ('RERANK_EQUATION', first_pass_eq_name, eq_name) if eq_name in ranking_prebuilt_equations: eq = ranking_prebuilt_equations[eq_name] else: eq = eq_name self.eq = eq self.aeval = Interpreter() ## Access all functions of these modules: ## Turns out that asteval already imports all of `math`. for mod in []: for attr in dir(mod): if attr.startswith('_'): continue self.aeval.symtable[attr] = getattr(math, attr) ## numpy: self.aeval.symtable['np'] = np
def recalculate_exchanges(self, group: str, global_params: dict = None) -> Iterable[Tuple[int, float]]: """ Constructs a list of exc.id/amount tuples for the ParameterizedExchanges in the given group. """ params = self.initial.exc_by_group(group) if not params: return [] glo = global_params or {} interpreter = Interpreter() interpreter.symtable.update(glo) return [(k, interpreter(v)) for k, v in params.items()]
def run(self, script,data): for k,v in self.stateData.items(): data[k] = v data['stateData'] = self.stateData interpreter = Interpreter(data) interpreter.eval(script,0,True) for k,v in interpreter.symtable.items(): if type(v) in [str,int,float,bool]: #print 'saving {} in stateData'.format(k) self.stateData[k] = v interpreter = None
def button_equal(): equation = e.get() e.delete(0, END) my_eval = Interpreter() messsage = my_eval(equation) if len(my_eval.error) > 0: for err in my_eval.error: e.insert(0, err.get_error()) messsage = "Invalid operation" else: e.insert(0, messsage)
def get_interpreter(self, evaluate_first=True): """Get an instance of ``asteval.Interpreter`` that is prepopulated with global and local symbol names and values.""" if evaluate_first: self.evaluate_and_set_amount_field() interpreter = Interpreter() for key, value in self.global_params.items(): interpreter.symtable[key] = value for key, value in self.params.items(): interpreter.symtable[key] = value['amount'] return interpreter