Exemplo n.º 1
0
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")
Exemplo n.º 2
0
 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)
Exemplo n.º 3
0
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)
Exemplo n.º 7
0
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")
Exemplo n.º 8
0
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")
Exemplo n.º 9
0
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")
Exemplo n.º 10
0
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")
Exemplo n.º 11
0
 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)
Exemplo n.º 12
0
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")
Exemplo n.º 13
0
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")
Exemplo n.º 14
0
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(')
Exemplo n.º 15
0
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")
Exemplo n.º 16
0
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")
Exemplo n.º 17
0
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")
Exemplo n.º 18
0
 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)
Exemplo n.º 19
0
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")
Exemplo n.º 20
0
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
Exemplo n.º 21
0
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.")
Exemplo n.º 22
0
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
Exemplo n.º 23
0
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
Exemplo n.º 24
0
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
Exemplo n.º 25
0
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))
Exemplo n.º 26
0
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")
Exemplo n.º 27
0
    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)
Exemplo n.º 28
0
 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)
Exemplo n.º 29
0
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")
Exemplo n.º 30
0
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")
Exemplo n.º 31
0
 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)
Exemplo n.º 32
0
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.")
Exemplo n.º 33
0
 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)
Exemplo n.º 34
0
 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)
Exemplo n.º 35
0
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))