Python Node.children方法代码示例

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_replace_node_and_subtree(self):
        n1 = Node('n1', label=['205', '1'])
        n2 = Node('n2', label=['205', '2'])
        n4 = Node('n4', label=['205', '4'])

        n2a = Node('n2a', label=['205', '2', 'a'])
        n2b = Node('n2b', label=['205', '2', 'b'])
        n2.children = [n2a, n2b]

        root = Node('', label=['205'])
        root.children = [n1, n2, n4]

        reg_tree = compiler.RegulationTree(root)

        a2 = Node('a2', label=['205', '2'])
        a2e = Node('a2e', label=['205', '2', 'e'])
        a2f = Node('a2f', label=['205', '2', 'f'])
        a2.children = [a2e, a2f]

        reg_tree.replace_node_and_subtree(a2)

        new_tree = Node('', label=[205])
        new_tree.children = [n1, a2, n4]

        self.assertEqual(new_tree, reg_tree.tree)
        self.assertEqual(None, find(reg_tree.tree, '205-2-a'))

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
def build_tree(reg_xml):
    doc = etree.fromstring(reg_xml)
    preprocess_xml(doc)

    reg_part = get_reg_part(doc)
    title = get_title(doc)

    tree = Node("", [], [reg_part], title)

    part = doc.xpath('//PART')[0]

    subpart_xmls = [c for c in part.getchildren() if c.tag == 'SUBPART']
    if len(subpart_xmls) > 0:
        subparts = [build_subpart(reg_part, s) for s in subpart_xmls]
        tree.children = subparts
    else:
        section_xmls = [c for c in part.getchildren() if c.tag == 'SECTION']
        sections = []
        for section_xml in section_xmls:
            sections.extend(build_from_section(reg_part, section_xml))
        empty_part = reg_text.build_empty_part(reg_part)
        empty_part.children = sections
        tree.children = [empty_part]

    non_reg_sections = build_non_reg_text(doc, reg_part)
    tree.children += non_reg_sections

    return tree

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_move_interps(self):
        n1 = Node('n1', label=['205', '1', 'Interp'], node_type=Node.INTERP)
        n2 = Node('n2', label=['205', '2', 'Interp'], node_type=Node.INTERP)
        n4 = Node('n4', label=['205', '4', 'Interp'], node_type=Node.INTERP)

        n4c = Node(
            'n4c', label=['205', '4', 'c', 'Interp'],
            node_type=Node.INTERP)

        n4.children = [n4c]

        n2a = Node(
            'n2a', label=['205', '2', 'a', 'Interp'],
            node_type=Node.INTERP)
        n2b = Node(
            'n2b', label=['205', '2', 'b', 'Interp'],
            node_type=Node.INTERP)
        n2a1 = Node(
            '1. First', label=['205', '2', 'a', 'Interp', '1'],
            node_type=Node.INTERP)

        n2a.children = [n2a1]
        n2.children = [n2a, n2b]

        root = Node('', label=['205', 'Interp'], node_type=Node.INTERP)
        root.children = [n1, n2, n4]

        reg_tree = compiler.RegulationTree(root)
        reg_tree.move('205-2-a-Interp-1', ['205', '4', 'c', 'Interp', '5'])

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_replace_node_and_subtree(self):
        n1 = Node("n1", label=["205", "1"])
        n2 = Node("n2", label=["205", "2"])
        n4 = Node("n4", label=["205", "4"])

        n2a = Node("n2a", label=["205", "2", "a"])
        n2b = Node("n2b", label=["205", "2", "b"])
        n2.children = [n2a, n2b]

        root = Node("", label=["205"])
        root.children = [n1, n2, n4]

        reg_tree = compiler.RegulationTree(root)

        a2 = Node("a2", label=["205", "2"])
        a2e = Node("a2e", label=["205", "2", "e"])
        a2f = Node("a2f", label=["205", "2", "f"])
        a2.children = [a2e, a2f]

        reg_tree.replace_node_and_subtree(a2)

        new_tree = Node("", label=[205])
        new_tree.children = [n1, a2, n4]

        self.assertEqual(new_tree, reg_tree.tree)
        self.assertEqual(None, find(reg_tree.tree, "205-2-a"))

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def build_tree(self):
        n1 = Node('n1', label=['200', '1'])
        n2 = Node('n1i', label=['200', 1, 'i'])
        n3 = Node('n2', label=['200', '2'])
        n4 = Node('n3', label=['200', '3'])
        n5 = Node('n3a', label=['200', '3', 'a'])

        n1.children = [n2]
        n4.children = [n5]
        root = Node('root', label=['200'], children=[n1, n3, n4])
        return root

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def tree_with_paragraphs(self):
        n1 = Node('n1', label=['205', '1'])
        n2 = Node('n2', label=['205', '2'])
        n4 = Node('n4', label=['205', '4'])

        n2a = Node('n2a', label=['205', '2', 'a'])
        n2b = Node('n2b', label=['205', '2', 'b'])
        n2.children = [n2a, n2b]

        root = Node('', label=['205'])
        root.children = [n1, n2, n4]
        return root

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def tree_with_paragraphs(self):
        n1 = Node("n1", label=["205", "1"])
        n2 = Node("n2", label=["205", "2"])
        n4 = Node("n4", label=["205", "4"])

        n2a = Node("n2a", label=["205", "2", "a"])
        n2b = Node("n2b", label=["205", "2", "b"])
        n2.children = [n2a, n2b]

        root = Node("", label=["205"])
        root.children = [n1, n2, n4]
        return root

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_add_section(self):
        nsa = Node("nsa", label=["205", "Subpart", "A"], node_type=Node.SUBPART)

        nappa = Node("nappa", label=["205", "Appendix", "C"], node_type=Node.APPENDIX)

        root = Node("", label=["205"])
        root.children = [nsa, nappa]

        n1 = Node("", label=["205", "1"])

        reg_tree = compiler.RegulationTree(root)
        reg_tree.add_section(n1, ["205", "Subpart", "A"])

        nsa.children = [n1]
        self.assertEqual(reg_tree.tree, root)

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_find_candidate_impossible_label(self):
        n1 = Node("", label=["200", "1"])
        n1a = Node("", label=["200", "1", "a"])

        n1a1i = Node("", label=["200", "1", "a", "1", "i"])
        n1a.children = [n1a1i]

        n1b = Node("", label=["200", "1", "b"])
        n1i = Node("", label=["200", "1", "i"])
        n1.children = [n1a, n1b, n1i]

        root = Node("root", label=["200"], children=[n1])
        candidate = changes.find_candidate(root, "i", ["200-1-a", "200-1-b"])[0]

        self.assertEqual(candidate.label, ["200", "1", "i"])

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_add_node_dummy_subpart(self):
        """If the tree consists only of the empty subpart, adding a new
        section should insert into the empty subpart"""
        root = Node(label=["1"])
        empty = Node(label=["1", "Subpart"], node_type="emptypart")
        n1 = Node("n1", label=["1", "1"])
        n2 = Node("n2", label=["1", "2"])
        empty.children = [n1, n2]
        root.children = [empty]
        reg_tree = compiler.RegulationTree(root)

        node = Node("n3", label=["1", "3"], node_type=Node.REGTEXT)
        reg_tree.add_node(node)

        self.assertEqual(len(reg_tree.tree.children), 1)
        self.assertEqual(len(reg_tree.tree.children[0].children), 3)

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_add_to_root(self):
        nsa = Node("nsa", label=["205", "Subpart", "A"], node_type=Node.SUBPART)

        nappa = Node("nappa", label=["205", "Appendix", "C"], node_type=Node.APPENDIX)

        root = Node("", label=["205"])
        root.children = [nsa, nappa]

        reg_tree = compiler.RegulationTree(root)

        nappb = Node("nappb", label=["205", "Appendix", "B"], node_type=Node.APPENDIX)

        reg_tree.add_to_root(nappb)
        root.children = [nsa, nappb, nappa]

        self.assertEqual(reg_tree.tree, root)

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def section_node(self):
        n1 = Node('n2', label=['200', '2'])
        n2 = Node('n2a', label=['200', '2', 'a'])

        n1.children = [n2]
        root = Node('root', label=['200'], children=[n1])
        return root

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def test_find_candidate_impossible_label(self):
        n1 = Node('', label=['200', '1'])
        n1a = Node('', label=['200', '1', 'a'])

        n1a1i = Node('', label=['200', '1', 'a', '1', 'i'])
        n1a.children = [n1a1i]

        n1b = Node('', label=['200', '1', 'b'])
        n1i = Node('', label=['200', '1', 'i'])
        n1.children = [n1a, n1b, n1i]

        root = Node('root', label=['200'], children=[n1])
        candidate = changes.find_candidate(
            root, 'i', ['200-1-a', '200-1-b'])[0]

        self.assertEqual(candidate.label, ['200', '1', 'i'])

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
def build_tree(reg_xml):
    logger.info("Build tree %s", reg_xml)
    preprocess_xml(reg_xml)

    reg_part = get_reg_part(reg_xml)
    title = get_title(reg_xml)

    tree = Node("", [], [reg_part], title)

    part = reg_xml.xpath('//PART')[0]

    # Build a list of SUBPARTs, then pull SUBJGRPs into that list:
    subpart_and_subjgrp_xmls = []
    for subpart in part.xpath('./SUBPART|./SUBJGRP'):
        subpart_and_subjgrp_xmls.append(subpart)
        # SUBJGRPS can be nested, particularly inside SUBPARTs
        for subjgrp in subpart.xpath('./SUBJGRP'):
            subpart_and_subjgrp_xmls.append(subjgrp)

    if len(subpart_and_subjgrp_xmls) > 0:
        subthings = []
        letter_list = []
        for subthing in subpart_and_subjgrp_xmls:
            if subthing.tag == "SUBPART":
                subthings.append(build_subpart(reg_part, subthing))
            elif subthing.tag == "SUBJGRP":
                built_subjgrp = build_subjgrp(reg_part, subthing, letter_list)
                letter_list.append(built_subjgrp.label[-1])
                subthings.append(built_subjgrp)

        tree.children = subthings
    else:
        section_xmls = [c for c in part.getchildren() if c.tag == 'SECTION']
        sections = []
        for section_xml in section_xmls:
            sections.extend(build_from_section(reg_part, section_xml))
        empty_part = reg_text.build_empty_part(reg_part)
        empty_part.children = sections
        tree.children = [empty_part]

    non_reg_sections = build_non_reg_text(reg_xml, reg_part)
    tree.children += non_reg_sections

    return tree

# 需要导入模块: from regparser.tree.struct import Node [as 别名]
# 或者: from regparser.tree.struct.Node import children [as 别名]
    def tree_with_subparts(self):
        nsa = Node("nsa", label=["205", "Subpart", "A"], node_type=Node.SUBPART)

        nsb = Node("nsb", label=["205", "Subpart", "B"], node_type=Node.SUBPART)

        nappa = Node("nappa", label=["205", "Appendix", "C"], node_type=Node.APPENDIX)

        root = Node("", label=["205"])
        root.children = [nsa, nsb, nappa]
        return root