re-common 10.0.39__py3-none-any.whl → 10.0.41__py3-none-any.whl

re_common/v2/baselibrary/tools/tree_processor/builder.py

@@ -0,0 +1,25 @@
+from re_common.v2.baselibrary.tools.tree_processor.node import TreeNode
+
+
+def build_forest(node_list):
+    nodes = {}  # cid -> TreeNode
+    has_parent = set()
+
+    # 第一步：创建所有节点
+    for cid, pid, count in node_list:
+        node = TreeNode(cid, count)
+        nodes[cid] = node
+        if pid is not None:
+            has_parent.add(cid)
+
+    # 第二步：连接 parent-child
+    for cid, pid, _ in node_list:
+        if pid is not None and pid in nodes:
+            parent = nodes[pid]
+            child = nodes[cid]
+            parent.children.append(child)
+            child.parent = parent
+
+    # 第三步：找所有根节点（即没有 parent 的）
+    roots = [node for cid, node in nodes.items() if node.parent is None]
+    return roots  # 返回多棵树的根节点列表

re_common/v2/baselibrary/tools/tree_processor/node.py

@@ -0,0 +1,13 @@
+class TreeNode:
+    def __init__(self, cid, count):
+        self.id = cid
+        self.count = count
+        self.children = []
+        self.parent = None
+
+    def add_child(self, child):
+        self.children.append(child)
+        child.parent = self
+
+    def is_leaf(self):
+        return len(self.children) == 0

re_common/v2/baselibrary/tools/unionfind_tools.py

