def lambda_handler(event, context):
code = event['code']
setup(line_numbers = "TRUE")
code = parse(code)
print("compiled")
print(code)
return code
def magic(line, cell=None):
"""Coconut IPython magic."""
try:
if cell is None:
code = line
else:
cmd(line) # first line in block is cmd
code = cell
compiled = parse(code)
except CoconutException:
logger.print_exc()
else:
ipython.run_cell(compiled, shell_futures=False)
def magic(line, cell=None):
"""Provides %coconut and %%coconut magics."""
try:
if cell is None:
code = line
else:
# first line in block is cmd, rest is code
line = line.strip()
if line:
cmd(line)
code = cell
compiled = parse(code)
except CoconutException:
logger.display_exc()
else:
ipython.run_cell(compiled, shell_futures=False)
def magic(line, cell=None):
"""Provides %coconut and %%coconut magics."""
try:
if cell is None:
code = line
else:
# first line in block is cmd, rest is code
line = line.strip()
if line:
cmd(line, interact=False)
code = cell
compiled = parse(code)
except CoconutException:
logger.display_exc()
else:
ipython.run_cell(compiled, shell_futures=False)
def generate(self, code, lang='py', mode='main'):
self.mod_name = mode
if mode not in ['main', 'block']:
self.namespace = mode
self.variables |= {mode: {'type': types.types['module'](mode)}}
if lang == 'py':
tree = ast.parse(code).body
elif lang == 'hy':
if not is_hy_supported:
raise Exception(
"requires hy library\n"
"\trun 'python -m pip install kithon[add-langs]' to fix")
tree = hy_parse(code)[1:]
elif lang == 'coco':
if not is_coconut_supported:
raise Exception(
"requires coconut library\n"
"\trun 'python -m pip install kithon[add-langs]' to fix")
setup(target='sys')
tree = ast.parse(parse(code, 'block')).body
for block in map(self.visit, tree):
if not block:
continue
self.strings.extend(block.render().split('\n'))
if mode != 'block':
code = self.templates['main']['tmp'].render(_body=self.strings,
body='\n'.join(
self.strings),
env=self)
if mode == 'main':
self.variables = {
'__main__': {
'type': types.types['module']('__main__')
}
}
self.temp_var_counts = defaultdict(int)
else:
code = '\n'.join(self.strings)
self.nl = 0
self.namespace = '__main__'
self.strings = []
self.used = set([])
return code
def coconut():
"""
Handles Coconut code submitted by users.
"""
coconut_code = request.form['code']
# Get optional compile arguments
# Examples: http://coconut.readthedocs.io/en/master/DOCS.html#usage
compile_args = json.loads(request.form.get('args', '{}'))
# If target not specified by user, choose the specific target corresponding to
# the current version
if not compile_args.get('target'):
compile_args['target'] = 'sys'
# Initialize parameters
output_text = ''
python_code = ''
compile_error = False
running_error = False
coconut_error = None
python_error = None
# Compile the user's code with Coconut compiler
try:
# Necessary for _coconut_sys definition in exec environment
d = {'sys': globals()['sys']}
exec(parse(), d)
setup(**compile_args)
compiled_code = parse(coconut_code, 'block')
except CoconutException as error:
compile_error = True
output_text = '{}: {}'.format(error.__class__.__name__, error)
print("Error in compiling Coconut code")
if not compile_error:
print("Finish compilation")
python_code = compiled_code
# Run the compiled code.
with stdoutIO() as s:
try:
exec(compiled_code, d)
except Exception:
running_error = True
output_text = traceback.format_exc()
if running_error:
print("Error in running Coconut code")
print("Finish running")
if not running_error:
# Store output from the run
output_text = s.getvalue()
else:
python_error = extract_trace_py(output_text)
line_num, python_lines = python_error['line'], python_code.split('\n')
if 0 < line_num < len(python_lines):
python_error['call'] = python_lines[line_num-1].strip()
output_text = python_error['error']
else:
coconut_error = extract_trace_coco(output_text)
output_text = coconut_error['error']
# Print output
print("Output is\n{:}".format(output_text))
# Return JSON output
return jsonify({'output': output_text,
'python': python_code,
'pythonError': python_error,
'coconutError': coconut_error})
def tefie():
if Panda0Box.F1.Racinp2.Value == True:
exec(parse(Panda0Box.F1.Tein1.Value), globals())
print("Coconut Executed:" + "\n" + Panda0Box.F1.Tein1.Value)
if Panda0Box.F1.Racinp1.Value == True:
exec((Panda0Box.F1.Tein1.Value), globals())
def coconut():
"""
Handles Coconut code submitted by users.
"""
coconut_code = request.form['code']
# Initialize parameters
output_text = ''
python_code = ''
compile_error = False
running_error = False
coconut_error = None
python_error = None
# Compile the user's code with Coconut compiler
try:
setup(target='sys')
compiled_code = parse(coconut_code, 'exec')
except CoconutException as error:
compile_error = True
output_text = '{}: {}'.format(error.__class__.__name__, error)
print("Error in compiling Coconut code")
if not compile_error:
print("Finish compilation")
SEPARATOR = "# Compiled Coconut: -----------------------------------------------------------\n\n"
header, python_code = compiled_code.split(SEPARATOR, maxsplit=1)
header_len = header.count('\n') + SEPARATOR.count('\n')
# Run the compiled code.
with stdoutIO() as s:
try:
# Necessary for _coconut_sys definition in exec environment
d = {'sys': globals()['sys']}
exec(compiled_code, d)
except Exception:
running_error = True
output_text = traceback.format_exc()
if running_error:
print("Error in running Coconut code")
print("Finish running")
if not running_error:
# Store output from the run
output_text = s.getvalue()
else:
python_error = extract_trace_py(output_text, header_len)
line_num, python_lines = python_error['line'], python_code.split(
'\n')
if 0 < line_num < len(python_lines):
python_error['call'] = python_lines[line_num - 1].strip()
output_text = python_error['error']
else:
coconut_error = extract_trace_coco(output_text)
output_text = coconut_error['error']
# Print output
print("Output is\n{:}".format(output_text))
# Return JSON output
return jsonify({
'output': output_text,
'python': python_code,
'pythonError': python_error,
'coconutError': coconut_error
})
import unittest
from coconut import convenience
exec(convenience.parse(""))
class Test_convenience(unittest.TestCase):
def test_convenience_version(self):
version = convenience.version()
self.assertIsInstance(version,str)
if __name__ == '__main__':
unittest.main()
def test_extras():
if IPY:
import coconut.highlighter # type: ignore
assert consume(range(10), keep_last=1)[0] == 9 == coc_consume(range(10), keep_last=1)[0]
assert version() == version("num")
assert version("name")
assert version("spec")
assert version("tag")
assert version("-v")
assert_raises(lambda _=None: version("other"), CoconutException)
def _coconut_lambda_0(_=None):
raise CoconutException("derp").syntax_err()
assert_raises(_coconut_lambda_0, SyntaxError)
assert coconut_eval("x -> x + 1")(2) == 3
assert coconut_eval("addpattern")
assert parse("abc") == parse("abc", "sys")
assert parse("abc", "file")
assert parse("abc", "package")
assert parse("abc", "block") == "abc\n" == parse("abc", "single")
assert parse("abc", "eval") == "abc" == parse(" abc", "eval")
assert parse("abc", "any") == "abc"
assert parse("x |> map$(f)", "any") == "map(f, x)"
assert "_coconut" not in parse("a |> .b |> .m() |> f$(x) |> .[0]", "block")
assert parse("abc # derp", "any") == "abc # derp"
assert_raises(lambda _=None: parse(" abc", "file"), CoconutException)
assert_raises(lambda _=None: parse("'"), CoconutException)
assert_raises(lambda _=None: parse("("), CoconutException)
assert_raises(lambda _=None: parse("\\("), CoconutException)
assert_raises(lambda _=None: parse("if a:\n b\n c"), CoconutException)
assert_raises(lambda _=None: parse("$"), CoconutException)
assert_raises(lambda _=None: parse("_coconut"), CoconutException)
assert parse("def f(x):\n \t pass")
assert parse("lambda x: x")
assert parse("u''")
assert parse("def f(x):\\\n pass")
assert parse("abc ")
assert parse("abc # derp", "any") == "abc # derp"
setup(line_numbers=True)
assert parse("abc", "any") == "abc # line 1"
setup(keep_lines=True)
assert parse("abc", "any") == "abc # abc"
setup(line_numbers=True, keep_lines=True)
assert parse("abc", "any") == "abc # line 1: abc"
setup()
assert "prepattern" in parse("\n", mode="file")
assert "datamaker" in parse("\n", mode="file")
setup(strict=True)
assert "prepattern" not in parse("\n", mode="file")
assert "datamaker" not in parse("\n", mode="file")
assert_raises(lambda _=None: parse("def f(x):\n \t pass"), CoconutStyleError)
assert_raises(lambda _=None: parse("lambda x: x"), CoconutStyleError)
assert_raises(lambda _=None: parse("u''"), CoconutStyleError)
assert_raises(lambda _=None: parse("def f(x):\\\n pass"), CoconutStyleError)
assert_raises(lambda _=None: parse("abc "), CoconutStyleError)
assert_raises(lambda _=None: parse("abc", "file"), CoconutStyleError)
assert_raises(lambda _=None: parse("a=1;"), CoconutStyleError)
assert_raises(lambda _=None: parse("class derp(object)"), CoconutStyleError)
setup()
assert_raises(lambda _=None: cmd("-f"), SystemExit)
assert_raises(lambda _=None: cmd("-pa ."), SystemExit)
assert_raises(lambda _=None: cmd("-n . ."), SystemExit)
assert_raises(lambda _=None: parse("f$()"), CoconutSyntaxError)
assert_raises(lambda _=None: parse("f(*x, y)"), CoconutSyntaxError)
assert_raises(lambda _=None: parse("def f(x) = return x"), CoconutSyntaxError)
assert_raises(lambda _=None: parse("def f(x) =\n return x"), CoconutSyntaxError)
assert_raises(lambda _=None: parse("a := b"), CoconutParseError)
assert_raises(lambda _=None: parse("(a := b)"), CoconutTargetError)
setup(target="2.7")
assert parse("from io import BytesIO", mode="any") == "from io import BytesIO"
assert_raises(lambda _=None: parse("def f(*, x=None) = x"), CoconutTargetError)
setup(target="3.6")
assert parse("def f(*, x=None) = x")
setup(target="3.8")
assert parse("(a := b)")
assert parse("print(a := 1, b := 2)")
assert parse("def f(a, /, b) = a, b")
if CoconutKernel is not None:
if PY35:
asyncio.set_event_loop(asyncio.new_event_loop())
k = CoconutKernel()
exec_result = (unwrap_future)(k.do_execute("derp = pow$(?, 2)", False, True, {"two": "(+)(1, 1)"}, True))
assert exec_result["status"] == "ok"
assert exec_result["user_expressions"]["two"]["data"]["text/plain"] == "2"
assert k.do_is_complete("if abc:")["status"] == "incomplete"
assert k.do_is_complete("f(")["status"] == "incomplete"
assert k.do_is_complete("abc")["status"] == "complete"
inspect_result = k.do_inspect("derp", 4, 0)
assert inspect_result["status"] == "ok"
assert inspect_result["found"]
assert inspect_result["data"]["text/plain"]
complete_result = k.do_complete("der", 1)
assert complete_result["status"] == "ok"
assert "derp" in complete_result["matches"]
assert complete_result["cursor_start"] == 0
assert complete_result["cursor_end"] == 1
keyword_complete_result = k.do_complete("ma", 1)
assert keyword_complete_result["status"] == "ok"
assert "match" in keyword_complete_result["matches"]
assert "map" in keyword_complete_result["matches"]
assert keyword_complete_result["cursor_start"] == 0
assert keyword_complete_result["cursor_end"] == 1
if not PYPY:
import numpy as np
assert np.all(fmap(lambda _=None: _ + 1, np.arange(3)) == np.array([1, 2, 3]))
print("<success>")
def _compileAndCheck(self,expr,expected):
"""Compiles `code` using `convenience.parse` and asserts the result is in `output`"""
code = convenience.parse(expr,'block')
self.assertIn(expected,code)
def main():
if NOT_PY_32:
import coconut.highlighter
assert consume(range(10), keep_last=1)[0] == 9 == coc_consume(range(10), keep_last=1)[0]
assert version() == version("num")
assert version("name")
assert version("spec")
assert version("tag")
assert version("-v")
try:
version("other")
except CoconutException:
assert True
else:
assert False
setup()
_sys = parse("abc", "sys")
assert _sys
assert _sys == parse("abc")
_single = parse("abc", "single")
assert _single
_file = parse("abc", "file")
assert _file
_package = parse("abc", "package")
assert _package
_block = parse("abc", "block")
assert _block
_eval = parse("abc", "eval")
assert _eval
_debug = parse("abc", "debug")
assert _debug
assert _single == parse("abc", "single")
assert _file == parse("abc", "file")
assert _package == parse("abc", "package")
assert _block == parse("abc", "block")
assert _eval == parse("abc", "eval")
assert _debug == parse("abc", "debug")
assert parse(" abc", "eval")
try:
parse(" abc", "file")
except CoconutException:
assert True
else:
assert False
try:
parse("'")
except CoconutException:
assert True
else:
assert False
try:
parse("(")
except CoconutException:
assert True
else:
assert False
try:
parse("\\(")
except CoconutException:
assert True
else:
assert False
try:
parse("if a:\n b\n c")
except CoconutException:
assert True
else:
assert False
try:
parse("$")
except CoconutException:
assert True
else:
assert False
try:
parse("_coconut")
except CoconutException:
assert True
else:
assert False
assert parse("def f(x):\n \t pass")
assert parse("lambda x: x")
assert parse("u''")
assert parse("def f(x):\\\n pass")
assert parse("abc ")
setup(strict=True)
try:
parse("def f(x):\n \t pass")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("lambda x: x")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("u''")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("def f(x):\\\n pass")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("abc ")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("abc", "file")
except CoconutStyleError:
assert True
else:
assert False
try:
parse("a=1;")
except CoconutStyleError:
assert True
else:
assert False
setup()
try:
cmd("-f")
except SystemExit:
assert True
else:
assert False
try:
cmd("-pa .")
except SystemExit:
assert True
else:
assert False
try:
cmd("-n . .")
except SystemExit:
assert True
else:
assert False
try:
parse("f''")
except CoconutException:
assert True
else:
assert False
setup(target="3.6")
assert parse("f''")
if CoconutKernel is not None:
k = CoconutKernel()
exec_result = k.do_execute("abcdefghi = True", False, True, {"two": "1+1"}, True)
assert exec_result["status"] == "ok"
assert exec_result["user_expressions"]["two"] == 2
assert k.do_is_complete("if abc:")["status"] == "incomplete"
assert k.do_is_complete("f(")["status"] == "incomplete"
assert k.do_is_complete("abc")["status"] == "complete"
inspect_result = k.do_inspect("abcdefghi", 4, 0)
assert inspect_result["status"] == "ok"
assert inspect_result["found"]
assert inspect_result["data"]["text/plain"]
complete_result = k.do_complete("abc", 1)
assert complete_result["status"] == "ok"
assert complete_result["matches"] == ["abcdefghi"]
assert complete_result["cursor_start"] == 0
assert complete_result["cursor_end"] == 3
assert not complete_result["metadata"]
keyword_complete_result = k.do_complete("ma", 1)
assert keyword_complete_result["status"] == "ok"
assert set(keyword_complete_result["matches"]) == set(["map", "match"])
assert keyword_complete_result["cursor_start"] == 0
assert keyword_complete_result["cursor_end"] == 2
assert not keyword_complete_result["metadata"]
print("<success>")
