Python TaggedValue Examples

Example #1

def test_dacc_path_has_no_critical():
    seg = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "L"),
         TaggedValue(3, "L")])
    with pytest.raises(ApplicationError):
        seg.dacc_path(fun.idt, fun.idt, operator.add)

Example #2

def test_reduce_global_has_critical():
    seg = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "L"),
         TaggedValue(2, "C")])
    with pytest.raises(AssertionError):
        seg.reduce_global(fun.add)

Example #3

def test_has_critical_no():
    val1 = TaggedValue(1, "N")
    val2 = TaggedValue(2, "L")
    seg = Segment([val1, val2])
    exp = False
    res = seg.has_critical()
    assert exp == res

Example #4

def test_has_critical_yes():
    val1 = TaggedValue(1, "N")
    val2 = TaggedValue(2, "L")
    val3 = TaggedValue(3, "C")
    seg = Segment([val1, val2, val3])
    exp = True
    res = seg.has_critical()
    assert exp == res

Example #5

def test_get_right_is_leaf():
    gt = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "L"),
         TaggedValue(2, "L")])
    i = 1
    with pytest.raises(AssertionError):
        gt.get_right(i)

Example #6

def test_zip_not_equal_size_error():
    seg1 = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "L"),
         TaggedValue(2, "L")])
    seg2 = Segment([TaggedValue(2, "L")])
    with pytest.raises(AssertionError):
        seg1.zip(seg2)

Example #7

def test_reduce_global_node():
    seg = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(2, "L"),
         TaggedValue(2, "L")])
    res = seg.reduce_global(fun.add)
    exp = 6
    assert res == exp

Example #8

def test_zipwith_not_equal_size_error():
    seg1 = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "L"),
         TaggedValue(2, "L")])
    seg2 = Segment([TaggedValue(2, "L")])
    with pytest.raises(AssertionError):
        seg1.map2(operator.add, seg2)

Example #9

def test_from_str():
    s = "[(11^N); (2^L); (3^C)]"
    res = Segment.from_str(s)
    exp = Segment(
        [TaggedValue(11, "N"),
         TaggedValue(2, "L"),
         TaggedValue(3, "C")])
    assert res == exp

Example #10

def test_reduce_local_leaf():
    seg = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "L"),
         TaggedValue(3, "L")])
    res = seg.reduce_local(fun.add, fun.idt, fun.add, fun.add)
    exp = TaggedValue(6, "L")
    assert res == exp

Example #11

def test_get_right_has_critical():
    gt = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "C"),
         TaggedValue(2, "L")])
    i = 0
    with pytest.raises(AssertionError):
        gt.get_right(i)

Example #12

def test_dacc_global_has_critical():
    seg = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(1, "C"),
         TaggedValue(1, "L")])
    c = 2
    with pytest.raises(AssertionError):
        seg.dacc_global(operator.add, c)

Example #13

File: test_ltree.py Project: JolanPhilippe/PySke

def test_uacc_illformed():
    seg1 = Segment([TaggedValue(13, "C")])
    seg3 = Segment(
        [TaggedValue(72, "N"),
         TaggedValue(92, "L"),
         TaggedValue(42, "L")])
    lt = LTree([seg1, seg3])
    with pytest.raises(IllFormedError):
        lt.uacc(fun.add, fun.idt, fun.add, fun.add, fun.add)

Example #14

def test_get_right_direct():
    gt = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "L"),
         TaggedValue(2, "L")])
    i = 0
    res = gt.get_right(i)
    exp = TaggedValue(2, "L")
    assert res == exp

Example #15

def test_uacc_local_prefix_1():
    seg = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "C"),
         TaggedValue((0, 1), "L")])
    res = seg.uacc_local(k, phi, psi_l, psi_r)
    exp = (TaggedValue((0, 1, 1, 4),
                       "N"), Segment([None, None,
                                      TaggedValue((0, 1), "L")]))
    assert res == exp

Example #16

def test_uacc_update_not_same_size():
    seg = Segment([
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(3, "L")
    ])
    gt = Segment()
    lc = 1
    rc = 2
    with pytest.raises(AssertionError):
        seg.uacc_update(gt, fun.add, lc, rc)

Example #17