@@ -1,60 +1,60 @@
-"""
-并查集（Union-Find）是一种用于管理元素分组的数据结构，主要用于解决动态连通性问题。它支持以下两种核心操作：
-
-查找（Find）：确定某个元素属于哪个集合。
-
-合并（Union）：将两个集合合并为一个集合。
-
-并查集广泛应用于图论、网络连接、社交网络分析、图像处理等领域。
-"""
-
-
-class UnionFind:
-    def __init__(self):
-        """
-        初始化并查集。
-        使用字典动态存储 parent 和 rank。
-        """
-        self.parent = {}  # 存储每个元素的父节点，用于表示集合的树结构
-        self.rank = {}  # 存储每个集合的秩（树的高度），用于优化合并操作
-
-    def find(self, x):
-        """
-        查找元素 x 的根节点（路径压缩优化）。
-        如果元素不存在，则动态添加。
-        """
-        if x not in self.parent:  # 如果元素 x 不在 parent 字典中
-            self.parent[x] = x  # 将 x 的父节点设置为自己（初始化）
-            self.rank[x] = 1  # 将 x 的秩初始化为 1
-        if self.parent[x] != x:  # 如果 x 不是根节点（路径压缩优化）
-            self.parent[x] = self.find(self.parent[x])  # 递归查找根节点，并更新 x 的父节点
-        return self.parent[x]  # 返回 x 的根节点
-
-    def union(self, x, y):
-        """
-        合并元素 x 和 y 所在的集合（按秩合并优化）。
-        如果元素不存在，则动态添加。
-        """
-        root_x = self.find(x)  # 找到 x 的根节点
-        root_y = self.find(y)  # 找到 y 的根节点
-        if root_x != root_y:  # 如果 x 和 y 不在同一个集合中
-            # 按秩合并
-            if self.rank[root_x] > self.rank[root_y]:  # 如果 x 所在集合的秩更大
-                self.parent[root_y] = root_x  # 将 y 的根节点指向 x 的根节点
-            elif self.rank[root_x] < self.rank[root_y]:  # 如果 y 所在集合的秩更大
-                self.parent[root_x] = root_y  # 将 x 的根节点指向 y 的根节点
-            else:  # 如果两个集合的秩相等
-                self.parent[root_y] = root_x  # 将 y 的根节点指向 x 的根节点
-                self.rank[root_x] += 1  # 增加 x 所在集合的秩
-
-    def get_groups(self):
-        """
-        获取所有分组，返回一个字典，键为根节点，值为该组的所有元素。
-        """
-        groups = {}  # 初始化一个空字典，用于存储分组
-        for x in self.parent:  # 遍历所有元素
-            root = self.find(x)  # 找到当前元素的根节点
-            if root not in groups:  # 如果根节点不在 groups 字典中
-                groups[root] = []  # 初始化一个空列表
-            groups[root].append(x)  # 将当前元素添加到对应根节点的列表中
-        return groups  # 返回分组结果
+"""
+并查集（Union-Find）是一种用于管理元素分组的数据结构，主要用于解决动态连通性问题。它支持以下两种核心操作：
+
+查找（Find）：确定某个元素属于哪个集合。
+
+合并（Union）：将两个集合合并为一个集合。
+
+并查集广泛应用于图论、网络连接、社交网络分析、图像处理等领域。
+"""
+
+
+class UnionFind:
+    def __init__(self):
+        """
+        初始化并查集。
+        使用字典动态存储 parent 和 rank。
+        """
+        self.parent = {}  # 存储每个元素的父节点，用于表示集合的树结构
+        self.rank = {}  # 存储每个集合的秩（树的高度），用于优化合并操作
+
+    def find(self, x):
+        """
+        查找元素 x 的根节点（路径压缩优化）。
+        如果元素不存在，则动态添加。
+        """
+        if x not in self.parent:  # 如果元素 x 不在 parent 字典中
+            self.parent[x] = x  # 将 x 的父节点设置为自己（初始化）
+            self.rank[x] = 1  # 将 x 的秩初始化为 1
+        if self.parent[x] != x:  # 如果 x 不是根节点（路径压缩优化）
+            self.parent[x] = self.find(self.parent[x])  # 递归查找根节点，并更新 x 的父节点
+        return self.parent[x]  # 返回 x 的根节点
+
+    def union(self, x, y):
+        """
+        合并元素 x 和 y 所在的集合（按秩合并优化）。
+        如果元素不存在，则动态添加。
+        """
+        root_x = self.find(x)  # 找到 x 的根节点
+        root_y = self.find(y)  # 找到 y 的根节点
+        if root_x != root_y:  # 如果 x 和 y 不在同一个集合中
+            # 按秩合并
+            if self.rank[root_x] > self.rank[root_y]:  # 如果 x 所在集合的秩更大
+                self.parent[root_y] = root_x  # 将 y 的根节点指向 x 的根节点
+            elif self.rank[root_x] < self.rank[root_y]:  # 如果 y 所在集合的秩更大
+                self.parent[root_x] = root_y  # 将 x 的根节点指向 y 的根节点
+            else:  # 如果两个集合的秩相等
+                self.parent[root_y] = root_x  # 将 y 的根节点指向 x 的根节点
+                self.rank[root_x] += 1  # 增加 x 所在集合的秩
+
+    def get_groups(self):
+        """
+        获取所有分组，返回一个字典，键为根节点，值为该组的所有元素。
+        """
+        groups = {}  # 初始化一个空字典，用于存储分组
+        for x in self.parent:  # 遍历所有元素
+            root = self.find(x)  # 找到当前元素的根节点
+            if root not in groups:  # 如果根节点不在 groups 字典中
+                groups[root] = []  # 初始化一个空列表
+            groups[root].append(x)  # 将当前元素添加到对应根节点的列表中
+        return groups  # 返回分组结果

re_common/v2/baselibrary/utils/BusinessStringUtil.py

