def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line',
Integer(0)) # Reset the line number
self.establish_comm_manager() # needed for ipywidgets and Manipulate[]
self.web_engine = None
def __init__(self, **kwargs):
self.mathjax_initialized = False
Kernel.__init__(self, **kwargs)
if self.log is None:
# This occurs if we call as a stand-alone kernel
# (eg, not as a process)
# FIXME: take care of input/output, eg StringIO
# make work without a session
self.log = logging.Logger("NotebookApp")
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number
def do_complete(self, code, cursor_pos):
definitions = Definitions(add_builtin=True)
matches_raw = definitions.get_matching_names(code + '*')
matches = []
for match in matches_raw:
matches.append(match.replace('System`', ''))
return {
'matches': matches,
'cursor_start': cursor_pos - len(code),
'cursor_end': cursor_pos,
'metadata': {},
'status': 'ok',
}
def __init__(
self, definitions=None, output=None, format="text", catch_interrupt=True
) -> None:
from mathics.core.definitions import Definitions
from mathics.core.expression import Symbol
if definitions is None:
definitions = Definitions()
self.definitions = definitions
self.recursion_depth = 0
self.timeout = False
self.timeout_queue = []
self.stopped = False
self.out = []
self.output = output if output else Output()
self.listeners = {}
self.options = None
self.predetermined_out = None
self.quiet_all = False
self.format = format
self.catch_interrupt = catch_interrupt
self.SymbolNull = Symbol("Null")
# status of last evaluate
self.exc_result = self.SymbolNull
self.last_eval = None
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 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 query(request):
global definitions
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=str(request.META),
log="",
)
query_log.save()
evaluation = get_session_evaluation(request.session)
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 SystemExit as e:
results = []
result = None
definitions = Definitions(add_builtin=True,
extension_modules=default_pymathics_modules)
evaluation.definitions = definitions
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],
}
if settings.LOG_QUERIES:
query_log.timeout = evaluation.timeout
query_log.result = str(result) # evaluation.results
query_log.error = False
query_log.save()
return JsonResponse(result)
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 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 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 __init__(self,
input=None,
definitions=None,
timeout=None,
out_callback=None,
format='text',
catch_interrupt=True):
from mathics.core.definitions import Definitions
if definitions is None:
definitions = Definitions()
self.definitions = definitions
self.recursion_depth = 0
self.timeout = False
self.stopped = False
self.out = []
self.out_callback = out_callback
self.listeners = {}
self.options = None
self.quiet_all = False
self.quiet_messages = set()
self.format = format
queries = []
last_parse_error = None
if input is not None:
from mathics.core.parser import parse, TranslateError
lines = input.splitlines()
query = ''
for line in lines:
if line:
query += line
try:
expression = parse(query)
if expression is not None:
queries.append(expression)
query = ''
last_parse_error = None
except TranslateError, exc:
last_parse_error = exc
else:
query += ' '
def __init__(self, definitions=None,
output=None, format='text', catch_interrupt=True):
from mathics.core.definitions import Definitions
if definitions is None:
definitions = Definitions()
self.definitions = definitions
self.recursion_depth = 0
self.timeout = False
self.stopped = False
self.out = []
self.output = output if output else Output()
self.listeners = {}
self.options = None
self.predetermined_out = None
self.quiet_all = False
self.format = format
self.catch_interrupt = catch_interrupt
def __init__(self,
definitions=None,
out_callback=None,
format='text',
catch_interrupt=True):
from mathics.core.definitions import Definitions
if definitions is None:
definitions = Definitions()
self.definitions = definitions
self.recursion_depth = 0
self.timeout = False
self.stopped = False
self.out = []
self.out_callback = out_callback
self.listeners = {}
self.options = None
self.quiet_all = False
self.quiet_messages = set()
self.format = format
self.catch_interrupt = catch_interrupt
def set_settings_value(definitions: Definitions, setting_name: str, value):
"""Set a Mathics Settings` with name "setting_name" from definitions to value
"value".
"""
return definitions.set_ownvalue(setting_name, value)
class MathicsNotebookKernel(Kernel):
implementation = 'mathics'
implementation_version = '1.0'
banner = 'Mathics Jupyter Kernel - Implementation'
language_info = {
'version': '1.0',
'name': 'Mathematica',
'mimetype': 'text/x-mathematica',
}
name = 'MathicsNotebook'
"""
Initialize Mathics core.
"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.definitions = Definitions(add_builtin=True)
self.evaluation = Evaluation(self.definitions, format='xml')
"""
Preprocess output for better support for graphics.
"""
def preprocess_output(self, data):
data = re.sub(
r"<math><mglyph width=\"(.*)\" height=\"(.*)\" src=\"(.*)\"/></math>",
"<img width=\"\\1\" height=\"\\2\" src=\"\\3\" />", data, 0)
return data
"""
Handle jupyter connections.
"""
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=False):
if not silent:
from mathics.core.parser import MultiLineFeeder
feeder = MultiLineFeeder(code, '<notebook>')
results = []
try:
while not feeder.empty():
expr = self.evaluation.parse_feeder(feeder)
if expr is None:
results.append(Result(self.evaluation.out, None, None))
self.evaluation.out = []
continue
result = self.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 do_complete(self, code, cursor_pos):
matches_raw = self.definitions.get_matching_names(code + '*')
matches = []
for match in matches_raw:
matches.append(match.replace('System`', ''))
return {
'matches': matches,
'cursor_start': cursor_pos - len(code),
'cursor_end': cursor_pos,
'metadata': {},
'status': 'ok',
}
def get_settings_value(definitions: Definitions, setting_name: str):
"""Get a Mathics Settings` value with name "setting_name" from definitions. If setting_name is not defined return None"""
settings_value = definitions.get_ownvalue(setting_name)
if settings_value is None:
return None
return settings_value.replace.to_python(string_quotes=False)
import unittest
import random
import sys
from mathics_scanner import (
IncompleteSyntaxError,
InvalidSyntaxError,
ScanError,
SingleLineFeeder,
)
from mathics.core.definitions import Definitions
from mathics.core.parser import parse
from mathics.core.expression import Symbol, Integer, Expression, Real, Rational, String
definitions = Definitions(add_builtin=True)
class ConvertTests(unittest.TestCase):
def parse(self, code):
return parse(definitions, SingleLineFeeder(code))
def check(self, expr1, expr2):
if isinstance(expr1, str):
expr1 = self.parse(expr1)
if isinstance(expr2, str):
expr2 = self.parse(expr2)
if expr1 is None:
assert expr2 is None
else:
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', 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', nargs='?', help='execute a command')
argparser.add_argument('--colors', nargs='?', help='interactive shell colors')
argparser.add_argument('--version', '-v', action='version', version=get_version_string(False))
args = argparser.parse_args()
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-D'
definitions = Definitions(add_builtin=True)
# TODO all binary operators?
#Reset the line number to 1
definitions.set_ownvalue('$Line', Integer(1))
shell = TerminalShell(definitions, args.colors)
if args.execute:
total_input = args.execute.decode(sys.stdin.encoding) # check encoding
print shell.get_in_prompt() + total_input
evaluation = Evaluation(total_input, definitions, timeout=30, out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(unicode(result.result)) + '\n'
return
if not (args.quiet or args.script):
print_version(is_server=False)
print_license()
print u"Quit by pressing %s" % quit_command
print ''
if args.FILE is not None:
total_input = ""
for line in args.FILE:
line = line.decode('utf-8') # TODO: other encodings
if args.script and line.startswith('#!'):
continue
if total_input == "":
print shell.get_in_prompt() + line,
else:
print ' ', line,
total_input += line
if line == "":
pass
elif wait_for_line(total_input):
continue
evaluation = Evaluation(total_input, definitions, timeout=30, out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(unicode(result.result)) + '\n'
total_input = ""
if not args.persist:
return
while True:
try:
total_input = ""
line_input = raw_input(shell.get_in_prompt())
line_input = line_input.decode(sys.stdin.encoding)
while line_input != "":
total_input += ' ' + line_input
if not wait_for_line(total_input):
break
line_input = raw_input(' ')
line_input = line_input.decode(sys.stdin.encoding)
evaluation = Evaluation(total_input, definitions, timeout=30, out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(unicode(result.result)) + '\n'
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
class JsonResponse(HttpResponse):
def __init__(self, result={}):
json = simplejson.dumps(result)
super(JsonResponse, self).__init__(json, mimetype=JSON_MIMETYPE)
def require_ajax_login(func):
def new_func(request, *args, **kwargs):
if not request.user.is_authenticated():
return JsonResponse({'requireLogin': True})
return func(request, *args, **kwargs)
return new_func
definitions = Definitions(add_builtin=True)
def require_ajax_login(f):
return f
def main_view(request):
mimetype = get_mimetype(request)
return render_to_response('main.html', {
'login_form': LoginForm(),
'save_form': SaveForm(),
'require_login': settings.REQUIRE_LOGIN,
},
context_instance=RequestContext(request),
mimetype=mimetype)
def get_mimetype(request):
return 'text/html' if 'MSIE' in request.META.get('HTTP_USER_AGENT', '') else 'application/xhtml+xml'
class JsonResponse(HttpResponse):
def __init__(self, result={}):
json = simplejson.dumps(result)
super(JsonResponse, self).__init__(json, mimetype=JSON_MIMETYPE)
def require_ajax_login(func):
def new_func(request, *args, **kwargs):
if not request.user.is_authenticated():
return JsonResponse({'requireLogin': True})
return func(request, *args, **kwargs)
return new_func
definitions = Definitions(add_builtin=True)
def require_ajax_login(f):
return f
def main_view(request):
mimetype = get_mimetype(request)
return render_to_response('main.html', {
'login_form': LoginForm(),
'save_form': SaveForm(),
'require_login': settings.REQUIRE_LOGIN,
}, context_instance=RequestContext(request), mimetype=mimetype)
def test_view(request):
return render_to_response('test.html', {
}, context_instance=RequestContext(request))
def setUp(self):
definitions = Definitions(add_builtin=True)
self.evaluation = Evaluation(definitions, format="xml")
def main():
from mathics.doc import documentation as main_mathics_documentation
global definitions
global documentation
global logfile
global check_partial_enlapsed_time
definitions = Definitions(add_builtin=True)
documentation = main_mathics_documentation
parser = ArgumentParser(description="Mathics test suite.", add_help=False)
parser.add_argument("--help",
"-h",
help="show this help message and exit",
action="help")
parser.add_argument("--version",
"-v",
action="version",
version="%(prog)s " + mathics.__version__)
parser.add_argument(
"--chapters",
"-c",
dest="chapters",
metavar="CHAPTER",
help="only test CHAPTER(s). "
"You can list multiple chapters by adding a comma (and no space) in between chapter names.",
)
parser.add_argument(
"--sections",
"-s",
dest="sections",
metavar="SECTION",
help="only test SECTION(s). "
"You can list multiple sections by adding a comma (and no space) in between section names.",
)
parser.add_argument(
"--exclude",
"-X",
default="",
dest="exclude",
metavar="SECTION",
help="excude SECTION(s). "
"You can list multiple sections by adding a comma (and no space) in between section names.",
)
parser.add_argument(
"--logfile",
"-f",
dest="logfilename",
metavar="LOGFILENAME",
help="stores the output in [logfilename]. ",
)
parser.add_argument(
"--pymathics",
"-l",
dest="pymathics",
action="store_true",
help="also checks pymathics modules.",
)
parser.add_argument(
"--time-each",
"-d",
dest="enlapsed_times",
action="store_true",
help=
"check the time that take each test to parse, evaluate and compare.",
)
parser.add_argument(
"--output",
"-o",
dest="output",
action="store_true",
help="generate LaTeX pickled internal data",
)
parser.add_argument(
"--doc-only",
dest="doc_only",
action="store_true",
help=
"generate LaTeX pickled internal data without running tests; Can't be used with --section or --reload.",
)
parser.add_argument(
"--latex-only",
dest="latex_only",
action="store_true",
help=
"generate LaTeX output from internal data without running tests; assumes --reload",
)
parser.add_argument(
"--reload",
"-r",
dest="reload",
action="store_true",
help="reload LaTeX pickled internal data, before possibly adding to it",
)
parser.add_argument(
"--tex",
"-t",
dest="tex",
action="store_true",
help="include LaTeX document generation file at the end of other steps",
)
parser.add_argument("--quiet",
"-q",
dest="quiet",
action="store_true",
help="hide passed tests")
parser.add_argument(
"--keep-going",
"-k",
dest="keep_going",
action="store_true",
help="create documentation even if there is a test failure",
)
parser.add_argument("--stop-on-failure",
"-x",
action="store_true",
help="stop on failure")
parser.add_argument(
"--skip",
metavar="N",
dest="skip",
type=int,
default=0,
help="skip the first N tests",
)
parser.add_argument(
"--count",
metavar="N",
dest="count",
type=int,
default=MAX_TESTS,
help="run only N tests",
)
args = parser.parse_args()
if args.enlapsed_times:
check_partial_enlapsed_time = True
# If a test for a specific section is called
# just test it
if args.logfilename:
logfile = open(args.logfilename, "wt")
if args.sections:
sections = set(args.sections.split(","))
if args.pymathics: # in case the section is in a pymathics module...
documentation.load_pymathics_doc()
test_sections(sections,
stop_on_failure=args.stop_on_failure,
reload=args.reload)
elif args.chapters:
chapters = set(args.chapters.split(","))
if args.pymathics: # in case the section is in a pymathics module...
documentation.load_pymathics_doc()
test_chapters(chapters,
stop_on_failure=args.stop_on_failure,
reload=args.reload)
else:
# if we want to check also the pymathics modules
if args.pymathics:
print("Building pymathics documentation object")
documentation.load_pymathics_doc()
elif args.latex_only:
write_latex()
elif args.doc_only:
extract_doc_from_source(
quiet=args.quiet,
reload=args.reload,
)
else:
excludes = set(args.exclude.split(","))
start_at = args.skip + 1
start_time = datetime.now()
test_all(
quiet=args.quiet,
generate_output=args.output,
stop_on_failure=args.stop_on_failure,
start_at=start_at,
count=args.count,
doc_even_if_error=args.keep_going,
excludes=excludes,
)
end_time = datetime.now()
print("Tests took ", end_time - start_time)
# If TeX output requested, try to build it:
if args.tex:
write_latex()
if logfile:
logfile.close()
def setUpModule():
global definitions
definitions = Definitions(add_builtin=True)
response = json.dumps(result)
super(JsonResponse, self).__init__(response,
content_type=JSON_CONTENT_TYPE)
def require_ajax_login(func):
def new_func(request, *args, **kwargs):
if not request.user.is_authenticated():
return JsonResponse({'requireLogin': True})
return func(request, *args, **kwargs)
return new_func
from mathics.settings import default_pymathics_modules
definitions = Definitions(add_builtin=True,
extension_modules=default_pymathics_modules)
def require_ajax_login(f):
return f
def main_view(request):
context = {
'login_form': LoginForm(),
'save_form': SaveForm(),
'require_login': settings.REQUIRE_LOGIN,
}
return render(request, 'main.html', context)
class MathicsKernel(Kernel):
implementation = 'Mathics'
implementation_version = '0.1'
language_info = {
'version': __version__,
'name': 'Mathematica',
'mimetype': 'text/x-mathematica',
}
banner = "Mathics kernel" # TODO
shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
shell_class = Type(ZMQInteractiveShell)
user_module = Any()
user_ns = Instance(dict, args=None, allow_none=True)
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number
self.establish_comm_manager() # needed for ipywidgets and Manipulate[]
self.web_engine = None
def establish_comm_manager(self):
# see ipykernel/ipkernel.py
self.shell = self.shell_class.instance(
parent=self,
profile_dir=self.profile_dir,
user_module=self.user_module,
user_ns=self.user_ns,
kernel=self)
self.shell.displayhook.session = self.session
self.shell.displayhook.pub_socket = self.iopub_socket
self.shell.displayhook.topic = self._topic('execute_result')
self.shell.display_pub.session = self.session
self.shell.display_pub.pub_socket = self.iopub_socket
self.comm_manager = CommManager(parent=self, kernel=self)
comm_msg_types = ['comm_open', 'comm_msg', 'comm_close']
for msg_type in comm_msg_types:
self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)
def init_web_engine(self):
if self.web_engine is None:
self.web_engine = WebEngine()
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 out_callback(self, out):
if out.is_message:
content = {
'name': 'stderr',
'text': '{symbol}::{tag}: {text}\n'.format(**out.get_data()),
}
elif out.is_print:
content = {
'name': 'stdout',
'text': out.text + '\n',
}
else:
raise ValueError('Unknown out')
self.send_response(self.iopub_socket, 'stream', content)
def reconfigure_mathjax(self):
# Jupyter's default MathJax configuration ("safe" mode) blocks the use
# of data uris which we use in mglyphs for displaying svgs and imgs.
# enable the "data" protocol here. also remove font size restrictions.
# we set processSectionDelay to 0 since that drastically improves the
# visual experience of Manipulate as there's a lot less jitter, also see
# http://docs.mathjax.org/en/latest/api/hub.html
safeModeJS = """
MathJax.Hub.Config({
showMathMenu: false,
showProcessingMessages: false,
messageStyle: "normal",
displayAlign: "left",
Safe: {
safeProtocols: {
data: true
},
allow: {
fontsize: "all"
}
},
"HTML-CSS": {
availableFonts: [], /* force Web font */
preferredFont: null, /* force Web font */
webFont: "Asana-Math",
linebreaks: {
automatic: true,
width: "70%"
}
}
});
MathJax.Hub.processSectionDelay = 0;
"""
# see http://jupyter-client.readthedocs.org/en/latest/messaging.html
content = {
'data': {'application/javascript': safeModeJS},
'metadata': {},
}
self.send_response(self.iopub_socket, 'display_data', content)
def result_callback(self, result):
self.reconfigure_mathjax()
content = {
'execution_count': result.line_no,
'data': result.result,
'metadata': {},
}
self.send_response(self.iopub_socket, 'execute_result', content)
def clear_output_callback(self, wait=False):
# see http://jupyter-client.readthedocs.org/en/latest/messaging.html
content = dict(wait=wait)
self.send_response(self.iopub_socket, 'clear_output', content)
def display_data_callback(self, data, metadata):
self.reconfigure_mathjax()
# see http://jupyter-client.readthedocs.org/en/latest/messaging.html
content = {
'data': data,
'metadata': metadata,
}
self.send_response(self.iopub_socket, 'display_data', content)
def do_inspect(self, code, cursor_pos, detail_level=0):
start_pos, end_pos, name = self.find_symbol_name(code, cursor_pos)
if name is None:
return {'status': 'error'}
if '`' not in name:
name = 'System`' + name
try:
instance = builtins[name]
except KeyError:
return {'status': 'ok', 'found': False, 'data': {}, 'metadata': {}}
doc = Doc(instance.__doc__ or '')
data = {
'text/plain': str(doc),
# TODO latex
# TODO html
}
return {'status': 'ok', 'found': True, 'data': data, 'metadata': {}}
def do_complete(self, code, cursor_pos):
start_pos, end_pos, name = self.find_symbol_name(code, cursor_pos)
if name is None:
return {'status': 'error'}
remove_system = False
system_prefix = 'System`'
if '`' not in name:
name = system_prefix + name
remove_system = True
matches = []
for key in builtins:
if key.startswith(name):
matches.append(key)
if remove_system:
matches = [match[len(system_prefix):] for match in matches]
return {
'status': 'ok',
'matches': matches,
'cursor_start': start_pos,
'cursor_end': end_pos,
'metadata': {},
}
def do_is_complete(self, code):
try:
# list forces generator evaluation (parse all lines)
list(parse_lines(code, self.definitions))
except IncompleteSyntaxError:
return {'status': 'incomplete', 'indent': ''}
except TranslateError:
return {'status': 'invalid'}
else:
return {'status': 'complete'}
@staticmethod
def find_symbol_name(code, cursor_pos):
'''
Given a string of code tokenize it until cursor_pos and return the final symbol name.
returns None if no symbol is found at cursor_pos.
>>> MathicsKernel.find_symbol_name('1 + Sin', 6)
'System`Sin'
>>> MathicsKernel.find_symbol_name('1 + ` Sin[Cos[2]] + x', 8)
'System`Sin'
>>> MathicsKernel.find_symbol_name('Sin `', 4)
'''
tokeniser = Tokeniser(SingleLineFeeder(code))
start_pos = None
end_pos = None
name = None
while True:
try:
token = tokeniser.next()
except ScanError:
continue
if token.tag == 'END':
break # ran out of tokens
# find first token which contains cursor_pos
if tokeniser.pos >= cursor_pos:
if token.tag == 'Symbol':
name = token.text
start_pos = token.pos
end_pos = tokeniser.pos
break
return start_pos, end_pos, name
class MathicsKernel(Kernel):
import re
svg_open_tag = re.compile('<mtable><mtr><mtd><svg')
svg_close_tag = re.compile('</svg></mtd></mtr></mtable>')
implementation = 'Mathics'
implementation_version = __version__
language_version = '0.1' # TODO
language_info = {
'name': 'Mathematica',
'mimetype': 'text/x-mathematica',
}
banner = "Mathics kernel" # TODO
def __init__(self, **kwargs):
self.mathjax_initialized = False
Kernel.__init__(self, **kwargs)
if self.log is None:
# This occurs if we call as a stand-alone kernel
# (eg, not as a process)
# FIXME: take care of input/output, eg StringIO
# make work without a session
self.log = logging.Logger("NotebookApp")
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number
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 out_callback(self, out):
if out.is_message:
content = {
'name': 'stderr',
'text': '{symbol}::{tag}: {text}\n'.format(**out.get_data()),
}
elif out.is_print:
content = {
'name': 'stdout',
'text': out.text + '\n',
}
else:
raise ValueError('Unknown out')
self.send_response(self.iopub_socket, 'stream', content)
def do_inspect(self, code, cursor_pos, detail_level=0):
# name = code[:cursor_pos]
name = code
if '`' not in name:
name = 'System`' + name
try:
instance = builtins[name]
except KeyError:
return {'status': 'ok', 'found': False, 'data': {}, 'metadata': {}}
doc = Doc(instance.__doc__ or '') # TODO Handle possible ValueError here
data = {'text/plain': doc.text(detail_level), 'text/html': doc.html()} # TODO 'application/x-tex': doc.latex()
return {'status': 'ok', 'found': True, 'data': data, 'metadata': {}}
@staticmethod
def do_is_complete(code):
code = code.rstrip()
trailing_ops = ['+', '-', '/', '*', '^', '=', '>', '<', '/;', '/:',
'/.', '&&', '||']
if any(code.endswith(op) for op in trailing_ops):
return {'status': 'incomplete', 'indent': ''}
brackets = [('(', ')'), ('[', ']'), ('{', '}')]
kStart, kEnd, stack = 0, 1, []
in_string = False
for char in code:
if char == '"':
in_string = not in_string
if not in_string:
for bracketPair in brackets:
if char == bracketPair[kStart]:
stack.append(char)
elif char == bracketPair[kEnd]:
if len(stack) == 0:
return {'status': 'invalid'}
if stack.pop() != bracketPair[kStart]:
return {'status': 'invalid'}
if in_string:
return {'status': 'incomplete', 'indent': ''}
elif len(stack) != 0:
return {'status': 'incomplete', 'indent': 4 * len(stack) * ' '}
else:
return {'status': 'complete'}
#Borrowed from metakernel package
def repr(self, item):
return repr(item)
#Borrowed from metakernel package
def Display(self, *args, **kwargs):
clear_output = kwargs.get("clear_output", False)
for message in args:
if isinstance(message, HTML):
if clear_output:
self.send_response(self.iopub_socket, 'clear_output',
{'wait': True})
# if Widget and isinstance(message, Widget):
# self.log.debug('Display Widget')
# self._ipy_formatter(message)
else:
self.log.debug('Display Data')
try:
data = _formatter(message, self.repr)
except Exception as e:
self.Error(e)
return
self.send_response(self.iopub_socket, 'display_data',
{'data': data,
'metadata': dict()})
def main():
from mathics.doc import documentation as main_mathics_documentation
global definitions
global documentation
definitions = Definitions(add_builtin=True)
documentation = main_mathics_documentation
parser = ArgumentParser(description="Mathics test suite.", add_help=False)
parser.add_argument("--help",
"-h",
help="show this help message and exit",
action="help")
parser.add_argument("--version",
"-v",
action="version",
version="%(prog)s " + mathics.__version__)
parser.add_argument(
"--sections",
"-s",
dest="section",
metavar="SECTION",
help="only test SECTION(s). "
"You can list multiple sections by adding a comma (and no space) in between section names."
)
parser.add_argument(
"--pymathics",
"-l",
dest="pymathics",
action="store_true",
help="also checks pymathics modules.",
)
parser.add_argument(
"--output",
"-o",
dest="output",
action="store_true",
help="generate TeX and XML output data",
)
parser.add_argument(
"--doc-only",
dest="doc_only",
action="store_true",
help="generate TeX and XML output data without running tests",
)
parser.add_argument(
"--tex",
"-t",
dest="tex",
action="store_true",
help="generate TeX documentation file",
)
parser.add_argument("--quiet",
"-q",
dest="quiet",
action="store_true",
help="hide passed tests")
parser.add_argument(
"--keep-going",
"-k",
dest="keep_going",
action="store_true",
help="create documentation even if there is a test failure",
)
parser.add_argument("--stop-on-failure",
action="store_true",
help="stop on failure")
parser.add_argument(
"--skip",
metavar="N",
dest="skip",
type=int,
default=0,
help="skip the first N tests",
)
parser.add_argument(
"--count",
metavar="N",
dest="count",
type=int,
default=MAX_TESTS,
help="run only N tests",
)
args = parser.parse_args()
# If a test for a specific section is called
# just test it
if args.section:
sections = set(args.section.split(","))
if args.pymathics: # in case the section is in a pymathics module...
documentation.load_pymathics_doc()
test_section(sections, stop_on_failure=args.stop_on_failure)
else:
# if we want to check also the pymathics modules
if args.pymathics:
print("Building pymathics documentation object")
documentation.load_pymathics_doc()
elif args.doc_only:
make_doc(quiet=args.quiet, )
else:
start_at = args.skip + 1
start_time = datetime.now()
test_all(
quiet=args.quiet,
generate_output=args.output,
stop_on_failure=args.stop_on_failure,
start_at=start_at,
count=args.count,
doc_even_if_error=args.keep_going,
)
end_time = datetime.now()
print("Tests took ", end_time - start_time)
# If TeX output requested, try to build it:
if args.tex:
write_latex()
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',
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',
nargs='?',
help='execute a command')
argparser.add_argument('--colors',
nargs='?',
help='interactive shell colors')
argparser.add_argument('--version',
'-v',
action='version',
version=get_version_string(False))
args = argparser.parse_args()
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-D'
definitions = Definitions(add_builtin=True)
# TODO all binary operators?
#Reset the line number to 1
definitions.set_ownvalue('$Line', Integer(1))
shell = TerminalShell(definitions, args.colors)
if args.execute:
print get_in_prompt() + args.execute
evaluation = Evaluation(args.execute,
definitions,
timeout=30,
out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(unicode(
result.result)) + '\n'
return
if not (args.quiet or args.script):
print_version(is_server=False)
print_license()
print u"Quit by pressing %s" % quit_command
print ''
if args.FILE is not None:
total_input = ""
for line in args.FILE:
if args.script and line.startswith('#!'):
continue
if total_input == "":
print shell.get_in_prompt() + line,
else:
print ' ', line,
total_input += line
if line == "":
pass
elif wait_for_line(total_input):
continue
evaluation = Evaluation(total_input,
definitions,
timeout=30,
out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(
unicode(result.result)) + '\n'
total_input = ""
if not args.persist:
return
while True:
try:
total_input = ""
line_input = raw_input(shell.get_in_prompt())
while line_input != "":
total_input += ' ' + line_input
if not wait_for_line(total_input):
break
line_input = raw_input(' ')
evaluation = Evaluation(total_input,
definitions,
timeout=30,
out_callback=out_callback)
for result in evaluation.results:
if result.result is not None:
print shell.get_out_prompt() + to_output(
unicode(result.result)) + '\n'
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
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
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',
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',
nargs='?',
help='execute a command')
argparser.add_argument('--colors',
nargs='?',
help='interactive shell colors')
argparser.add_argument('--version',
'-v',
action='version',
version=get_version_string(False))
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(1)) #Reset the line number to 1
shell = TerminalShell(definitions, args.colors)
if not (args.quiet or args.script):
print_version(is_server=False)
print_license()
print u"Quit by pressing {0}\n".format(quit_command)
if args.execute:
total_input = args.execute.decode(sys.stdin.encoding) # check encoding
print shell.get_in_prompt() + total_input
shell.evaluate(total_input)
return
if args.FILE is not None:
total_input = ''
for line_no, line in enumerate(args.FILE):
try:
line = line.decode('utf-8') # TODO: other encodings
if args.script and line_no == 0 and line.startswith('#!'):
continue
print shell.get_in_prompt(
continued=(total_input != '')) + line,
total_input += ' ' + line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
if not args.persist:
return
total_input = ""
while True:
try:
line = raw_input(shell.get_in_prompt(continued=total_input != ''))
line = line.decode(sys.stdin.encoding)
total_input += line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
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:
# expr = expr.decode(shell.input_encoding)
print(shell.get_in_prompt() + expr)
shell.evaluate(expr)
if not args.persist:
return
if args.FILE is not None:
total_input = ''
for line_no, line in enumerate(args.FILE):
try:
# line = line.decode('utf-8') # TODO: other encodings
if args.script and line_no == 0 and line.startswith('#!'):
continue
print(shell.get_in_prompt(continued=total_input != '') + line.rstrip('\n'))
total_input += ' ' + line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print('\nKeyboardInterrupt')
except (SystemExit, EOFError):
print("\n\nGood bye!\n")
break
if not args.persist:
return
total_input = ""
while True:
try:
line = shell.read_line(
shell.get_in_prompt(continued=total_input != ''))
total_input += line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print('\nKeyboardInterrupt')
except (SystemExit, EOFError):
print("\n\nGood bye!\n")
break
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() -> 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():
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',
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', nargs='?', help='execute a command')
argparser.add_argument(
'--colors', nargs='?', help='interactive shell colors')
argparser.add_argument(
'--version', '-v', action='version', version=get_version_string(False))
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)
if not (args.quiet or args.script):
print_version(is_server=False)
print_license()
print u"Quit by pressing {0}\n".format(quit_command)
if args.execute:
total_input = args.execute.decode(shell.input_encoding)
print shell.get_in_prompt() + total_input
shell.evaluate(total_input)
return
if args.FILE is not None:
total_input = ''
for line_no, line in enumerate(args.FILE):
try:
line = line.decode('utf-8') # TODO: other encodings
if args.script and line_no == 0 and line.startswith('#!'):
continue
print shell.get_in_prompt(continued=total_input != '') + line,
total_input += ' ' + line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
if not args.persist:
return
total_input = ""
while True:
try:
line = shell.read_line(
shell.get_in_prompt(continued=total_input != ''))
line = line.decode(shell.input_encoding)
total_input += line
if line != "" and wait_for_line(total_input):
continue
shell.evaluate(total_input)
total_input = ""
except (KeyboardInterrupt):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.definitions = Definitions(add_builtin=True)
self.evaluation = Evaluation(self.definitions, format='xml')
class MathicsKernel(Kernel):
implementation = 'Mathics'
implementation_version = '0.1'
language_info = {
'version': __version__,
'name': 'Mathematica',
'mimetype': 'text/x-mathematica',
}
banner = "Mathics kernel" # TODO
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number
self.establish_comm_manager() # needed for ipywidgets and Manipulate[]
def establish_comm_manager(self):
self.comm_manager = CommManager(parent=self, kernel=self)
comm_msg_types = ['comm_open', 'comm_msg', 'comm_close']
for msg_type in comm_msg_types:
self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)
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 out_callback(self, out):
if out.is_message:
content = {
'name': 'stderr',
'text': '{symbol}::{tag}: {text}\n'.format(**out.get_data()),
}
elif out.is_print:
content = {
'name': 'stdout',
'text': out.text + '\n',
}
else:
raise ValueError('Unknown out')
self.send_response(self.iopub_socket, 'stream', content)
def result_callback(self, result):
content = {
'execution_count': result.line_no,
'data': result.data,
'metadata': result.metadata,
}
self.send_response(self.iopub_socket, 'execute_result', content)
def clear_output_callback(self, wait=False):
# see http://jupyter-client.readthedocs.org/en/latest/messaging.html
content = dict(wait=wait)
self.send_response(self.iopub_socket, 'clear_output', content)
def display_data_callback(self, result):
# see http://jupyter-client.readthedocs.org/en/latest/messaging.html
content = {
'data': result.data,
'metadata': result.metadata,
}
self.send_response(self.iopub_socket, 'display_data', content)
def do_inspect(self, code, cursor_pos, detail_level=0):
start_pos, end_pos, name = self.find_symbol_name(code, cursor_pos)
if name is None:
return {'status': 'error'}
if '`' not in name:
name = 'System`' + name
try:
instance = builtins[name]
except KeyError:
return {'status': 'ok', 'found': False, 'data': {}, 'metadata': {}}
doc = Doc(instance.__doc__ or '')
data = {
'text/plain': str(doc),
# TODO latex
# TODO html
}
return {'status': 'ok', 'found': True, 'data': data, 'metadata': {}}
def do_complete(self, code, cursor_pos):
start_pos, end_pos, name = self.find_symbol_name(code, cursor_pos)
if name is None:
return {'status': 'error'}
remove_system = False
system_prefix = 'System`'
if '`' not in name:
name = system_prefix + name
remove_system = True
matches = []
for key in builtins:
if key.startswith(name):
matches.append(key)
if remove_system:
matches = [match[len(system_prefix):] for match in matches]
return {
'status': 'ok',
'matches': matches,
'cursor_start': start_pos,
'cursor_end': end_pos,
'metadata': {},
}
def do_is_complete(self, code):
try:
# list forces generator evaluation (parse all lines)
list(parse_lines(code, self.definitions))
except IncompleteSyntaxError:
return {'status': 'incomplete', 'indent': ''}
except TranslateError:
return {'status': 'invalid'}
else:
return {'status': 'complete'}
@staticmethod
def find_symbol_name(code, cursor_pos):
'''
Given a string of code tokenize it until cursor_pos and return the final symbol name.
returns None if no symbol is found at cursor_pos.
>>> MathicsKernel.find_symbol_name('1 + Sin', 6)
'System`Sin'
>>> MathicsKernel.find_symbol_name('1 + ` Sin[Cos[2]] + x', 8)
'System`Sin'
>>> MathicsKernel.find_symbol_name('Sin `', 4)
'''
scanner = MathicsScanner()
scanner.build()
scanner.lexer.input(code)
start_pos = None
end_pos = None
name = None
while True:
try:
token = scanner.lexer.token()
except ScanError:
scanner.lexer.skip(1)
continue
if token is None:
break # ran out of tokens
# find first token which contains cursor_pos
if scanner.lexer.lexpos >= cursor_pos:
if token.type == 'symbol':
name = token.value
start_pos = token.lexpos
end_pos = scanner.lexer.lexpos
break
return start_pos, end_pos, name
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',
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('--version',
'-v',
action='version',
version=get_version_string(False))
args = argparser.parse_args()
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-D'
if not (args.quiet or args.script):
print_version(is_server=False)
print_license()
print u"Quit by pressing %s" % quit_command
print ''
definitions = Definitions(add_builtin=True)
trailing_ops = ['+', '-', '/', '*'] # TODO all binary operators?
if args.FILE is not None:
total_input = ""
for line in args.FILE:
if args.script and line.startswith('#!'):
continue
if total_input == "":
print '>> ', line,
else:
print ' ', line,
total_input += line
if line == "":
pass
elif any(line.rstrip().endswith(op) for op in
trailing_ops) or not brackets_balanced(total_input):
continue
evaluation = Evaluation(total_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))
total_input = ""
if not args.persist:
return
while True:
try:
total_input = ""
line_input = raw_input('>> ')
while line_input != "":
total_input += ' ' + line_input
if any(
[line_input.rstrip().endswith(op) for op in trailing_ops]):
pass
elif brackets_balanced(total_input):
break
line_input = raw_input(' ')
evaluation = Evaluation(total_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):
print '\nKeyboardInterrupt'
except (SystemExit, EOFError):
print "\n\nGood bye!\n"
break
def __init__(self, **kwargs):
Kernel.__init__(self, **kwargs)
self.definitions = Definitions(add_builtin=True) # TODO Cache
self.definitions.set_ownvalue('$Line', Integer(0)) # Reset the line number
self.establish_comm_manager() # needed for ipywidgets and Manipulate[]