def test_parse(): # invalid inputs assert_throw(lambda: lisp.parse('1337')) assert_throw(lambda: lisp.parse('nick "oreqizer"')) assert_throw(lambda: lisp.parse('(yolo "swag")')) print("test_parse OK")
def test_lisp_define(self): input = '(define circle-area (lambda (r) (* pi (* r r))))' expected = 314.1592653589793 lisp.eval(lisp.parse(input)) input = '(circle-area (+ 5 5))' actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual)
def test_eval_solve(): # • ‹(solve <matrix>)› # → ‹vector› -- linear equation solver res = eval_root( parse('(solve (matrix (vector 1 0) (vector 0 1)))')) want = Vector([0, 0]) assert res == want, f'{res} == {want}' res = eval_root( parse('(solve (matrix (vector 2 0) (vector 0 1)))')) want = Vector([0, 0]) assert res == want, f'{res} == {want}' res = eval_root(parse('(solve (matrix (vector 1 2 0) (vector 0 4 1) (vector 2 0 -1)))')) want = Vector([-0.4364357804719846, 0.21821789023599236, -0.8728715609439694]) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root( parse('(solve (matrix (vector 1 2 3) (vector 1 2 3)))'))) res = eval_root( parse('(solve (matrix (+ (vector 0 1 0) (vector 1 1 0)) (vector 0 4 1)(vector 2 0 -1)))')) want = Vector([-0.4364357804719846, 0.21821789023599236, -0.8728715609439694]) assert res == want, f'{res} == {want}' print("test_eval_solve OK")
def test_eval_expr_2(self): """Test 'eval_sexpr' circle circumference 2""" sexpr1 = "(define circle-area (lambda (r) (* pi (* r r))))" sexpr2 = "(circle-area 3)" _actual1 = eval_sexpr(parse(sexpr1)) actual2 = eval_sexpr(parse(sexpr2)) expected = 28.274333882308138 self.assertEqual(actual2, expected)
def test_eval_expr_3(self): """Test 'eval_sexpr' circle cricumference 3""" sexpr1 = "(define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))" sexpr2 = "(circle-area (fact 10))" _actual1 = eval_sexpr(parse(sexpr1)) actual2 = eval_sexpr(parse(sexpr2)) expected = 41369087205782.695 self.assertEqual(actual2, expected)
def test_eval_expr_5(self): """Test 'eval_sexpr' factorial""" sexpr1 = "(define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))" sexpr2 = "(fact 10)" _actual1 = eval_sexpr(parse(sexpr1)) actual2 = eval_sexpr(parse(sexpr2)) expected = 3628800 self.assertEqual(actual2, expected)
def test_parse_replay(): # (replay "{channel}" {unix timestamp}) got = lisp.parse('(replay "#chan" 1337)') want = Replay("#chan", 1337) assert got == want, f"{got} == {want}" assert_throw(lambda: lisp.parse('(replay "#chan")')) assert_throw(lambda: lisp.parse('(replay "#chan" 1337 asd)')) print("test_parse_replay OK")
def test_parse_nick(): # (nick "{nickname}") got = lisp.parse('(nick "oreqizer")') want = Nick("oreqizer") assert got == want, f"{got} == {want}" assert_throw(lambda: lisp.parse('(nick "#channel")')) assert_throw(lambda: lisp.parse('(nick)')) assert_throw(lambda: lisp.parse('(nick "oreqizer" asd)')) print("test_parse_nick OK")
def test_parse_message(): # (message "{channel}" "{text}") got = lisp.parse('(message "#chan" "toxt")') want = Message("#chan", "toxt") assert got == want, f"{got} == {want}" assert_throw(lambda: lisp.parse('(message "chan", "toxt")')) assert_throw(lambda: lisp.parse('(message "#oreqizer")')) assert_throw(lambda: lisp.parse('(message "#oreqizer" "oreqizer" asd)')) print("test_parse_message OK")
def test_parse_part(): # (part "{channel}") got = lisp.parse('(part "#chan")') want = Part("#chan") assert got == want, f"{got} == {want}" assert_throw(lambda: lisp.parse('(part "chan")')) assert_throw(lambda: lisp.parse('(part)')) assert_throw(lambda: lisp.parse('(part "#chan" asd)')) print("test_parse_part OK")
def test_eval_expr_4(self): """Test 'eval_sexpr' account structure""" sexpr1 = "(define make-account (lambda (balance) (lambda (amt) (begin (set! balance (+ balance amt)) balance))))" sexpr2 = "(define account1 (make-account 100.00))" sexpr3 = "(account1 -20.00)" _actual1 = eval_sexpr(parse(sexpr1)) _actual2 = eval_sexpr(parse(sexpr2)) actual3 = eval_sexpr(parse(sexpr3)) expected = 80.0 self.assertEqual(actual3, expected)
def test_parse_join(): # (join "{channel}") got = lisp.parse('(join "#chan")') want = Join("#chan") assert got == want, f"{got} == {want}" assert_throw(lambda: lisp.parse('(join "chan")')) assert_throw(lambda: lisp.parse('(join)')) assert_throw(lambda: lisp.parse('(join "#oreqizer" asd)')) print("test_parse_join OK")
def test_eval_root(): # root: Compound # returns Matrix | Vector | Number assert_throw(lambda: eval_root(parse('(kek)'))) assert_throw(lambda: eval_root(parse('(oopa 1 3 3 7)'))) s = '13.37' res = eval_root(parse(s)) assert type(res) == Number, f'{type(res)} == Number' assert str(res) == s, f'{str(res)} == {s}' assert res.value == 13.37, f'{res.value} == 13.37' print("test_eval_root OK")
def test_parser(): assert p("'a") == ['quote', 'a'] assert p('b') == 'b' assert p('()') == [] assert p('(c)') == ['c'] assert p('(c d)') == ['c', 'd'] assert p('((e) f)') == [['e'], 'f'] assert p('(g (h))') == ['g', ['h']] assert p('(g (h) ())') == ['g', ['h'], []] assert parse('(g) (h)') == [['g'], ['h']] assert parse("(label a 'b) (wrap a)") == [['label', 'a', ['quote', 'b']], ['wrap', 'a']] with pytest.raises(AssertionError): parse('(g(')
def test_eval_dot(): # • ‹(dot <vector> <vector>)› # → ‹real› -- dot product res = eval_root(parse('(dot (vector 2 1 6) (vector 1 2 1))')) want = Number(10.0) assert res == Number(10.0), f'{res} == {want}' assert_throw(lambda: eval_root(parse('(dot (vector 0 1) (vector 1 2 3))'))) res = eval_root( parse('(dot (+ (vector 1 1 2) (vector 1 0 4)) (vector 1 2 1))')) want = Number(10.0) assert res == Number(10.0), f'{res} == {want}' print("test_eval_dot OK")
def test_eval_det(): # • ‹(det <matrix>)› # → ‹real› -- determinant of the matrix res = eval_root(parse('(det (matrix (vector 1 2) (vector 2 3)))')) want = Number(-1) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root( parse('(det (matrix (vector 1 2 3) (vector 1 2 3)))'))) res = eval_root( parse('(det (matrix (+ (vector 0 1) (vector 1 1)) (vector 2 3)))')) want = Number(-1) assert res == want, f'{res} == {want}' print("test_eval_det OK")
def test_eval_vector(): # • ‹(vector <real>+)› # <real>+ means 1 or more objects of type ‹real› s = '(vector 1.0 3.0 7.0)' res = eval_root(parse(s)) assert type(res) == Vector, f'{type(res)} == Vector' assert str(res) == s, f'{str(res)} == {s}' assert res.values == [1, 3, 7], f'{res.values} == [1, 3, 7]' assert_throw(lambda: eval_root(parse('(vector 1 "kek" 7)'))) res = eval_root(parse('(vector 1 (dot (vector 1 0) (vector 3 2)) 7)')) want = Vector([1, 3, 7]) assert res == want, f'{res} == {want}' print("test_eval_vector OK")
def test_eval_expr_6(self): """Test 'eval_sexpr' count""" sexpr1 = "(define first car)" sexpr2 = "(define rest cdr)" sexpr3 = "(define count (lambda (item L) (if L (+ (equal? item (first L)) (count item (rest L))) 0)))" sexpr4 = "(count 0 (list 0 1 2 3 0 0))" sexpr5 = "(count (quote the) (quote (the more the merrier the bigger the better)))" _actual1 = eval_sexpr(parse(sexpr1)) _actual2 = eval_sexpr(parse(sexpr2)) _actual3 = eval_sexpr(parse(sexpr3)) actual4 = eval_sexpr(parse(sexpr4)) actual5 = eval_sexpr(parse(sexpr5)) expected_1 = 3 self.assertEqual(actual4, expected_1) expected_2 = 4 self.assertEqual(actual5, expected_2)
def test_eval_mul(): # • ‹(* <matrix> <matrix>)› # → ‹matrix› -- matrix multiplication res = eval_root(parse( '(* (matrix (vector 1 2 0) (vector 2 3 1)) (matrix (vector 3) (vector 0) (vector 1)))')) want = Matrix([Vector([3]), Vector([7])]) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root( parse('(* (matrix (vector 1 2 3)) (matrix (vector 3 1) (vector 0 1)))'))) res = eval_root(parse( '(* (matrix (+ (vector 0 1) (vector 1 1)) (vector 2 3)) (matrix (vector 3 1) (vector 0 1)))')) want = Matrix([Vector([3, 3]), Vector([6, 5])]) assert res == want, f'{res} == {want}' print("test_eval_mul OK")
def parse_attributes(text): stream = StringIO() stream.write(text) stream.seek(0) premonition_stream_1 = lisp.premonition_stream(stream) items = lisp.parse(premonition_stream_1) return items
def test_forward(): """Simple example using interaction, parsing, and sample call to GNN.forward() where we still take the ground truth path at each step.""" problem = "(q-transform/hint (quote (lambda (cdr (cdr (var ()))))) (quote ((() y . 1) (#f y () . #t) (#f b () b . y) (x #f (#f . #f) . #t) (a #f y x s . a))))" step = 0 model = GNNModel() # small model, randomly initialized print("Starting problem:", problem) with Interaction(lisp.parse(problem)) as env: signal = None while signal != "solved": # parse & score acc = {'constraints': []} parsed_subtree = parse_split_trees(env.state) out = gnn_forward(parsed_subtree, model) prob = F.softmax(out, 1) print(prob) # ignore the score and take the ground-truth step signal = env.follow_path(env.good_path) step += 1 print('Step', step, 'Signal:', signal) print("Completed.")
def decode_folders(folders): for folder_text in folders: #print "folder_text", folder_text stream = StringIO() stream.write(folder_text) # (\HasNoChildren) "/" "Gel&APY-schte Objekte" <type 'str'> stream.seek(0) premonition_stream_1 = lisp.premonition_stream(stream) assert (premonition_stream_1.peek() == "(") premonition_stream_1.consume() flags = lisp.parse(premonition_stream_1) assert (premonition_stream_1.peek() == " ") premonition_stream_1.consume() separator = lisp.parse_string_literal(premonition_stream_1) assert (separator == "/") # limitation assert (premonition_stream_1.peek() == " ") premonition_stream_1.consume() if premonition_stream_1.peek() == "\"": name = lisp.parse_string_literal(premonition_stream_1) else: # weird. name = premonition_stream_1.consume_rest() name = "".join(unescape_imap_name(name)) #flags, separator, name = data yield flags, separator, name
def decode_folders(folders): for folder_text in folders: # print "folder_text", folder_text stream = StringIO() stream.write(folder_text) # (\HasNoChildren) "/" "Gel&APY-schte Objekte" <type 'str'> stream.seek(0) premonition_stream_1 = lisp.premonition_stream(stream) assert premonition_stream_1.peek() == "(" premonition_stream_1.consume() flags = lisp.parse(premonition_stream_1) assert premonition_stream_1.peek() == " " premonition_stream_1.consume() separator = lisp.parse_string_literal(premonition_stream_1) assert separator == "/" # limitation assert premonition_stream_1.peek() == " " premonition_stream_1.consume() if premonition_stream_1.peek() == '"': name = lisp.parse_string_literal(premonition_stream_1) else: # weird. name = premonition_stream_1.consume_rest() name = "".join(unescape_imap_name(name)) # flags, separator, name = data yield flags, separator, name
def resolve(elements): if len(elements) != 2 and len(elements) != 3: return Error("too many/ too little operands") operator = str(elements[0]) operands = elements[1:] if operator == "+": if len(operands) != 2: return Error("too many/ too little operands") try: result = operands[0] + operands[1] except: return Error("+ failed") elif operator == "*": if len(operands) != 2: return Error("too many/ too little operands") try: result = operands[0] * operands[1] except: return Error("* failed") elif operator == "dot": if len(operands) != 2: return Error("too many/ too little operands") try: result = operands[0].dot(operands[1]) except: return Error("dot failed") elif operator == "dft": if len(operands) != 1: return Error("too many/ too little operands") try: result = operands[0].dft() except: return Error("dft failed") elif operator == "solve": if len(operands) != 1: return Error("too many/ too little operands") try: result = operands[0].solve() except: return Error("solve failed") elif operator == "det": if len(operands) != 1: return Error("too many/ too little operands") try: result = operands[0].det() except: return Error("det failed") else: return Error("unexpected operator") return parse(toLisp(result))
def test_eval_add(): # • ‹(+ <vector> <vector>)› # → ‹vector› -- vector addition res = eval_root(parse('(+ (vector 0 2 1 6) (vector 1 1 2 1))')) want = Vector([1, 3, 3, 7]) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root(parse('(+ (vector 0 1) (vector 1 2 3))'))) res = eval_root( parse('(+ (+ (vector 0 1 1 2) (vector 0 1 0 4)) (vector 1 1 2 1))')) want = Vector([1, 3, 3, 7]) assert res == want, f'{res} == {want}' # • ‹(+ <matrix> <matrix>)› # → ‹matrix› -- matrix addition res = eval_root(parse( '(+ (matrix (vector 1 2 0) (vector 2 3 1)) (matrix (vector 3 1 4) (vector 0 1 0)))')) want = Matrix([Vector([4, 3, 4]), Vector([2, 4, 1])]) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root( parse('(+ (matrix (vector 1 2)) (matrix (vector 3 1) (vector 0 1)))'))) assert_throw(lambda: eval_root(parse( '(+ (matrix (vector 1 2 3) (vector 2 3 1)) (matrix (vector 3 1) (vector 0 1)))'))) res = eval_root(parse( '(+ (matrix (+ (vector 0 1) (vector 1 1)) (vector 2 3)) (matrix (vector 3 1) (vector 0 1)))')) want = Matrix([Vector([4, 3]), Vector([2, 4])]) assert res == want, f'{res} == {want}' print("test_eval_add OK")
def test_lisp_expression(self): input = '(+ 10 20)' expected = 30 actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual) input = '(- 10 20)' expected = -10 actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual) input = '(* 5 12)' expected = 60 actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual) input = '(/ 30 5)' expected = 6 actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual) # input = '(+ 1 2 3 4 5)' # expected = 15 # actual = lisp.eval(lisp.parse(input)) # self.assertEqual(expected, actual) # input = '(- 100 10 1)' # expected = 89 # actual = lisp.eval(lisp.parse(input)) # self.assertEqual(expected, actual) # input = '(* 1 2 3 4 5)' # expected = 120 # actual = lisp.eval(lisp.parse(input)) # self.assertEqual(expected, actual) # input = '(/ 100 10 2)' # expected = 5 # actual = lisp.eval(lisp.parse(input)) # self.assertEqual(expected, actual) input = '(+ (* 5 3) 5)' expected = 20 actual = lisp.eval(lisp.parse(input)) self.assertEqual(expected, actual)
def test_eval_expr_7(self): """Test 'eval_sexpr' repeat""" sexpr1 = "(define twice (lambda (x) (* 2 x)))" sexpr2 = "(define repeat (lambda (f) (lambda (x) (f (f x)))))" sexpr3 = "(twice 5)" sexpr4 = "((repeat twice) 10)" sexpr5 = "((repeat (repeat twice)) 10)" sexpr6 = "((repeat (repeat (repeat twice))) 10)" sexpr7 = "((repeat (repeat (repeat (repeat twice)))) 10)" _actual1 = eval_sexpr(parse(sexpr1)) _actual2 = eval_sexpr(parse(sexpr2)) actual3 = eval_sexpr(parse(sexpr3)) actual4 = eval_sexpr(parse(sexpr4)) actual5 = eval_sexpr(parse(sexpr5)) actual6 = eval_sexpr(parse(sexpr6)) actual7 = eval_sexpr(parse(sexpr7)) expected_3 = 10 self.assertEqual(actual3, expected_3) expected_4 = 40 self.assertEqual(actual4, expected_4) expected_5 = 160 self.assertEqual(actual5, expected_5) expected_6 = 2560 self.assertEqual(actual6, expected_6) expected_7 = 655360 self.assertEqual(actual7, expected_7)
def test_eval_cross(): # • ‹(cross <vector> <vector>)› # → ‹vector› -- cross product res = eval_root(parse('(cross (vector 2 1 6) (vector 1 2 1))')) want = Vector([-11, 4, 3]) assert res == want, f'{res} == {want}' assert_throw(lambda: eval_root( parse('(cross (vector 0 1) (vector 1 2 3))'))) assert_throw(lambda: eval_root(parse('(cross (vector 0 1) (vector 2 3))'))) assert_throw(lambda: eval_root( parse('(cross (vector 0 1 1 3) (vector 2 3 3 7))'))) res = eval_root( parse('(cross (+ (vector 1 1 2) (vector 1 0 4)) (vector 1 2 1))')) want = Vector([-11, 4, 3]) assert res == want, f'{res} == {want}' print("test_eval_cross OK")
def test_eval_matrix(): # • ‹(matrix <vector>+)› # each vector is one row, starting from the top s = '(matrix (vector 1.0 3.0) (vector 3.0 7.0))' res = eval_root(parse(s)) assert type(res) == Matrix, f'{type(res)} == Matrix' assert str(res) == s, f'{str(res)} == {s}' assert res.values == [Vector([1, 3]), Vector( [3, 7])], f'{res.values} == [Vector([1. 3]), Vector([3, 7])]' assert_throw(lambda: eval_root( parse('(matrix (vector 1 3) (vector 3 7 5))'))) assert_throw(lambda: eval_root(parse('(matrix (vector 1 3) "kek")'))) res = eval_root( parse('(matrix (+ (vector 1 2) (vector 0 1)) (vector 3 7))')) want = Matrix([Vector([1, 3]), Vector([3, 7])]) assert res == want, f'{res} == {want}' print("test_eval_matrix OK")
def test_eval_expr_8(self): """Test 'eval_sexpr' range""" sexpr1 = "(define fib (lambda (n) (if (< n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))" sexpr2 = "(define range (lambda (a b) (if (= a b) (quote ()) (cons a (range (+ a 1) b)))))" sexpr3 = "(range 0 10)" sexpr4 = "(map fib (range 0 10))" sexpr5 = "(map fib (range 0 20))" _actual1 = eval_sexpr(parse(sexpr1)) _actual2 = eval_sexpr(parse(sexpr2)) actual3 = eval_sexpr(parse(sexpr3)) actual4 = eval_sexpr(parse(sexpr4)) actual5 = eval_sexpr(parse(sexpr5)) expected_3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] self.assertEqual(actual3, expected_3) expected_4 = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] self.assertEqual(actual4, expected_4) expected_5 = [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765 ] self.assertEqual(actual5, expected_5)
def example_interaction_gt(): """Simple example usage of Interaction, where we take the ground truth path at each step.""" problem = "(q-transform/hint (quote (lambda (cdr (cdr (var ()))))) (quote ((() y . 1) (#f y () . #t) (#f b () b . y) (x #f (#f . #f) . #t) (a #f y x s . a))))" step = 0 print("Starting problem:", problem) with Interaction(lisp.parse(problem)) as env: signal = None while signal != "solved": # env.state is ignored signal = env.follow_path(env.good_path) step += 1 print('Step', step, 'Signal:', signal) print("Completed.")
def test_parse(self): """Test 'parse' function happy path""" actual = parse('(begin (define r 10) (* pi (* r r)))') expected = ['begin', ['define', 'r', 10], ['*', 'pi', ['*', 'r', 'r']]] self.assertEqual(actual, expected)
def test_eval_expr(self): """Test 'eval_sexpr' function happy path""" eval_sexpr(parse("(define r 10)")) actual = eval_sexpr(parse("(* pi (* r r))")) expected = 314.1592653589793 self.assertEqual(actual, expected)
def parse_items(all_items, just_one_item_p=False): # re_items = re.compile(r"^([0-9][0-9]*) (.*)$") # match = re_items.match(items) # assert(match) # print >>sys.stderr,"group(1)", match.group(1), uid, type(uid) # assert(int(match.group(1)) == int(uid)) # items = match.group(2) stream = StringIO() # all_items arbitrary item, literal, ... parts for items in all_items: if isinstance(items, str) and items.startswith( "Some messages in the mailbox had previously been expunged and could not be returned" ): # Some messages in the mailbox had previously been expunged and could not be returned. <type 'str'> pass # raise ParseError() if items is None: # ??? # ('46 (ENVELOPE ("Wed, 11 Apr 2007 13:08:38 +0200" {35}', 'Neues "Local-Index-Service" Projekt') <type 'tuple'> print >> sys.stderr, "error: one item is None: all_items = ", all_items raise ParseError() if isinstance(items, tuple): # has literal parts # print >>sys.stderr, "tuple", items coalesced_result = "" is_literal = False for tuple_item in items: if not is_literal: i = tuple_item.rfind("{") if i > -1: tuple_item = tuple_item[:i] is_literal = True else: # is_literal is_literal = False tuple_item = lisp_escaped_quoted_string(tuple_item) stream.write(tuple_item) else: stream.write(items) stream.seek(0) # import pickle # pickle.dump(stream.getvalue(), open('/tmp/save.p','w')) # FIXME # print >>sys.stderr, ">>>", stream.getvalue(), "<<<" premonition_stream_1 = lisp.premonition_stream(stream) # assert(premonition_stream_1.peek() == "(") # premonition_stream_1.consume() items = lisp.parse(premonition_stream_1) # items = [1, [\UID, 0807, \FLAGS, [\Seen], ...], 2, [\UID, 0808, \FLAGS, [\Seen], ...]] items = pair(items) # items = [(1, [\UID, 0807, \FLAGS, [\Seen], ...]), (2, [\UID, 0808, \FLAGS, [\Seen], ...], ...)] """ (ENVELOPE ("Wed, 10 Jan 2007 18:16:22 +0200" "subject" ( ("Long, Name" NIL "Name.Long" "fabalabs.org") ) ( ("Long, Name" NIL "Name.Long" "fabalabs.org") ) ( ("Long, Name" NIL "Name.Long" "fabalabs.org") ) ( ("Milosavljevic, Danny" NIL "Danny.Milosavljevic" "fabasoft.com") ("Pesendorfer, Klaus" NIL "Klaus.Pesendorfer" "fabasoft.com") ("Lechner, Jakob" NIL "Jakob.Lechner" "fabasoft.com") ) NIL NIL NIL "<*****@*****.**>")) """ # items [\UID, \10525, \ENVELOPE, ['Wed, 10 Jan 2007 18:16:22 +0200', 'subject' .. # print >>sys.stderr, "items", items # [0] # assert(items[0][0] in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]) # items.next() if not just_one_item_p: items = items[1:] for number, item in items: # print >>sys.stderr, "item", item # print >>sys.stderr, "yield", dict(pair(item)) # FIXME yield dict(pair(item))