@@ -1,196 +1,196 @@
-# 某些业务中的字符串处理 算是特定场景的工具 不算通用工具
-import re
-
-from re_common.v2.baselibrary.utils.string_bool import is_all_symbols
-
-
-def clean_organ_postcode(organ):
-    """
-    格式化组织名称字符串，移除括号内容并删除独立的6位数字（邮政编码），然后清理标点。
-
-    备注: 该方法替换java 里面的 formatOrgan
-
-    参数:
-        organ (str): 输入的组织名称字符串，可能包含括号、分号和邮政编码。
-
-    返回:
-        str: 格式化并清理后的组织名称字符串（无独立6位数字）。
-    """
-    # 如果输入为空，设为空字符串以避免后续操作报错
-    if not organ:
-        organ = ""
-
-    # 删除方括号和圆括号中的内容（包括括号本身）
-    organ = re.sub(r"\[.*?\]", "", organ)  # 非贪婪匹配方括号内容
-    organ = re.sub(r"\(.*?\)", "", organ)  # 非贪婪匹配圆括号内容
-
-    # 定义正则表达式，匹配独立的6位数字
-    # \b 表示单词边界，确保6位数字是独立的（前后不是字母、数字或下划线）
-    organ = re.sub(r"\b[0-9]{6}\b", "", organ)
-
-    # 初始化结果列表，用于存储处理后的组织名称部分
-    format_organ = []
-    # 按分号分割字符串，生成组织名称的各个部分
-    organ_parts = organ.split(";")
-
-    # 遍历每个部分，追加到结果列表
-    for temp_organ in organ_parts:
-        # 去除首尾多余空格后追加（避免因移除邮编导致的空字符串）
-        cleaned_part = temp_organ.strip()
-        # 如果首尾是标点符号，则移除
-        # 定义标点符号的正则表达式（这里包括常见标点）
-        punctuation = r"^[!,.?;:#$%^&*+-]+|[!,.?;:#$%^&*+-]+$"
-        cleaned_part = re.sub(punctuation, "", cleaned_part)
-        if cleaned_part:  # 只追加非空部分
-            format_organ.append(cleaned_part)
-
-    # 用分号连接结果，转换为大写并清理标点
-    format_organ = ";".join(format_organ)
-
-    # 返回最终结果并去除首尾空格
-    return format_organ.strip()
-
-
-def get_first_organ(organ):
-    if not organ:
-        return ""
-    organ_list = organ.strip().split(";")
-    for organ_one in organ_list:
-        # 清理邮政编码
-        organ_one = clean_organ_postcode(organ_one)
-        if organ_one.strip():
-            return organ_one
-
-    return ""
-
-
-def get_first_author(author: str) -> str:
-    if not author:
-        return ""
-    au_list = author.strip().split(";")
-    for au in au_list:
-        au = re.sub("\\[.*?]", "", au)
-        au = re.sub("\\(.*?\\)", "", au)
-        if au.strip():
-            return au
-    return ""
-
-
-def get_author_list(author: str):
-    lists = []
-    if not author:
-        return []
-    au_list = author.strip().split(";")
-    for au in au_list:
-        au = re.sub("\\[.*?]", "", au)
-        au = re.sub("\\(.*?\\)", "", au)
-        if au.strip():
-            lists.append(au.strip())
-    return lists
-
-
-def get_scopus_author_abbr(author_row: str):
-    if not author_row:
-        return ""
-    author_list = author_row.split("&&")
-    if len(author_list) != 3:
-        raise Exception("错误的数据个数 可能来自其他数据源")
-
-    abbr_list = author_list[0].strip().split(";")
-    abbr_list = [author.strip() for author in abbr_list if
-                 author.strip() and author.strip().lower() not in ("*", "and")]
-    return ";".join(abbr_list)
-
-
-def get_wos_author_abbr(author_row: str):
-    if not author_row:
-        return ""
-    author_list = author_row.split("&&")
-    if len(author_list) != 4:
-        raise Exception("错误的数据个数 可能来自其他数据源")
-    abbr_list = []
-    abbr_list_au = author_list[0].strip().split(";")
-    abbr_list_ba = author_list[2].strip().split(";")
-    abbr_list.extend(abbr_list_au)
-    abbr_list.extend(abbr_list_ba)
-    abbr_list = [author.strip() for author in abbr_list if
-                 author.strip() and author.strip().lower() not in ("*", "and")]
-    return ";".join(abbr_list)
-
-
-def deal_rel_vol(vol_str: str):
-    """
-    处理 期刊融合时的卷处理逻辑
-    """
-
-    # 如果卷是全符号 清理掉
-    if is_all_symbols(vol_str):
-        vol_str = ""
-
-    if vol_str.replace(".", "").isdigit():
-        try:
-            float_num = float(vol_str)
-            if int(float_num) == float_num:
-                return str(int(float_num))
-        except:
-            pass
-
-    if vol_str.lower().startswith("v "):
-        vol_str = vol_str.lower().replace("v ", "").strip()
-        return vol_str
-    if vol_str.lower().startswith("volume "):
-        vol_str = vol_str.lower().replace("volume ", "").strip()
-        return vol_str
-    if vol_str.lower().startswith("vol. "):
-        vol_str = vol_str.lower().replace("vol. ", "").strip()
-        return vol_str
-    if vol_str.lower().startswith("vol "):
-        vol_str = vol_str.lower().replace("vol ", "").strip()
-        return vol_str
-    return vol_str
-
-
-def deal_num_strs(input_str):
-    """
-    int后在str 防止有浮点型的表达方式
-    """
-    number_list = re.findall(r'\d+', input_str)
-    transformed_numbers = [str(int(num)) for num in number_list]
-
-    # 替换原字符串中的数字为转换后的数字
-    for num, transformed_num in zip(number_list, transformed_numbers):
-        input_str = input_str.replace(num, transformed_num)
-    return input_str
-
-
-def deal_num(num_str):
-    """
-    将 期格式化 方便 group尤其是有横杆的数据
-    该方法 为融合二次分割时使用，如果场景合适也可以用于其他地方
-    :param strs:
-    :return:
-    """
-    # 如果期是全符号清理掉
-    if is_all_symbols(num_str):
-        num_str = ""
-
-    if num_str.lower().startswith("n "):
-        num_str = num_str.lower().replace("n ", "").strip()
-
-    num_str = num_str.lower().replace("special_issue_", '').replace("_special_issue", '').replace("issue", "")
-    num_str = num_str.replace("spec.", "").replace("iss.", "").replace("spl.", "").replace("special.", "").replace(
-        "specialissue.", "")
-    num_str = num_str.replace("spec", "").replace("iss", "").replace("spl", "").replace("special", "").replace(
-        "specialissue", '')
-
-    num_str = num_str.replace("-", "_").replace(".", "_").upper()
-    num_str = num_str.lstrip("_").rstrip("_")
-    if num_str.find("_") > -1:
-        start, end = num_str.split("_")
-        start = deal_num_strs(start)
-        end = deal_num_strs(end)
-        num_str = start + "_" + end
-    else:
-        num_str = deal_num_strs(num_str)
-
-    return num_str.lower().strip()
+# 某些业务中的字符串处理 算是特定场景的工具 不算通用工具
+import re
+
+from re_common.v2.baselibrary.utils.string_bool import is_all_symbols
+
+
+def clean_organ_postcode(organ):
+    """
+    格式化组织名称字符串，移除括号内容并删除独立的6位数字（邮政编码），然后清理标点。
+
+    备注: 该方法替换java 里面的 formatOrgan
+
+    参数:
+        organ (str): 输入的组织名称字符串，可能包含括号、分号和邮政编码。
+
+    返回:
+        str: 格式化并清理后的组织名称字符串（无独立6位数字）。
+    """
+    # 如果输入为空，设为空字符串以避免后续操作报错
+    if not organ:
+        organ = ""
+
+    # 删除方括号和圆括号中的内容（包括括号本身）
+    organ = re.sub(r"\[.*?\]", "", organ)  # 非贪婪匹配方括号内容
+    organ = re.sub(r"\(.*?\)", "", organ)  # 非贪婪匹配圆括号内容
+
+    # 定义正则表达式，匹配独立的6位数字
+    # \b 表示单词边界，确保6位数字是独立的（前后不是字母、数字或下划线）
+    organ = re.sub(r"\b[0-9]{6}\b", "", organ)
+
+    # 初始化结果列表，用于存储处理后的组织名称部分
+    format_organ = []
+    # 按分号分割字符串，生成组织名称的各个部分
+    organ_parts = organ.split(";")
+
+    # 遍历每个部分，追加到结果列表
+    for temp_organ in organ_parts:
+        # 去除首尾多余空格后追加（避免因移除邮编导致的空字符串）
+        cleaned_part = temp_organ.strip()
+        # 如果首尾是标点符号，则移除
+        # 定义标点符号的正则表达式（这里包括常见标点）
+        punctuation = r"^[!,.?;:#$%^&*+-]+|[!,.?;:#$%^&*+-]+$"
+        cleaned_part = re.sub(punctuation, "", cleaned_part)
+        if cleaned_part:  # 只追加非空部分
+            format_organ.append(cleaned_part)
+
+    # 用分号连接结果，转换为大写并清理标点
+    format_organ = ";".join(format_organ)
+
+    # 返回最终结果并去除首尾空格
+    return format_organ.strip()
+
+
+def get_first_organ(organ):
+    if not organ:
+        return ""
+    organ_list = organ.strip().split(";")
+    for organ_one in organ_list:
+        # 清理邮政编码
+        organ_one = clean_organ_postcode(organ_one)
+        if organ_one.strip():
+            return organ_one
+
+    return ""
+
+
+def get_first_author(author: str) -> str:
+    if not author:
+        return ""
+    au_list = author.strip().split(";")
+    for au in au_list:
+        au = re.sub("\\[.*?]", "", au)
+        au = re.sub("\\(.*?\\)", "", au)
+        if au.strip():
+            return au
+    return ""
+
+
+def get_author_list(author: str):
+    lists = []
+    if not author:
+        return []
+    au_list = author.strip().split(";")
+    for au in au_list:
+        au = re.sub("\\[.*?]", "", au)
+        au = re.sub("\\(.*?\\)", "", au)
+        if au.strip():
+            lists.append(au.strip())
+    return lists
+
+
+def get_scopus_author_abbr(author_row: str):
+    if not author_row:
+        return ""
+    author_list = author_row.split("&&")
+    if len(author_list) != 3:
+        raise Exception("错误的数据个数 可能来自其他数据源")
+
+    abbr_list = author_list[0].strip().split(";")
+    abbr_list = [author.strip() for author in abbr_list if
+                 author.strip() and author.strip().lower() not in ("*", "and")]
+    return ";".join(abbr_list)
+
+
+def get_wos_author_abbr(author_row: str):
+    if not author_row:
+        return ""
+    author_list = author_row.split("&&")
+    if len(author_list) != 4:
+        raise Exception("错误的数据个数 可能来自其他数据源")
+    abbr_list = []
+    abbr_list_au = author_list[0].strip().split(";")
+    abbr_list_ba = author_list[2].strip().split(";")
+    abbr_list.extend(abbr_list_au)
+    abbr_list.extend(abbr_list_ba)
+    abbr_list = [author.strip() for author in abbr_list if
+                 author.strip() and author.strip().lower() not in ("*", "and")]
+    return ";".join(abbr_list)
+
+
+def deal_rel_vol(vol_str: str):
+    """
+    处理 期刊融合时的卷处理逻辑
+    """
+
+    # 如果卷是全符号 清理掉
+    if is_all_symbols(vol_str):
+        vol_str = ""
+
+    if vol_str.replace(".", "").isdigit():
+        try:
+            float_num = float(vol_str)
+            if int(float_num) == float_num:
+                return str(int(float_num))
+        except:
+            pass
+
+    if vol_str.lower().startswith("v "):
+        vol_str = vol_str.lower().replace("v ", "").strip()
+        return vol_str
+    if vol_str.lower().startswith("volume "):
+        vol_str = vol_str.lower().replace("volume ", "").strip()
+        return vol_str
+    if vol_str.lower().startswith("vol. "):
+        vol_str = vol_str.lower().replace("vol. ", "").strip()
+        return vol_str
+    if vol_str.lower().startswith("vol "):
+        vol_str = vol_str.lower().replace("vol ", "").strip()
+        return vol_str
+    return vol_str
+
+
+def deal_num_strs(input_str):
+    """
+    int后在str 防止有浮点型的表达方式
+    """
+    number_list = re.findall(r'\d+', input_str)
+    transformed_numbers = [str(int(num)) for num in number_list]
+
+    # 替换原字符串中的数字为转换后的数字
+    for num, transformed_num in zip(number_list, transformed_numbers):
+        input_str = input_str.replace(num, transformed_num)
+    return input_str
+
+
+def deal_num(num_str):
+    """
+    将 期格式化 方便 group尤其是有横杆的数据
+    该方法 为融合二次分割时使用，如果场景合适也可以用于其他地方
+    :param strs:
+    :return:
+    """
+    # 如果期是全符号清理掉
+    if is_all_symbols(num_str):
+        num_str = ""
+
+    if num_str.lower().startswith("n "):
+        num_str = num_str.lower().replace("n ", "").strip()
+
+    num_str = num_str.lower().replace("special_issue_", '').replace("_special_issue", '').replace("issue", "")
+    num_str = num_str.replace("spec.", "").replace("iss.", "").replace("spl.", "").replace("special.", "").replace(
+        "specialissue.", "")
+    num_str = num_str.replace("spec", "").replace("iss", "").replace("spl", "").replace("special", "").replace(
+        "specialissue", '')
+
+    num_str = num_str.replace("-", "_").replace(".", "_").upper()
+    num_str = num_str.lstrip("_").rstrip("_")
+    if num_str.find("_") > -1:
+        start, end = num_str.split("_")
+        start = deal_num_strs(start)
+        end = deal_num_strs(end)
+        num_str = start + "_" + end
+    else:
+        num_str = deal_num_strs(num_str)
+
+    return num_str.lower().strip()