def test_uacc_global_node():
    seg = Segment([
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(3, "L")
    ])
    res = seg.uacc_global(fun.add)
    exp = Segment([
        TaggedValue(9, "N"),
        TaggedValue(2, "L"),
        TaggedValue(6, "N"),
        TaggedValue(2, "L"),
        TaggedValue(3, "L")
    ])
    assert res == exp

Example #18

def test_dacc_local():
    seg = Segment([
        TaggedValue(231, "N"),
        TaggedValue(169, "L"),
        TaggedValue(478, "N"),
        TaggedValue(634, "L"),
        TaggedValue(2, "C")
    ])
    c = 400
    res = seg.dacc_local(operator.add, operator.sub, c)
    exp = Segment([
        TaggedValue(400, "N"),
        TaggedValue(631, "L"),
        TaggedValue(169, "N"),
        TaggedValue(647, "L"),
        TaggedValue(-309, "C")
    ])
    assert res == exp

Example #19

def test_dacc_global():
    c = 2
    seg = Segment([
        TaggedValue((1, 1), "N"),
        TaggedValue((2, 3), "L"),
        TaggedValue((1, 2), "N"),
        TaggedValue((2, 2), "L"),
        TaggedValue((3, 1), "L")
    ])
    res = seg.dacc_global(operator.add, c)
    exp = Segment([
        TaggedValue(2, "N"),
        TaggedValue(3, "L"),
        TaggedValue(3, "N"),
        TaggedValue(4, "L"),
        TaggedValue(5, "L")
    ])
    assert res == exp

Example #20

def test_zipwith():
    seg1 = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "L"),
         TaggedValue(3, "L")])
    seg2 = Segment(
        [TaggedValue(4, "N"),
         TaggedValue(5, "L"),
         TaggedValue(6, "L")])
    res = seg1.map2(operator.add, seg2)
    exp = Segment(
        [TaggedValue(5, "N"),
         TaggedValue(7, "L"),
         TaggedValue(9, "L")])
    assert res == exp

Example #21

def test_deserialization_1_1():
    # btree4
    exp = Node(1, Node(2, Node(4, Leaf(6), Leaf(7)), Node(5, Leaf(8),
                                                          Leaf(9))), Leaf(3))
    seg1 = Segment([TaggedValue(1, "C")])
    seg2 = Segment([TaggedValue(2, "C")])
    seg3 = Segment([TaggedValue(4, "C")])
    seg4 = Segment([TaggedValue(6, "L")])
    seg5 = Segment([TaggedValue(7, "L")])
    seg6 = Segment([TaggedValue(5, "C")])
    seg7 = Segment([TaggedValue(8, "L")])
    seg8 = Segment([TaggedValue(9, "L")])
    seg9 = Segment([TaggedValue(3, "L")])
    lt = LTree([seg1, seg2, seg3, seg4, seg5, seg6, seg7, seg8, seg9])
    res = lt.deserialization()
    assert res == exp

Example #22

def test_zip():
    seg1 = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "L"),
         TaggedValue(3, "L")])
    seg2 = Segment(
        [TaggedValue(4, "N"),
         TaggedValue(5, "L"),
         TaggedValue(6, "L")])
    res = seg1.zip(seg2)
    exp = Segment([
        TaggedValue((1, 4), "N"),
        TaggedValue((2, 5), "L"),
        TaggedValue((3, 6), "L")
    ])
    assert res == exp

Example #23

def test_serialization_1_1():
    # btree4
    bt = Node(1, Node(2, Node(4, Leaf(6), Leaf(7)), Node(5, Leaf(8), Leaf(9))),
              Leaf(3))
    m = 1
    res = LTree.init_from_bt(bt, m)
    seg1 = Segment([TaggedValue(1, "C")])
    seg2 = Segment([TaggedValue(2, "C")])
    seg3 = Segment([TaggedValue(4, "C")])
    seg4 = Segment([TaggedValue(6, "L")])
    seg5 = Segment([TaggedValue(7, "L")])
    seg6 = Segment([TaggedValue(5, "C")])
    seg7 = Segment([TaggedValue(8, "L")])
    seg8 = Segment([TaggedValue(9, "L")])
    seg9 = Segment([TaggedValue(3, "L")])
    exp = LTree([seg1, seg2, seg3, seg4, seg5, seg6, seg7, seg8, seg9])
    assert res == exp

