def lambda_handler(event, context): code = event['code'] setup(line_numbers = "TRUE") code = parse(code) print("compiled") print(code) return code
def using_coconut(fresh_logger=True, fresh_convenience=False): """Decorator for ensuring that coconut.terminal.logger and coconut.convenience.* are reset.""" saved_logger = logger.copy() if fresh_convenience: setup() auto_compilation(False) if fresh_logger: logger.reset() try: yield finally: setup() auto_compilation(False) logger.copy_from(saved_logger)
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 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 })
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 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>")