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