def query(request): input = request.POST.get('query', '') if settings.DEBUG and not input: input = request.GET.get('query', '') if settings.LOG_QUERIES: query_log = Query(query=input, error=True, browser=request.META.get('HTTP_USER_AGENT', ''), remote_user=request.META.get('REMOTE_USER', ''), remote_addr=request.META.get('REMOTE_ADDR', ''), remote_host=request.META.get('REMOTE_HOST', ''), meta=unicode(request.META), log='', ) query_log.save() user_definitions = request.session.get('definitions') definitions.set_user_definitions(user_definitions) try: evaluation = Evaluation(input, definitions, timeout=settings.TIMEOUT, format='xml') except Exception, exc: if settings.DEBUG and settings.DISPLAY_EXCEPTIONS: evaluation = Evaluation() info = traceback.format_exception(*sys.exc_info()) info = '\n'.join(info) msg = 'Exception raised: %s\n\n%s' % (exc, info) evaluation.results = [Result([Message('System', 'exception', msg)], None, None)] else: raise
def query(request): from mathics.core.parser import MultiLineFeeder input = request.POST.get('query', '') if settings.DEBUG and not input: input = request.GET.get('query', '') if settings.LOG_QUERIES: query_log = Query( query=input, error=True, browser=request.META.get('HTTP_USER_AGENT', ''), remote_user=request.META.get('REMOTE_USER', ''), remote_addr=request.META.get('REMOTE_ADDR', ''), remote_host=request.META.get('REMOTE_HOST', ''), meta=six.text_type(request.META), log='', ) query_log.save() user_definitions = request.session.get('definitions') definitions.set_user_definitions(user_definitions) evaluation = Evaluation(definitions, format='xml', output=WebOutput()) feeder = MultiLineFeeder(input, '<notebook>') results = [] try: while not feeder.empty(): expr = evaluation.parse_feeder(feeder) if expr is None: results.append(Result(evaluation.out, None, None)) # syntax errors evaluation.out = [] continue result = evaluation.evaluate(expr, timeout=settings.TIMEOUT) if result is not None: results.append(result) except Exception as exc: if settings.DEBUG and settings.DISPLAY_EXCEPTIONS: info = traceback.format_exception(*sys.exc_info()) info = '\n'.join(info) msg = 'Exception raised: %s\n\n%s' % (exc, info) results.append( Result([Message('System', 'exception', msg)], None, None)) else: raise result = { 'results': [result.get_data() for result in results], } request.session['definitions'] = definitions.get_user_definitions() if settings.LOG_QUERIES: query_log.timeout = evaluation.timeout query_log.result = six.text_type(result) # evaluation.results query_log.error = False query_log.save() return JsonResponse(result)
def create_output(tests, output_xml, output_tex): for format, output in [('xml', output_xml), ('tex', output_tex)]: definitions.reset_user_definitions() for test in tests.tests: key = test.key evaluation = Evaluation(definitions, format=format, catch_interrupt=False) results = evaluation.parse_evaluate(test.test) output[key] = { 'query': test.test, 'results': [r.get_data() for r in results], }
def test_case(test, tests, index=0, subindex=0, quiet=False, section=None): test, wanted_out, wanted = test.test, test.outs, test.result def fail(why): part, chapter, section = tests.part, tests.chapter, tests.section print("%sTest failed: %s in %s / %s\n%s\n%s\n" % (sep, section, part, chapter, test, why)) return False if not quiet: if section: print("%s %s / %s %s" % (stars, tests.chapter, section, stars)) print("%4d (%2d): TEST %s" % (index, subindex, test)) feeder = SingleLineFeeder(test, "<test>") evaluation = Evaluation(definitions, catch_interrupt=False, output=TestOutput()) try: query = evaluation.parse_feeder(feeder) if query is None: # parsed expression is None result = None out = evaluation.out else: result = evaluation.evaluate(query) out = result.out result = result.result except Exception as exc: fail("Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False if not compare(result, wanted): fail_msg = "Result: %s\nWanted: %s" % (result, wanted) if out: fail_msg += "\nAdditional output:\n" fail_msg += "\n".join(str(o) for o in out) return fail(fail_msg) output_ok = True if len(out) != len(wanted_out): output_ok = False else: for got, wanted in zip(out, wanted_out): if not got == wanted: output_ok = False break if not output_ok: return fail( "Output:\n%s\nWanted:\n%s" % ("\n".join(str(o) for o in out), "\n".join(str(o) for o in wanted_out))) return True
def query(request): from mathics.core.parser import MultiLineFeeder input = request.POST.get('query', '') if settings.DEBUG and not input: input = request.GET.get('query', '') if settings.LOG_QUERIES: query_log = Query(query=input, error=True, browser=request.META.get('HTTP_USER_AGENT', ''), remote_user=request.META.get('REMOTE_USER', ''), remote_addr=request.META.get('REMOTE_ADDR', ''), remote_host=request.META.get('REMOTE_HOST', ''), meta=six.text_type(request.META), log='', ) query_log.save() user_definitions = request.session.get('definitions') definitions.set_user_definitions(user_definitions) evaluation = Evaluation(definitions, format='xml', output=WebOutput()) feeder = MultiLineFeeder(input, '<notebook>') results = [] try: while not feeder.empty(): expr = evaluation.parse_feeder(feeder) if expr is None: results.append(Result(evaluation.out, None, None)) # syntax errors evaluation.out = [] continue result = evaluation.evaluate(expr, timeout=settings.TIMEOUT) if result is not None: results.append(result) except Exception as exc: if settings.DEBUG and settings.DISPLAY_EXCEPTIONS: info = traceback.format_exception(*sys.exc_info()) info = '\n'.join(info) msg = 'Exception raised: %s\n\n%s' % (exc, info) results.append(Result([Message('System', 'exception', msg)], None, None)) else: raise result = { 'results': [result.get_data() for result in results], } request.session['definitions'] = definitions.get_user_definitions() if settings.LOG_QUERIES: query_log.timeout = evaluation.timeout query_log.result = six.text_type(result) # evaluation.results query_log.error = False query_log.save() return JsonResponse(result)
def test_case(test, tests, index=0, quiet=False): test, wanted_out, wanted = test.test, test.outs, test.result part, chapter, section = tests.part, tests.chapter, tests.section def fail(why): print("%sTest failed: %s in %s / %s\n%s\n%s\n" % ( sep, section, part, chapter, test, why)) return False if not quiet: print('%4d. TEST %s' % (index, test)) feeder = SingleLineFeeder(test, '<test>') evaluation = Evaluation(definitions, catch_interrupt=False, output=TestOutput()) try: query = evaluation.parse_feeder(feeder) if query is None: # parsed expression is None result = None out = evaluation.out else: result = evaluation.evaluate(query) out = result.out result = result.result except Exception as exc: fail("Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False if not compare(result, wanted): fail_msg = "Result: %s\nWanted: %s" % (result, wanted) if out: fail_msg += "\nAdditional output:\n" fail_msg += '\n'.join(six.text_type(o) for o in out) return fail(fail_msg) output_ok = True if len(out) != len(wanted_out): output_ok = False else: for got, wanted in zip(out, wanted_out): if not got == wanted: output_ok = False break if not output_ok: return fail("Output:\n%s\nWanted:\n%s" % ( '\n'.join(six.text_type(o) for o in out), '\n'.join(six.text_type(o) for o in wanted_out))) return True
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): if not silent: from mathics.core.parser import MultiLineFeeder definitions = Definitions(add_builtin=True) evaluation = Evaluation(definitions, format='xml') feeder = MultiLineFeeder(code, '<notebook>') results = [] try: while not feeder.empty(): expr = evaluation.parse_feeder(feeder) if expr is None: results.append(Result(evaluation.out, None, None)) evaluation.out = [] continue result = evaluation.evaluate(expr, timeout=20) if result is not None: results.append(result) except Exception as exc: raise for result in results: result_data = result.get_data() result_html = self.preprocess_output(result_data['result']) display_data = { 'data': { 'text/html': result_html }, 'metadata': {}, } self.send_response(self.iopub_socket, 'display_data', display_data) return { 'status': 'ok', 'execution_count': self.execution_count, 'payload': [], 'user_expressions': {}, }
def create_output(tests, output_xml, output_tex): for format, output in [('xml', output_xml), ('tex', output_tex)]: definitions.reset_user_definitions() for test in tests.tests: key = test.key evaluation = Evaluation(definitions, format=format, catch_interrupt=False, output=TestOutput()) result = evaluation.parse_evaluate(test.test) if result is None: result = [] else: result = [result.get_data()] output[key] = { 'query': test.test, 'results': result, }
def __init__(self, add_builtin=False, builtin_filename=None, extension_modules=[]) -> None: super(Definitions, self).__init__() self.builtin = {} self.user = {} self.pymathics = {} self.definitions_cache = {} self.lookup_cache = {} self.proxy = defaultdict(set) self.now = 0 # increments whenever something is updated if add_builtin: from mathics.builtin import modules, contribute from mathics.core.evaluation import Evaluation from mathics.settings import ROOT_DIR loaded = False if builtin_filename is not None: builtin_dates = [get_file_time(module.__file__) for module in modules] builtin_time = max(builtin_dates) if get_file_time(builtin_filename) > builtin_time: builtin_file = open(builtin_filename, 'rb') self.builtin = pickle.load(builtin_file) loaded = True if not loaded: contribute(self) for module in extension_modules: try: loaded_module = self.load_pymathics_module(module, remove_on_quit=False) except PyMathicsLoadException as e: print(e.module + ' is not a valid pymathics module.') continue except ImportError as e: print(e.__repr__()) continue #print(module + loaded_module.pymathics_version_data['version'] + " by " + loaded_module.pymathics_version_data['author']) if builtin_filename is not None: builtin_file = open(builtin_filename, 'wb') pickle.dump(self.builtin, builtin_file, -1) # Load symbols from the autoload folder for root, dirs, files in os.walk(os.path.join(ROOT_DIR, 'autoload')): for path in [os.path.join(root, f) for f in files if f.endswith('.m')]: Expression('Get', String(path)).evaluate(Evaluation(self)) # Move any user definitions created by autoloaded files to # builtins, and clear out the user definitions list. This # means that any autoloaded definitions become shared # between users and no longer disappear after a Quit[]. # # Autoloads that accidentally define a name in Global` # could cause confusion, so check for this. # for name in self.user: if name.startswith('Global`'): raise ValueError("autoload defined %s." % name) self.builtin.update(self.user) self.user = {} self.clear_cache()
def main(): quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C' print_version(is_server=False) print_license() print u"Quit by pressing %s" % quit_command print '' definitions = Definitions(add_builtin=True) try: while True: input = raw_input('>> ') def out_callback(out): print to_output(unicode(out)) evaluation = Evaluation(input, definitions, timeout=30, out_callback=out_callback) for result in evaluation.results: if result.result is not None: print ' = %s' % to_output(unicode(result.result)) except (KeyboardInterrupt, SystemExit): print "\n\nGood bye!\n"
def __init__(self, add_builtin=False, builtin_filename=None): super(Definitions, self).__init__() self.builtin = {} self.user = {} self.autoload_stage = False if add_builtin: from mathics.builtin import modules, contribute from mathics.core.evaluation import Evaluation from mathics.settings import ROOT_DIR loaded = False if builtin_filename is not None: builtin_dates = [ get_file_time(module.__file__) for module in modules ] builtin_time = max(builtin_dates) if get_file_time(builtin_filename) > builtin_time: builtin_file = open(builtin_filename, 'r') self.builtin = pickle.load(builtin_file) loaded = True if not loaded: contribute(self) if builtin_filename is not None: builtin_file = open(builtin_filename, 'w') pickle.dump(self.builtin, builtin_file, -1) self.autoload_stage = True for root, dirs, files in os.walk( # noqa os.path.join(ROOT_DIR, 'autoload')): for f in filter(lambda x: x.endswith('.m'), files): with open(os.path.join(root, f)) as stream: Evaluation(stream.read(), self, timeout=30) self.autoload_stage = False
def get_session_evaluation(session): evaluation = _evaluations.get(session.session_key) if evaluation is None: definitions = Definitions(add_builtin=True) evaluation = Evaluation(definitions, format='xml', output=WebOutput()) _evaluations[session.session_key] = evaluation return evaluation
def get_session_evaluation(session): evaluation = _evaluations.get(session.session_key) if evaluation is None: definitions = Definitions(add_builtin=True) # We set the formatter to "unformatted" so that we can use # our own custom formatter that understand better how to format # in the context of mathics-django. # Previously, one specific format, like "xml" had to fit all. evaluation = Evaluation(definitions, format="unformatted", output=WebOutput()) _evaluations[session.session_key] = evaluation evaluation.format_output = lambda expr, format: format_output( evaluation, expr, format) autoload_files(definitions, ROOT_DIR, "autoload") return evaluation
def mathics_system_info(defs): def eval(name, needs_head=True): evaled = name().evaluate(evaluation) if needs_head: return evaled.head.to_python(string_quotes=False) else: return evaled.to_python(string_quotes=False) evaluation = Evaluation(defs, output=None) return { "$Machine": sys.platform, "$MachineName": platform.uname().node, "$ProcessID": os.getppid(), "$ProcessorType": platform.machine(), "$SystemID": sys.platform, "$UserName": eval(msystem.UserName), "$SystemMemory": eval(msystem.SystemMemory), "MemoryAvailable[]": eval(msystem.MemoryAvailable, needs_head=False), "$SystemTimeZone": eval(datentime.SystemTimeZone), "MachinePrecision": eval(numeric.MachinePrecision_), "$BaseDirectory": eval(filesystem.BaseDirectory), "$RootDirectory": eval(filesystem.RootDirectory), "$HomeDirectory": eval(filesystem.HomeDirectory), "$InstallationDirectory": eval(filesystem.InstallationDirectory), "$TemporaryDirectory": eval(filesystem.TemporaryDirectory), }
def _eval(self, code): """ Evaluates a command inside the Mathics interpreter and returns the output as a Mathics result. EXAMPLES:: sage: mathics._eval('1+1').last_eval # optional - mathics <Integer: 2> """ self._lazy_init() S = self._session expr = S.evaluate(code) from mathics.core.evaluation import Evaluation ev = Evaluation(S.definitions) return ev.evaluate(expr)
def _test_group(k, *group): for i, a in enumerate(group): for j, b in enumerate(group): if i == j: continue evaluation = Evaluation(definitions, catch_interrupt=False) try: is_same_under_sameq = Expression('SameQ', a, b).evaluate(evaluation) except Exception as exc: print("Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False is_same = a.same(b) if is_same != _symbol_truth_value(is_same_under_sameq): print( "%sTest failed: %s and %s are inconsistent under same() and SameQ\n" % (sep, repr(a), repr(b))) return False if is_same and hash(a) != hash(b): print( "%sTest failed: hashes for %s and %s must be equal but are not\n" % (sep, repr(a), repr(b))) return False
def _pythonized_mathics_expr(*x): inner_evaluation = Evaluation(definitions=evaluation.definitions) vars = dict(list(zip(names, x[: len(names)]))) pyexpr = expr.replace_vars(vars) pyexpr = Expression("N", pyexpr).evaluate(inner_evaluation) res = pyexpr.to_python(n_evaluation=inner_evaluation) return res
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): # TODO update user definitions response = { 'payload': [], 'user_expressions': {}, } formats = { 'text/plain': 'text', 'text/html': 'xml', 'text/latex': 'tex', } try: self.init_web_engine() evaluation = Evaluation(self.definitions, output=KernelOutput(self), format=formats) result = evaluation.parse_evaluate(code, timeout=settings.TIMEOUT) if result: self.result_callback(result) except Exception as exc: stack = traceback.format_exception(*sys.exc_info()) self.out_callback( Print('An error occured: ' + str(exc) + '\n\n' + '\n'.join(stack))) # internal error response['status'] = 'error' response['ename'] = 'System:exception' response['traceback'] = stack else: response['status'] = 'ok' response['execution_count'] = self.definitions.get_line_no() return response
def test_case(test, tests, index=0, quiet=False): test, wanted_out, wanted = test.test, test.outs, test.result part, chapter, section = tests.part, tests.chapter, tests.section def fail(why): print("%sTest failed: %s in %s / %s\n%s\n%s\n" % (sep, section, part, chapter, test, why)) return False if not quiet: print('%4d. TEST %s' % (index, test)) evaluation = Evaluation(definitions, catch_interrupt=False) try: results = evaluation.parse_evaluate(test) except Exception as exc: fail("Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False if results: if len(results) > 1: return fail("Too many results: %s" % results) result = results[0].result out = results[0].out else: result = None out = [] if not compare(result, wanted): fail_msg = "Result: %s\nWanted: %s" % (result, wanted) if out: fail_msg += "\nAdditional output:\n" fail_msg += '\n'.join(six.text_type(o) for o in out) return fail(fail_msg) output_ok = True if len(out) != len(wanted_out): output_ok = False else: for got, wanted in zip(out, wanted_out): if not got == wanted: output_ok = False break if not output_ok: return fail("Output:\n%s\nWanted:\n%s" % ('\n'.join( six.text_type(o) for o in out), '\n'.join(six.text_type(o) for o in wanted_out))) return True
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): #Initialize mathjax... It should be a beter place to do it inside the imathics kernel if not self.mathjax_initialized: self.mathjax_initialized = True self.Display(Javascript(''' MathJax.Hub.Config({jax: ["input/TeX","input/MathML","input/AsciiMath","output/HTML-CSS","output/NativeMML", "output/PreviewHTML"],extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathMenu.js","MathZoom.js", "fast-preview.js", "AssistiveMML.js"],TeX: { extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js", "noUndefined.js"]}});''', lib="https://cdn.mathjax.org/mathjax/latest/MathJax.js")) # TODO update user definitions response = { 'payload': [], 'user_expressions': {}, } try: evaluation = Evaluation(code, self.definitions, out_callback=self.out_callback, timeout=settings.TIMEOUT,format="xml") except Exception as exc: response['status'] = 'error' response['ename'] = 'System:exception' response['traceback'] = traceback.format_exception(*sys.exc_info()) evaluation = Evaluation() raise exc else: response['status'] = 'ok' if not silent: for result in evaluation.results: if result.result is not None: xmlchain = result.result xmlchain= MathicsKernel.svg_open_tag.sub("<mtable><mtr><mtd><annotation-xml encoding=\"text/html\" ><svg",xmlchain) xmlchain= MathicsKernel.svg_close_tag.sub("</svg></annotation-xml></mtd></mtr></mtable>",xmlchain) data = { 'text/html': xmlchain, # TODO html / mathjax output } content = {'execution_count': result.line_no, 'data': data, 'metadata': {}} self.send_response(self.iopub_socket, 'execute_result', content) response['execution_count'] = self.definitions.get_line() return response
def test_case(test, tests, index=0, quiet=False): test, wanted_out, wanted = test.test, test.outs, test.result part, chapter, section = tests.part, tests.chapter, tests.section def fail(why): print("%sTest failed: %s in %s / %s\n%s\n%s\n" % ( sep, section, part, chapter, test, why)) return False if not quiet: print('%4d. TEST %s' % (index, test)) evaluation = Evaluation(definitions, catch_interrupt=False) try: results = evaluation.parse_evaluate(test) except Exception as exc: fail("Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False if results: if len(results) > 1: return fail("Too many results: %s" % results) result = results[0].result out = results[0].out else: result = None out = [] if not compare(result, wanted): fail_msg = "Result: %s\nWanted: %s" % (result, wanted) if out: fail_msg += "\nAdditional output:\n" fail_msg += '\n'.join(six.text_type(o) for o in out) return fail(fail_msg) output_ok = True if len(out) != len(wanted_out): output_ok = False else: for got, wanted in zip(out, wanted_out): if not got == wanted: output_ok = False break if not output_ok: return fail("Output:\n%s\nWanted:\n%s" % ( '\n'.join(six.text_type(o) for o in out), '\n'.join(six.text_type(o) for o in wanted_out))) return True
def create_output(tests, output_xml, output_tex): for format, output in [('xml', output_xml), ('tex', output_tex)]: reset_user_definitions() for test in tests.tests: key = test.key evaluation = Evaluation(definitions, format=format, catch_interrupt=False) result = evaluation.parse_evaluate(test.test) if result is None: result = [] else: result = [result.get_data()] output[key] = { 'query': test.test, 'results': result, }
def mathics_shell(shell): while True: try: evaluation = Evaluation(shell.definitions, output=TerminalOutput(shell)) query = evaluation.parse_feeder(shell) if query is None: continue result = evaluation.evaluate(query, timeout=settings.TIMEOUT) if result is not None: shell.print_result(result) except (KeyboardInterrupt): print('\nKeyboardInterrupt') except (SystemExit, EOFError): break finally: shell.reset_lineno()
def onload(definitions): # from mathics.builtin import box_constructs # box_constructs["System`GraphicsBox"] = AsyGraphicsBox(expression=False) # box_constructs["System`Graphics3DBox"] = AsyGraphics3DBox(expression=False) MathicsExport._extdict["pdf"] = "PDF" definitions.set_ownvalue("Settings`UseAsyForGraphics2D", SymbolTrue) for root, dirs, files in os.walk(os.path.join(ROOT_DIR, "autoload")): for path in [os.path.join(root, f) for f in files if f.endswith(".m")]: Expression("Get", String(path)).evaluate(Evaluation(definitions))
def evaluate(self, text): evaluation = Evaluation(text, self.definitions, timeout=30, out_callback=out_callback) for result in evaluation.results: if result.result is not None: print self.get_out_prompt() + to_output(unicode( result.result)) + '\n'
def __init__(self, add_builtin=True, catch_interrupt=False, form="InputForm"): self.definitions = Definitions(add_builtin) self.evaluation = Evaluation(definitions=self.definitions, catch_interrupt=catch_interrupt) self.form = form self.last_result = None
def run(): global result # prompt = '(1+a)(1+b)(1+c)(1+d)(1+e)//Expand' # prompt = 'f/@Range[20000];' # prompt = 'Plus @@ Range[50000]' # prompt = 'Range[100000];' try: # prompt = 'SetAttributes[v, Flat]; v[x_]:={x}; v[a,b]' # prompt = """(Plus@@Symbol/@CharacterRange["a","z"])^2//Expand;""" # prompt = ( # 'Plus@@f/@Symbol/@StringJoin/@Tuples[CharacterRange["a","z"],2]') # prompt = 'FullForm[Nest[1+Sqrt[1+#]&, x, 20]]' # prompt = '1+2' prompt = 'DensityPlot[x*y,{x,-1,1},{y,-1,1}]' evaluation = Evaluation(definitions, format='xml') result = evaluation.parse_evaluate(prompt) except KeyboardInterrupt: result = 'INTERRUPTED'
def create_output(tests, output, format="tex"): definitions.reset_user_definitions() for test in tests.tests: if test.private: continue key = test.key evaluation = Evaluation(definitions, format=format, catch_interrupt=False, output=TestOutput()) result = evaluation.parse_evaluate(test.test) if result is None: result = [] else: result = [result.get_data()] output[key] = { "query": test.test, "results": result, }
def query(request): input = request.POST.get('query', '') if settings.DEBUG and not input: input = request.GET.get('query', '') if settings.LOG_QUERIES: query_log = Query(query=input, error=True, browser=request.META.get('HTTP_USER_AGENT', ''), remote_user=request.META.get('REMOTE_USER', ''), remote_addr=request.META.get('REMOTE_ADDR', ''), remote_host=request.META.get('REMOTE_HOST', ''), meta=six.text_type(request.META), log='', ) query_log.save() user_definitions = request.session.get('definitions') definitions.set_user_definitions(user_definitions) evaluation = Evaluation(definitions, format='xml') try: results = evaluation.parse_evaluate(input, timeout=settings.TIMEOUT) except Exception as exc: if settings.DEBUG and settings.DISPLAY_EXCEPTIONS: info = traceback.format_exception(*sys.exc_info()) info = '\n'.join(info) msg = 'Exception raised: %s\n\n%s' % (exc, info) results = [Result([Message('System', 'exception', msg)], None, None)] else: raise result = { 'results': [result.get_data() for result in results], } request.session['definitions'] = definitions.get_user_definitions() if settings.LOG_QUERIES: query_log.timeout = evaluation.timeout query_log.result = six.text_type(result) # evaluation.results query_log.error = False query_log.save() return JsonResponse(result)
def __init__(self, add_builtin=False, builtin_filename=None): super(Definitions, self).__init__() self.builtin = {} self.user = {} self.definitions_cache = {} self.lookup_cache = {} self.proxy = defaultdict(set) self.now = 0 # increments whenever something is updated if add_builtin: from mathics.builtin import modules, contribute from mathics.core.evaluation import Evaluation from mathics.settings import ROOT_DIR loaded = False if builtin_filename is not None: builtin_dates = [ get_file_time(module.__file__) for module in modules ] builtin_time = max(builtin_dates) if get_file_time(builtin_filename) > builtin_time: builtin_file = open(builtin_filename, 'rb') self.builtin = pickle.load(builtin_file) loaded = True if not loaded: contribute(self) if builtin_filename is not None: builtin_file = open(builtin_filename, 'wb') pickle.dump(self.builtin, builtin_file, -1) for root, dirs, files in os.walk(os.path.join( ROOT_DIR, 'autoload')): for path in [ os.path.join(root, f) for f in files if f.endswith('.m') ]: Expression('Get', String(path)).evaluate(Evaluation(self)) # Move any user definitions created by autoloaded files to # builtins, and clear out the user definitions list. This # means that any autoloaded definitions become shared # between users and no longer disappear after a Quit[]. # # Autoloads that accidentally define a name in Global` # could cause confusion, so check for this. # for name in self.user: if name.startswith('Global`'): raise ValueError("autoload defined %s." % name) self.builtin.update(self.user) self.user = {} self.clear_cache()
def load_settings(shell): autoload_files(shell.definitions, get_srcdir(), "autoload") settings_file = ensure_settings() if settings_file == "": return with open(settings_file, "r") as src: feeder = MathicsFileLineFeeder(src) try: while not feeder.empty(): evaluation = Evaluation( shell.definitions, output=TerminalOutput(shell), catch_interrupt=False, format="text", ) query = evaluation.parse_feeder(feeder) if query is None: continue evaluation.evaluate(query) except (KeyboardInterrupt): print("\nKeyboardInterrupt") return True
def create_output(tests, doc_data, format="xml"): definitions.reset_user_definitions() for test in tests.tests: if test.private: continue key = test.key evaluation = Evaluation(definitions, format=format, catch_interrupt=True, output=TestOutput()) try: result = evaluation.parse_evaluate(test.test) except: result = None if result is None: result = [] else: result = [result.get_data()] doc_data[key] = { "query": test.test, "results": result, }
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): # TODO update user definitions response = { 'payload': [], 'user_expressions': {}, } formats = { 'text/plain': 'text', 'text/html': 'xml', 'text/latex': 'tex', } try: self.init_web_engine() evaluation = Evaluation(self.definitions, output=KernelOutput(self), format=formats) result = evaluation.parse_evaluate(code, timeout=settings.TIMEOUT) if result: self.result_callback(result) except Exception as exc: stack = traceback.format_exception(*sys.exc_info()) self.out_callback(Print('An error occured: ' + str(exc) + '\n\n' + '\n'.join(stack))) # internal error response['status'] = 'error' response['ename'] = 'System:exception' response['traceback'] = stack else: response['status'] = 'ok' response['execution_count'] = self.definitions.get_line_no() return response
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): # TODO update user definitions response = { 'payload': [], 'user_expressions': {}, } evaluation = Evaluation(self.definitions, result_callback=self.result_callback, out_callback=self.out_callback, clear_output_callback=self.clear_output_callback, display_data_callback=self.display_data_callback) try: results = evaluation.parse_evaluate(code, timeout=settings.TIMEOUT) except Exception as exc: # internal error response['status'] = 'error' response['ename'] = 'System:exception' response['traceback'] = traceback.format_exception(*sys.exc_info()) results = [] else: response['status'] = 'ok' response['execution_count'] = self.definitions.get_line_no() return response
def query(request): input = request.POST.get('query', '') if settings.DEBUG and not input: input = request.GET.get('query', '') if settings.LOG_QUERIES: query_log = Query( query=input, error=True, browser=request.META.get('HTTP_USER_AGENT', ''), remote_user=request.META.get('REMOTE_USER', ''), remote_addr=request.META.get('REMOTE_ADDR', ''), remote_host=request.META.get('REMOTE_HOST', ''), meta=unicode(request.META), log='', ) query_log.save() user_definitions = request.session.get('definitions') definitions.set_user_definitions(user_definitions) try: evaluation = Evaluation(input, definitions, timeout=settings.TIMEOUT, format='xml') except Exception, exc: if settings.DEBUG and settings.DISPLAY_EXCEPTIONS: evaluation = Evaluation() info = traceback.format_exception(*sys.exc_info()) info = '\n'.join(info) msg = 'Exception raised: %s\n\n%s' % (exc, info) evaluation.results = [ Result([Message('System', 'exception', msg)], None, None) ] else: raise
def evaluate(self, text): def to_output(text): line_number = self.get_last_line_number() newline = '\n' + ' ' * len('Out[{0}]= '.format(line_number)) return newline.join(text.splitlines()) def out_callback(out): print to_output(unicode(out)) evaluation = Evaluation(text, self.definitions, timeout=settings.TIMEOUT, out_callback=out_callback) for result in evaluation.results: if result.result is not None: print(self.get_out_prompt() + to_output(unicode(result.result)) + '\n')
def test_case(test, tests, index=0, quiet=False): test, wanted_out, wanted = test.test, test.outs, test.result part, chapter, section = tests.part, tests.chapter, tests.section def fail(why): print u"%sTest failed: %s in %s / %s\n%s\n%s\n" % (sep, section, part, chapter, test, why) return False if not quiet: print '%4d. TEST %s' % (index, test) try: evaluation = Evaluation(test, definitions, catch_interrupt=False) except Exception, exc: fail(u"Exception %s" % exc) info = sys.exc_info() sys.excepthook(*info) return False
def main(): argparser = argparse.ArgumentParser( prog='mathics', usage='%(prog)s [options] [FILE]', add_help=False, description="Mathics is a general-purpose computer algebra system.", epilog="""Please feel encouraged to contribute to Mathics! Create your own fork, make the desired changes, commit, and make a pull request.""") argparser.add_argument( 'FILE', nargs='?', type=argparse.FileType('r'), help='execute commands from FILE') argparser.add_argument( '--help', '-h', help='show this help message and exit', action='help') argparser.add_argument( '--persist', help='go to interactive shell after evaluating FILE or -e', action='store_true') argparser.add_argument( '--quiet', '-q', help='don\'t print message at startup', action='store_true') argparser.add_argument( '-script', help='run a mathics file in script mode', action='store_true') argparser.add_argument( '--execute', '-e', action='append', metavar='EXPR', help='evaluate EXPR before processing any input files (may be given ' 'multiple times)') argparser.add_argument( '--colors', nargs='?', help='interactive shell colors') argparser.add_argument( '--no-completion', help="disable tab completion", action='store_true') argparser.add_argument( '--no-readline', help="disable line editing (implies --no-completion)", action='store_true') argparser.add_argument( '--version', '-v', action='version', version='%(prog)s ' + __version__) args = argparser.parse_args() quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-D' definitions = Definitions(add_builtin=True) definitions.set_line_no(0) shell = TerminalShell( definitions, args.colors, want_readline=not(args.no_readline), want_completion=not(args.no_completion)) if args.execute: for expr in args.execute: print(shell.get_in_prompt() + expr) evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback) result = evaluation.parse_evaluate(expr, timeout=settings.TIMEOUT) shell.print_result(result) if not args.persist: return if args.FILE is not None: feeder = FileLineFeeder(args.FILE) try: while not feeder.empty(): evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback, catch_interrupt=False) query = evaluation.parse_feeder(feeder) if query is None: continue evaluation.evaluate(query, timeout=settings.TIMEOUT) except (KeyboardInterrupt): print('\nKeyboardInterrupt') if args.persist: definitions.set_line_no(0) else: return if not args.quiet: print() print(version_string + '\n') print(license_string + '\n') print("Quit by pressing {0}\n".format(quit_command)) while True: try: evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback) query = evaluation.parse_feeder(shell) if query is None: continue result = evaluation.evaluate(query, timeout=settings.TIMEOUT) if result is not None: shell.print_result(result) except (KeyboardInterrupt): print('\nKeyboardInterrupt') except (SystemExit, EOFError): print("\n\nGood bye!\n") break finally: shell.reset_lineno()
def main(): argparser = argparse.ArgumentParser( prog='mathics', usage='%(prog)s [options] [FILE]', add_help=False, description="Mathics is a general-purpose computer algebra system.", epilog="""Please feel encouraged to contribute to Mathics! Create your own fork, make the desired changes, commit, and make a pull request.""") argparser.add_argument( 'FILE', nargs='?', type=argparse.FileType('r'), help='execute commands from FILE') argparser.add_argument( '--help', '-h', help='show this help message and exit', action='help') argparser.add_argument( '--persist', help='go to interactive shell after evaluating FILE or -e', action='store_true') argparser.add_argument( '--quiet', '-q', help='don\'t print message at startup', action='store_true') argparser.add_argument( '-script', help='run a mathics file in script mode', action='store_true') argparser.add_argument( '--execute', '-e', action='append', metavar='EXPR', help='evaluate EXPR before processing any input files (may be given ' 'multiple times)') argparser.add_argument( '--colors', nargs='?', help='interactive shell colors') argparser.add_argument( '--no-completion', help="disable tab completion", action='store_true') argparser.add_argument( '--no-readline', help="disable line editing (implies --no-completion)", action='store_true') argparser.add_argument( '--version', '-v', action='version', version='%(prog)s ' + __version__) args = argparser.parse_args() quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-D' definitions = Definitions(add_builtin=True) definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number shell = TerminalShell( definitions, args.colors, want_readline=not(args.no_readline), want_completion=not(args.no_completion)) if not (args.quiet or args.script): print() print(version_string + '\n') print(license_string + '\n') print("Quit by pressing {0}\n".format(quit_command)) if args.execute: for expr in args.execute: print(shell.get_in_prompt() + expr) evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback) exprs = evaluation.parse(expr) results = evaluation.evaluate(exprs, timeout=settings.TIMEOUT) shell.print_results(results) if not args.persist: return if args.FILE is not None: lines = args.FILE.readlines() if args.script and lines[0].startswith('#!'): lines[0] = '' results = [] query_gen = parse_lines(lines, shell.definitions) evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback) try: for query in query_gen: results.extend(evaluation.evaluate([query], timeout=settings.TIMEOUT)) except TranslateError as exc: evaluation.recursion_depth = 0 evaluation.stopped = False evaluation.message('Syntax', exc.msg, *exc.args) except (KeyboardInterrupt): print('\nKeyboardInterrupt') except (SystemExit, EOFError): print("\n\nGood bye!\n") if not args.persist: return total_input = "" while True: try: evaluation = Evaluation(shell.definitions, out_callback=shell.out_callback) line = shell.read_line(shell.get_in_prompt(continued=total_input != '')) total_input += line try: query = parse(total_input, shell.definitions) except TranslateError as exc: if line == '' or not isinstance(exc, IncompleteSyntaxError): evaluation.message('Syntax', exc.msg, *exc.args) total_input = "" continue total_input = "" if query is None: continue results = evaluation.evaluate([query], timeout=settings.TIMEOUT) shell.print_results(results) except (KeyboardInterrupt): print('\nKeyboardInterrupt') except (SystemExit, EOFError): print("\n\nGood bye!\n") break