Add tree_merge for law parsers, significantly outperforming hierarchical_merge (#10202)

### What problem does this PR solve?
Add tree_merge for law parsers, significantly outperforming
hierarchical_merge, solved: #8637
1. Add tree_merge for law parsers, include build_tree and get_tree by
dfs.
2. add Copyright statement for helath_utils
### Type of change

- [x] Documentation Update
- [x] Performance Improvement

rag/nlp/__init__.py

@@ -189,6 +189,13 @@ BULLET_PATTERN = [[
     r"Chapter (I+V?|VI*|XI|IX|X)",
     r"Section [0-9]+",
     r"Article [0-9]+"
+], [
+    r"^#[^#]",
+    r"^##[^#]",
+    r"^###.*",
+    r"^####.*",
+    r"^#####.*",
+    r"^######.*",
 ]
 ]
 
@@ -427,8 +434,58 @@ def not_title(txt):
         return True
     return re.search(r"[,;，。；！!]", txt)
 
+def tree_merge(bull, sections, depth):
+    
+    if not sections or bull < 0:
+        return sections
+    if isinstance(sections[0], type("")):
+        sections = [(s, "") for s in sections]
+    
+    # filter out position information in pdf sections
+    sections = [(t, o) for t, o in sections if
+                t and len(t.split("@")[0].strip()) > 1 and not re.match(r"[0-9]+$", t.split("@")[0].strip())]
+    
+    def get_level(bull, section):
+        text, layout = section
+        text = re.sub(r"\u3000", " ",   text).strip()
+
+        for i, title in enumerate(BULLET_PATTERN[bull]):
+            if re.match(title, text.strip()):
+                return i+1, text
+        else:
+            if re.search(r"(title|head)", layout) and not not_title(text):
+                return len(BULLET_PATTERN[bull])+1, text
+            else:
+                return len(BULLET_PATTERN[bull])+2, text
+    
+    level_set = set()
+    lines = []
+    for section in sections:
+        level, text = get_level(bull, section)
+
+        if not text.strip("\n"):
+            continue
+            
+        lines.append((level, text))
+        level_set.add(level)
+
+    sorted_levels = sorted(list(level_set))
+
+    if depth <= len(sorted_levels):
+        target_level = sorted_levels[depth - 1]
+    else:
+        target_level = sorted_levels[-1]
+
+    if target_level == len(BULLET_PATTERN[bull]) + 2:
+        target_level = sorted_levels[-2] if len(sorted_levels) > 1 else sorted_levels[0]
+
+    root = Node(level=0, depth=target_level, texts=[])
+    root.build_tree(lines)
+
+    return [("\n").join(element) for element in root.get_tree() if element]
 
 def hierarchical_merge(bull, sections, depth):
+
     if not sections or bull < 0:
         return []
     if isinstance(sections[0], type("")):
@@ -628,7 +685,7 @@ def docx_question_level(p, bull=-1):
         for j, title in enumerate(BULLET_PATTERN[bull]):
             if re.match(title, txt):
                 return j + 1, txt
-    return len(BULLET_PATTERN[bull]), txt
+    return len(BULLET_PATTERN[bull])+1, txt
 
 
 def concat_img(img1, img2):
@@ -731,3 +788,68 @@ def get_delimiters(delimiters: str):
     dels_pattern = "|".join(dels)
 
     return dels_pattern
+
+class Node:
+    def __init__(self, level, depth=-1, texts=None):
+        self.level = level
+        self.depth = depth
+        self.texts = texts if texts is not None else []  # 存放内容
+        self.children = []  # 子节点
+
+    def add_child(self, child_node):
+        self.children.append(child_node)
+
+    def get_children(self):
+        return self.children
+
+    def get_level(self):
+        return self.level
+
+    def get_texts(self):
+        return self.texts
+
+    def set_texts(self, texts):
+        self.texts = texts
+
+    def add_text(self, text):
+        self.texts.append(text)
+
+    def clear_text(self):
+        self.texts = []
+
+    def __repr__(self):
+        return f"Node(level={self.level}, texts={self.texts}, children={len(self.children)})"
+
+    def build_tree(self, lines):
+        stack = [self]  
+        for line in lines:
+            level, text = line
+            node = Node(level=level, texts=[text])
+
+            if level <= self.depth or self.depth == -1:
+                while stack and level <= stack[-1].get_level():
+                    stack.pop()
+
+                stack[-1].add_child(node)
+                stack.append(node)
+            else:
+                stack[-1].add_text(text)
+        return self  
+
+    def get_tree(self):
+        tree_list = []  
+        self._dfs(self, tree_list, 0, [])
+        return tree_list
+
+    def _dfs(self, node, tree_list, current_depth, titles):
+
+        if node.get_texts():
+            if 0 < node.get_level() < self.depth:
+                titles.extend(node.get_texts())
+            else:
+                combined_text = ["\n".join(titles + node.get_texts())]
+                tree_list.append(combined_text)
+
+
+        for child in node.get_children():
+            self._dfs(child, tree_list, current_depth + 1, titles.copy())