Example #24

def test_deserialization_1_4():
    # btree4
    seg1 = Segment([TaggedValue(1, "C")])
    seg2 = Segment([TaggedValue(2, "C")])
    seg3 = Segment(
        [TaggedValue(4, "N"),
         TaggedValue(6, "L"),
         TaggedValue(7, "L")])
    seg4 = Segment(
        [TaggedValue(5, "N"),
         TaggedValue(8, "L"),
         TaggedValue(9, "L")])
    seg5 = Segment([TaggedValue(3, "L")])
    lt = LTree([seg1, seg2, seg3, seg4, seg5])
    res = lt.deserialization()
    exp = Node(1, Node(2, Node(4, Leaf(6), Leaf(7)), Node(5, Leaf(8),
                                                          Leaf(9))), Leaf(3))
    assert res == exp

Example #25

File: ptree.py Project: Iguane45/PySke

 def __global_upwards_accumulation(psi_n, gt):
     gt2 = None
     if PID == 0:
         par.at_root(
             lambda: logger.debug('[START] PID[%s] uacc_global', PID))
         gt2 = gt.uacc_global(psi_n)
         for i, _ in enumerate(gt2):
             if gt2[i].is_node():
                 gt2[i] = TaggedValue((gt2.get_left(i).get_value(),
                                       gt2.get_right(i).get_value()),
                                      gt2[i].get_tag())
         par.at_root(lambda: logger.debug('[END] PID[%s] uacc_global', PID))
     return gt2

Example #26

def test_uacc_local_node():
    seg = Segment([
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(1, "N"),
        TaggedValue(2, "L"),
        TaggedValue(3, "C")
    ])
    res = seg.uacc_local(fun.add, fun.idt, fun.add, fun.add)
    exp = (TaggedValue(9, "N"),
           Segment(
               [None,
                TaggedValue(2, "L"), None,
                TaggedValue(2, "L"), None]))
    assert res == exp

Example #27

def test_serialization_1_3():
    # btree4
    bt = Node(1, Node(2, Node(4, Leaf(6), Leaf(7)), Node(5, Leaf(8), Leaf(9))),
              Leaf(3))
    m = 3
    res = LTree.init_from_bt(bt, m)
    seg1 = Segment(
        [TaggedValue(1, "N"),
         TaggedValue(2, "C"),
         TaggedValue(3, "L")])
    seg2 = Segment(
        [TaggedValue(4, "N"),
         TaggedValue(6, "L"),
         TaggedValue(7, "L")])
    seg3 = Segment(
        [TaggedValue(5, "N"),
         TaggedValue(8, "L"),
         TaggedValue(9, "L")])
    exp = LTree([seg1, seg2, seg3])
    assert res == exp

Example #28

File: test_ltree.py Project: JolanPhilippe/PySke

def test_reduce():
    seg1 = Segment([TaggedValue(13, "C")])
    seg2 = Segment(
        [TaggedValue(31, "N"),
         TaggedValue(47, "L"),
         TaggedValue(32, "L")])
    seg3 = Segment(
        [TaggedValue(72, "N"),
         TaggedValue(92, "L"),
         TaggedValue(42, "L")])
    lt = LTree([seg1, seg2, seg3])
    res = lt.reduce(fun.add, fun.idt, fun.add, fun.add, fun.add)
    exp = 13 + 31 + 47 + 32 + 72 + 92 + 42
    assert res == exp

Example #29

def test_uacc_local_prefix_3():
    seg = Segment([
        TaggedValue(5, "N"),
        TaggedValue((0, 1), "L"),
        TaggedValue((0, 1), "L")
    ])
    res = seg.uacc_local(k, phi, psi_l, psi_r)
    exp = (TaggedValue((1, 3), "L"),
           Segment([
               TaggedValue((1, 3), "N"),
               TaggedValue((0, 1), "L"),
               TaggedValue((0, 1), "L")
           ]))
    assert res == exp

Example #30

def test_zipwith_not_same_tag_error():
    seg1 = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "L"),
         TaggedValue(2, "L")])
    seg2 = Segment(
        [TaggedValue(2, "N"),
         TaggedValue(1, "C"),
         TaggedValue(2, "L")])
    with pytest.raises(NotSameTagError):
        seg1.map2(operator.add, seg2)