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 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 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 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): # 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 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 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 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 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, output=TerminalOutput(shell)) 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, output=TerminalOutput(shell), 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, 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): print("\n\nGoodbye!\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_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() -> int: """ Command-line entry. Return exit code we want to give status of """ exit_rc = 0 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( "--full-form", "-F", help="Show how input was parsed to FullForm", action="store_true", ) argparser.add_argument( "--pyextensions", "-l", action="append", metavar="PYEXT", help="directory to load extensions in python", ) argparser.add_argument( "--persist", help="go to interactive shell after evaluating FILE or -e", action="store_true", ) # --initfile is different from the combination FILE --persist since the first one # leaves the history empty and sets the current $Line to 1. argparser.add_argument( "--initfile", help="the same that FILE and --persist together", type=argparse.FileType("r"), ) 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, script_args = argparser.parse_known_args() quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-D" extension_modules = [] if args.pyextensions: for ext in args.pyextensions: extension_modules.append(ext) else: from mathics.settings import default_pymathics_modules extension_modules = default_pymathics_modules definitions = Definitions(add_builtin=True, extension_modules=extension_modules) definitions.set_line_no(0) shell = TerminalShell( definitions, args.colors, want_readline=not (args.no_readline), want_completion=not (args.no_completion), ) if args.initfile: feeder = FileLineFeeder(args.initfile) try: while not feeder.empty(): evaluation = Evaluation( shell.definitions, output=TerminalOutput(shell), catch_interrupt=False, ) query = evaluation.parse_feeder(feeder) if query is None: continue evaluation.evaluate(query, timeout=settings.TIMEOUT) except (KeyboardInterrupt): print("\nKeyboardInterrupt") definitions.set_line_no(0) if args.execute: for expr in args.execute: evaluation = Evaluation(shell.definitions, output=TerminalOutput(shell)) result = evaluation.parse_evaluate(expr, timeout=settings.TIMEOUT) shell.print_result(result, no_out_prompt=True) if evaluation.exc_result == Symbol("Null"): exit_rc = 0 elif evaluation.exc_result == Symbol("$Aborted"): exit_rc = -1 elif evaluation.exc_result == Symbol("Overflow"): exit_rc = -2 else: exit_rc = -3 if not args.persist: return exit_rc if args.FILE is not None: feeder = FileLineFeeder(args.FILE) try: while not feeder.empty(): evaluation = Evaluation( shell.definitions, output=TerminalOutput(shell), 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 exit_rc 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, output=TerminalOutput(shell)) query, source_code = evaluation.parse_feeder_returning_code(shell) if len(source_code) and source_code[0] == "!": subprocess.run(source_code[1:], shell=True) shell.definitions.increment_line_no(1) continue if query is None: continue if args.full_form: print(query) result = evaluation.evaluate(query, timeout=settings.TIMEOUT) if result is not None: shell.print_result(result) except (KeyboardInterrupt): print("\nKeyboardInterrupt") except EOFError: print("\n\nGoodbye!\n") break except SystemExit: print("\n\nGoodbye!\n") # raise to pass the error code on, e.g. Quit[1] raise finally: shell.reset_lineno() return exit_rc
def main( full_form, persist, quiet, readline, completion, unicode, prompt, pyextensions, execute, run, style, pygments_tokens, strict_wl_output, file, ) -> int: """A command-line interface to Mathics. Mathics is a general-purpose computer algebra system """ exit_rc = 0 quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-D" extension_modules = [] if pyextensions: for ext in pyextensions: extension_modules.append(ext) definitions = Definitions(add_builtin=True) definitions.set_line_no(0) # Set a default value for $ShowFullFormInput to False. # Then, it can be changed by the settings file (in WL) # and overwritten by the command line parameter. definitions.set_ownvalue( "Settings`$ShowFullFormInput", from_python(True if full_form else False) ) definitions.set_ownvalue( "Settings`$PygmentsShowTokens", from_python(True if pygments_tokens else False) ) readline = "none" if (execute or file and not persist) else readline.lower() if readline == "prompt": shell = TerminalShellPromptToolKit( definitions, style, completion, unicode, prompt ) else: want_readline = readline == "gnu" shell = TerminalShellGNUReadline( definitions, style, want_readline, completion, unicode, prompt ) load_settings(shell) if run: with open(run, "r") as ifile: feeder = MathicsFileLineFeeder(ifile) 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, timeout=settings.TIMEOUT) except (KeyboardInterrupt): print("\nKeyboardInterrupt") definitions.set_line_no(0) if execute: for expr in execute: evaluation = Evaluation( shell.definitions, output=TerminalOutput(shell), format="text" ) shell.terminal_formatter = None result = evaluation.parse_evaluate(expr, timeout=settings.TIMEOUT) shell.print_result(result, prompt, "text", strict_wl_output) # After the next release, we can remove the hasattr test. if hasattr(evaluation, "exc_result"): if evaluation.exc_result == Symbol("Null"): exit_rc = 0 elif evaluation.exc_result == Symbol("$Aborted"): exit_rc = -1 elif evaluation.exc_result == Symbol("Overflow"): exit_rc = -2 else: exit_rc = -3 if not persist: return exit_rc if file is not None: with open(file, "r") as ifile: feeder = MathicsFileLineFeeder(ifile) 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, timeout=settings.TIMEOUT) except (KeyboardInterrupt): print("\nKeyboardInterrupt") if not persist: return exit_rc if not quiet and prompt: print(f"\nMathicscript: {__version__}, {version_string}\n") print(license_string + "\n") print(f"Quit by evaluating Quit[] or by pressing {quit_command}.\n") # If defined, full_form and style overwrite the predefined values. definitions.set_ownvalue( "Settings`$ShowFullFormInput", SymbolTrue if full_form else SymbolFalse ) definitions.set_ownvalue( "Settings`$PygmentsStyle", from_python(shell.pygments_style) ) definitions.set_ownvalue( "Settings`$PygmentsShowTokens", from_python(pygments_tokens) ) definitions.set_ownvalue("Settings`MathicsScriptVersion", from_python(__version__)) definitions.set_attribute("Settings`MathicsScriptVersion", "System`Protected") definitions.set_attribute("Settings`MathicsScriptVersion", "System`Locked") TeXForm = Symbol("System`TeXForm") definitions.set_line_no(0) while True: try: if have_readline and shell.using_readline: import readline as GNU_readline last_pos = GNU_readline.get_current_history_length() full_form = definitions.get_ownvalue( "Settings`$ShowFullFormInput" ).replace.to_python() style = definitions.get_ownvalue("Settings`$PygmentsStyle") fmt = lambda x: x if style: style = style.replace.get_string_value() if shell.terminal_formatter: fmt = lambda x: highlight( str(query), mma_lexer, shell.terminal_formatter ) evaluation = Evaluation(shell.definitions, output=TerminalOutput(shell)) query, source_code = evaluation.parse_feeder_returning_code(shell) if ( have_readline and shell.using_readline and hasattr(GNU_readline, "remove_history_item") ): current_pos = GNU_readline.get_current_history_length() for pos in range(last_pos, current_pos - 1): GNU_readline.remove_history_item(pos) wl_input = source_code.rstrip() if unicode: wl_input = replace_wl_with_plain_text(wl_input) GNU_readline.add_history(wl_input) if query is None: continue if hasattr(query, "head") and query.head == TeXForm: output_style = "//TeXForm" else: output_style = "" if full_form: print(fmt(query)) result = evaluation.evaluate( query, timeout=settings.TIMEOUT, format="unformatted" ) if result is not None: shell.print_result( result, prompt, output_style, strict_wl_output=strict_wl_output ) except ShellEscapeException as e: source_code = e.line if len(source_code) and source_code[1] == "!": try: print(open(source_code[2:], "r").read()) except: print(str(sys.exc_info()[1])) else: subprocess.run(source_code[1:], shell=True) # Should we test exit code for adding to history? GNU_readline.add_history(source_code.rstrip()) # FIXME add this... when in Mathics core updated # shell.defintions.increment_line(1) except (KeyboardInterrupt): print("\nKeyboardInterrupt") except EOFError: if prompt: print("\n\nGoodbye!\n") break except SystemExit: print("\n\nGoodbye!\n") # raise to pass the error code on, e.g. Quit[1] raise finally: # Reset the input line that would be shown in a parse error. # This is not to be confused with the number of complete # inputs that have been seen, i.e. In[] shell.reset_lineno() return exit_rc