re-common 2.0.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

re_common/v2/baselibrary/tools/search_hash_tools.py

@@ -0,0 +1,33 @@
+from typing import List
+
+import jieba
+from datasketch import MinHash
+
+
+def tokenize(text: str, stopwords=None) -> List[str]:
+    """
+    分词并移除停用词
+    """
+    if stopwords is None:
+        stopwords = []
+    words = jieba.lcut(text)
+    # 统计单字符数据 长度，防止结巴分词分不了的单词 将数据分为单个字符
+    one_char_size = len([i for i in words if len(i) == 1])
+    all_size = len(words)
+    # 如果单字符个数超过一定比例 就直接用空格分词
+    if all_size != 0 and one_char_size / all_size > 0.6:
+        words = [i for i in text.split() if i.strip()]
+
+    # 过滤停用词和空字符
+    words = [w for w in words if w not in stopwords and w.strip()]
+    return words
+
+
+def create_minhash(words: List[str], num_perm=128) -> MinHash:
+    """
+    为分词结果创建 MinHash
+    """
+    minhash = MinHash(num_perm=num_perm)
+    for word in words:
+        minhash.update(word.encode("utf-8"))
+    return minhash

re_common/v2/baselibrary/tools/text_matcher.py

@@ -0,0 +1,223 @@
+import jieba
+import re
+from typing import List, Dict, Tuple, Set, Optional, Union
+from datasketch import MinHash, MinHashLSH
+
+
+class TextMatcher:
+    def __init__(
+            self,
+            threshold: float = 0.5,
+            num_perm: int = 128,
+            is_raw_texts=True,
+            stopwords_path: Optional[str] = None,
+            user_dict_path: Optional[str] = None,
+
+    ):
+        """
+        初始化文本匹配器
+
+        Args:
+            threshold: LSH 相似度阈值
+            num_perm: MinHash 排列数
+            stopwords_path: 停用词文件路径
+            user_dict_path: 用户自定义词典路径
+        """
+        self.threshold = threshold
+        self.num_perm = num_perm
+        self.lsh = MinHashLSH(threshold=threshold, num_perm=num_perm)
+        # self.minhashes: Dict[str, MinHash] = {}
+        self.raw_texts: Dict[str, str] = {}
+        self.is_raw_texts = is_raw_texts
+        self.doc_counter = 0
+
+        # 加载停用词
+        self.stopwords: Set[str] = set()
+        if stopwords_path:
+            self.load_stopwords(stopwords_path)
+
+        # 加载用户词典
+        if user_dict_path:
+            jieba.load_userdict(user_dict_path)
+
+    def load_stopwords(self, stopwords_path: str) -> None:
+        """加载停用词"""
+        with open(stopwords_path, "r", encoding="utf-8") as f:
+            self.stopwords = set(line.strip() for line in f)
+
+    def preprocess_text(self, text: str) -> str:
+        """
+        文本预处理
+        """
+        # 转换为小写
+        text = text.lower()
+        # 移除特殊字符
+        text = re.sub(r"[^\w\s\u4e00-\u9fff]", "", text)
+        # 移除多余空格
+        text = re.sub(r"\s+", " ", text).strip()
+        return text
+
+    def tokenize(self, text: str) -> List[str]:
+        """
+        分词并移除停用词
+        """
+        words = jieba.lcut(text)
+        one_char_size = len([i for i in words if len(i) == 1])
+        all_size = len(words)
+        if all_size != 0 and one_char_size / all_size > 0.6:
+            words = [i for i in text.split() if i.strip()]
+
+        # 过滤停用词和空字符
+        words = [w for w in words if w not in self.stopwords and w.strip()]
+        return words
+
+    def create_minhash(self, words: List[str]) -> MinHash:
+        """
+        为分词结果创建 MinHash
+        """
+        minhash = MinHash(num_perm=self.num_perm)
+        for word in words:
+            minhash.update(word.encode("utf-8"))
+        return minhash
+
+    def add_document(self, text: str, doc_id: Optional[str] = None) -> str:
+        """
+        添加文档到索引
+
+        Args:
+            text: 文档文本
+            doc_id: 文档ID（可选）
+
+        Returns:
+            doc_id: 文档ID
+        """
+        if doc_id is None:
+            doc_id = f"doc_{self.doc_counter}"
+            self.doc_counter += 1
+
+        # 预处理和分词
+        processed_text = self.preprocess_text(text)
+        words = self.tokenize(processed_text)
+
+        # 创建 MinHash
+        minhash = self.create_minhash(words)
+        if self.is_raw_texts:
+            # 存储原始文本和 MinHash
+            self.raw_texts[doc_id] = text
+        # self.minhashes[doc_id] = minhash
+
+        # 添加到 LSH
+        self.lsh.insert(doc_id, minhash)
+
+        return doc_id
+
+    def batch_add_documents(self, texts: Dict[str, str]) -> None:
+        """
+        批量添加文档
+
+        Args:
+            texts: {doc_id: text} 的字典
+        """
+        for doc_id, text in texts.items():
+            self.add_document(text, doc_id)
+
+    def create_query_minhash(self, query: str):
+
+        # 预处理查询文本
+        processed_query = self.preprocess_text(query)
+        query_words = self.tokenize(processed_query)
+        # print(query_words)
+        query_minhash = self.create_minhash(query_words)
+        return query_minhash
+
+    def find_similar(self, query_minhash: MinHash, return_similarities: bool = False) -> Union[
+        List[str], List[Tuple[str, float]]]:
+        """
+        查找相似文档
+
+        Args:
+            query: 查询文本
+            return_similarities: 是否返回相似度分数
+
+        Returns:
+            如果 return_similarities 为 True，返回 [(doc_id, similarity), ...]
+            否则返回 [doc_id, ...]
+        """
+
+        # 使用 LSH 查找候选集
+        similar_docs = self.lsh.query(query_minhash)
+
+        # if return_similarities:
+        #     # 计算精确的 Jaccard 相似度
+        #     results = []
+        #     for doc_id in similar_docs:
+        #         similarity = query_minhash.jaccard(self.minhashes[doc_id])
+        #         results.append((doc_id, similarity))
+        #     # 按相似度降序排序
+        #     return sorted(results, key=lambda x: x[1], reverse=True)
+
+        return similar_docs
+
+    def get_text(self, doc_id: str) -> Optional[str]:
+        """获取原始文本"""
+        if self.is_raw_texts:
+            return self.raw_texts.get(doc_id)
+        raise Exception("没有开启存储")
+
+    def remove_document(self, doc_id: str) -> bool:
+        """
+        删除文档
+
+        Returns:
+            bool: 是否成功删除
+        """
+        # if doc_id not in self.minhashes:
+        #     return False
+
+        self.lsh.remove(doc_id)
+        # del self.minhashes[doc_id]
+        if self.is_raw_texts:
+            del self.raw_texts[doc_id]
+        return True
+
+    def clear(self) -> None:
+        """清空所有数据"""
+        self.lsh = MinHashLSH(threshold=self.threshold, num_perm=self.num_perm)
+        # self.minhashes.clear()
+        self.raw_texts.clear()
+        self.doc_counter = 0
+
+
+if __name__ == "__main__":
+    # 创建匹配器实例
+    matcher = TextMatcher(
+        threshold=0.1,  # 相似度阈值
+        num_perm=128,  # MinHash 排列数
+    )
+
+    # 添加单个文档
+    doc_id = matcher.add_document(
+        "北京是中国的首都"
+    )
+
+    # 批量添加文档
+    docs = {"doc1": "北京是一座现代化的大都市", "doc2": "上海是中国最大的城市", "doc3": "中国的首都是北京"}
+    matcher.batch_add_documents(docs)
+
+    # 查找相似文档（不返回相似度分数）
+    similar_docs = matcher.find_similar("北京首都")
+    print("相似文档ID:", similar_docs)
+
+    # 查找相似文档（返回相似度分数）
+    similar_docs_with_scores = matcher.find_similar("北京首都", return_similarities=True)
+    print("相似文档ID和分数:", similar_docs_with_scores)
+
+    # 获取原始文本
+    for doc_id, score in similar_docs_with_scores:
+        print(f"文档 {doc_id}: {matcher.get_text(doc_id)} (相似度: {score:.2f})")
+
+    # 删除文档
+    matcher.remove_document("doc1")
+
+    # 清空所有数据
+    matcher.clear()

re_common/v2/baselibrary/utils/BusinessStringUtil.py

@@ -49,12 +49,12 @@ def clean_organ_postcode(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:
             return organ_one
@@ -62,7 +62,7 @@ def get_first_organ(organ):
     return ""
 
 
-def get_first_author(author: object) -> object:
+def get_first_author(author: str) -> str:
     if not author:
         return ""
     au_list = author.strip().split(";")

re_common/v2/baselibrary/utils/author_smi.py

@@ -0,0 +1,308 @@
+import re
+import string
+
+import regex
+import unicodedata
+from rapidfuzz._utils import setupPandas, is_none
+from rapidfuzz.distance import Jaro
+
+"""
+作者比率分布 大部分在 1和 2 
+1-2 675092763
+2-3 49335191
+3-4 440848
+4-5 9953
+其他都是几百 几十和几个 不用考虑
+如果 大于5 大降分
+3-4 4-5 分两个段降分 3-4 降得最少
+1-3 不降分
+"""
+
+additional_chars = '‑–‐’·．—'
+extended_punctuation = string.punctuation + additional_chars
+
+
+def get_diacritic_variant(char1):
+    # 将字符转换为标准的 Unicode 形式
+    normalized_char1 = unicodedata.normalize('NFD', char1)
+
+    # 获取基本字符（去掉变音符号）
+    base_char1 = ''.join(c for c in normalized_char1 if unicodedata.category(c) != 'Mn')
+
+    # 判断基本字符是否相同
+    return base_char1
+
+
+def detect_other_languages(text):
+    # 匹配所有非中文、非英文、非数字字符
+    pattern = r'[^\u4E00-\u9FFFa-zA-Z0-9\s.,!?;:\'\"()‑\-–—‐’·˜．]'
+
+    # 使用正则表达式查找
+    matches = re.findall(pattern, text)
+
+    # 如果找到匹配的字符，表示存在非中文、非英文、非数字的语言字符
+    return bool(matches)
+
+
+def extract_initials(text):
+    # 按空格分隔字符串
+    words = text.split()
+
+    # 提取每个单词的首字母并转化为大写
+    initials = ''.join(word[0].upper() for word in words)
+
+    return initials
+
+
+def is_contained(str1, str2):
+    # 判断是否是包含关系
+    return str1 in str2 or str2 in str1
+
+
+# list1 是否包含 list2 如果包含 return True
+def is_contained_list(list1, list2):
+    # 检查 list2 中每个元素的出现次数，是否能在 list1 中找到足够的数量
+    for item in list2:
+        if list2.count(item) > list1.count(item):
+            return False
+    return True
+
+
+def check_common_elements_by_length_rank(list1, list2):
+    # 获取两个列表的交集
+    set1 = set(list1)
+    set2 = set(list2)
+
+    common_elements = set1 & set2  # 获取交集
+
+    if not common_elements:
+        return False
+
+    # 确定较短的列表
+    short_list = list1 if len(list1) < len(list2) else list2
+
+    # 按字符长度排序短列表
+    sorted_short_list = sorted(short_list, key=len)
+
+    for word in common_elements:
+        # 获取该单词在短列表中的字符长度排名
+        length_rank = sorted_short_list.index(word) + 1  # +1 因为列表索引从0开始
+        # 如果单个字母跳过
+        if len(word) == 1:
+            continue
+
+        if length_rank / len(sorted_short_list) > 0.5:
+            # 说明 命中了长字符串相等
+            return True
+
+    return False
+
+
+def remove_punctuation(text):
+    # 20241226 替换掉自定义符号集
+    text = regex.sub("[\\p{P}￥+=˛`$<¸´~^￥≤℃×■¨°>|ⅰⅱⅲⅳⅴⅵⅶⅹⅺⅻ]", "", text.lower())
+    # text = text.translate(str.maketrans('', '', extended_punctuation))
+    return text
+
+
+def space_punctuation(text):
+    # 使用空格替换符号
+    return text.translate(str.maketrans(extended_punctuation, ' ' * len(extended_punctuation), ''))
+
+
+def custom_rstrip(s):
+    # 去除尾部的指定子串，顺序删除
+    s = s.strip()
+    if s.endswith("."):
+        s = s[:-1]  # 删除最后的 "."
+    s = s.strip()
+    if s.endswith("jr"):
+        s = s[:-2]  # 删除最后的 "jr"
+    s = s.strip()
+    if s.endswith(","):
+        s = s[:-1]  # 删除最后的 ","
+    s = s.strip()
+
+    return s
+
+
+def deal_str_first(s1):
+    # 先对数据处理一波
+    s1 = s1.replace("’", "")
+    return s1
+
+
+def AuthorRatio(
+        s1,
+        s2,
+        *,
+        processor=None,
+        score_cutoff=None,
+        is_delete_jr=True,
+):
+    # 判空需要
+    setupPandas()
+    # 如果为空就没有相似度
+    if is_none(s1) or is_none(s2):
+        return 0
+
+    # 处理字符串的程序
+    if processor is not None:
+        s1 = processor(s1)
+        s2 = processor(s2)
+
+        # 处理后是否为空字符串，如果有 返回0
+        if not s1 or not s2:
+            return 0
+
+    s1 = get_diacritic_variant(s1)
+    s2 = get_diacritic_variant(s2)
+    # 这里提出来是为了少计算 但后期需要平衡内存和算力
+    s1_punc = remove_punctuation(s1)
+    s2_punc = remove_punctuation(s2)
+    s1_punc_split = s1_punc.split()
+    s2_punc_split = s2_punc.split()
+
+    def compare_strings(s1_punc, s2_punc):
+        # 去除字符串中的空白字符
+        cleaned_s1 = re.sub(r'\s+', '', s1_punc)
+        cleaned_s2 = re.sub(r'\s+', '', s2_punc)
+
+        # 如果两个字符串相等，返回 相等
+        if cleaned_s1 == cleaned_s2:
+            return "equal"
+        # 如果一个字符串包含另一个字符串，返回 子字符串
+        elif cleaned_s1 in cleaned_s2 or cleaned_s2 in cleaned_s1:
+            return "subset"
+        # 否则返回 无关
+        else:
+            return "unrelated"
+
+    # 如果去除符号后相等 那么就是100% 的相同作者 这里主要防止顺序颠倒的问题
+    if len(s1_punc_split) == len(s2_punc_split) and set(s1_punc_split) == set(s2_punc_split):
+        return 1
+
+    # 如果少一个单词，认为是正确的包含关系，在简写中会出现这种情况
+    if is_contained_list(s1_punc_split, s2_punc_split) or is_contained_list(s2_punc_split, s1_punc_split):
+        return 0.98
+
+    rus = compare_strings(s1_punc, s2_punc)
+    # 如果顺序去字符 去空格完全相等 那么作者相同 “Hoorani, H. R.” -> 'Hoorani, HR'
+    if rus == "equal":
+        return 1
+
+    # 在外文中 jr 代表儿子 我现在需要去掉这个字符带来的影响,可以用参数控制
+    if is_delete_jr:
+        s1_n = custom_rstrip(s1.lower())
+        s1 = s1[:len(s1_n)]
+        s2_n = custom_rstrip(s2.lower())
+        s2 = s2[:len(s2_n)]
+
+    # 这里正向是为了解决 Liao, Zhan -> Liao Z. 这样的关系 但是反向会导致上面的错误存在
+    if len(s1_punc_split) == len(s2_punc_split) and rus == "subset":
+        if len(s1_punc_split[-1]) == 1 or len(s2_punc_split[-1]) == 1:
+            if s1_punc_split[0] == s2_punc_split[0] and s1_punc_split[-1][:1] == s2_punc_split[-1][:1]:
+                return 1
+        # return 0.96   # 如果单词数一致 是包含关系 但会出现这样的 Li Li 和 Li Liang 会被判定为一样 所以这里不给满分
+
+    # 使用正则表达式替换多个空格为一个空格
+    l1 = re.sub(r'\s+', ' ', space_punctuation(s1.replace("'", "")).strip()).strip().split()
+    l2 = re.sub(r'\s+', ' ', space_punctuation(s2.replace("'", "")).strip()).strip().split()
+
+    def is_same_or_initials_match(l1, l2):
+        """
+        判断两个字符串是否完全相同，或者它们的首字母是否相同。
+        bool: 如果两个字符串完全相同，或它们的首字母匹配，返回 True；否则返回 False。
+        """
+
+        # 使用 zip() 同时遍历 l1 和 l2 中的字符
+        for i1, i2 in zip(l1, l2):
+            # 如果两个字符忽略大小写后相同，继续比较下一个字符
+            if i1.lower() == i2.lower():
+                continue
+
+            # 如果其中一个字符的长度为1（即是单个字母），检查它们的首字母是否匹配
+            if len(i1) == 1 or len(i2) == 1:
+                # 比较它们的首字母（不区分大小写）
+                if i1[0].upper() == i2[0].upper():
+                    continue
+                else:
+                    return False  # 如果首字母不同，则返回 False
+
+            # 如果上面条件都不满足，说明字符不匹配，直接返回 False
+            return False
+
+        # 如果循环结束都没有提前返回 False，则表示两个字符串完全匹配，返回 True
+        return True
+
+    if len(l1[-1]) != 1 and l1[-1].isupper():
+        t_str = l1[-1]
+        l1 = l1[:-1]
+        l1.extend(list(t_str))
+    if len(l2[-1]) != 1 and l2[-1].isupper():
+        t_str = l2[-1]
+        l2 = l2[:-1]
+        l2.extend(list(t_str))
+
+    # 如果长度相等 简写也是单词的首字母 那么两个名字一致 举例:"María M.Martorell", "Martorell, María M."
+    if len(l1) == len(l2) and (is_same_or_initials_match(l1, l2) or set(l1) == set(l2)):
+        return 1
+
+    ##############################################################
+    # 以上为情况穷举情况，以下为其他情况的相似率计算
+    ##############################################################
+
+    # 设置score_cutoff 默认值为0
+    if score_cutoff is None:
+        score_cutoff = 0
+
+    len1 = len(s1)
+    len2 = len(s2)
+    # 用长字符串除以 短字符串 得到字符串长度的比率
+    len_ratio = len1 / len2 if len1 > len2 else len2 / len1
+
+    # 计算归一化的 Indel 相似度。 对于比率<score_cutoff，返回0。
+    end_ratio = normal_end_ratio = Jaro.normalized_similarity(s1, s2)
+
+    # 需要对作者的比率分布进行调研决定哪些是小比率哪些是大比率
+    if len_ratio > 1.5 and len_ratio < 3:
+        # 计算线性下降的减分比例
+        # 当 len_ratio = 1.5 时，reduction_factor = 1.0
+        # 当 len_ratio = 3.0 时，reduction_factor = 0.9
+        reduction_factor = 1.0 - (len_ratio - 1.5) * (0.1 / 1.5)
+        end_ratio = end_ratio * reduction_factor
+    if len_ratio > 3 and len_ratio < 4:  # 应该少量降分
+        end_ratio = end_ratio * 0.9
+    if len_ratio > 4 and len_ratio < 5:  # 应该中量降分
+        end_ratio = end_ratio * 0.8
+    if len_ratio > 5:  # 应该降分
+        end_ratio = end_ratio * 0.7
+
+    # 变音提分已经在上面解决了
+    # # 非英语 非汉语提分 与 英文对比时 提分
+    # if any([detect_other_languages(s1), detect_other_languages(s2)]) and not all([detect_other_languages(s1),
+    #                                                                               detect_other_languages(s2)]):
+    #     # 应该提分
+    #     end_ratio = end_ratio * 1.1
+
+    # 首字母相同提分
+    # if is_contained(extract_initials(s1), extract_initials(s2)):
+    if is_contained_list([i[:1] for i in l1], [i[:1] for i in l2]):
+        # 应该提分
+        end_ratio = end_ratio * 1.05
+    else:
+        end_ratio = end_ratio * 0.9
+
+    if len(l1) != len(l2):
+        end_ratio = end_ratio * 0.92
+
+    # 相同部分在短的数据的词中的长度位置 如果是简写相同 不应该提分
+    if check_common_elements_by_length_rank(l1, l2) and len_ratio > 1.5:
+        # 应该提分
+        end_ratio = end_ratio * 1.1
+
+    if l1[0] != l2[0]:
+        end_ratio = end_ratio * Jaro.normalized_similarity(l1[0], l2[0])
+
+    # 如果字符串本身的相似度高 应该拉上去 否者应该拉下来
+    return min(end_ratio, 1) * 0.5 + normal_end_ratio * 0.5

re_common/v2/baselibrary/utils/string_clear.py

@@ -14,6 +14,10 @@ class StringClear(object):
             self.obj_str = ''
         return self
 
+    def to_str(self):
+        self.obj_str = str(self.obj_str)
+        return self
+
     def qj_to_bj(self):
         # 全角变半角
         self.obj_str = qj2bj(self.obj_str)
@@ -22,6 +26,7 @@ class StringClear(object):
     def bj_to_qj(self):
         # 半角变全角
         self.obj_str = bj2qj(self.obj_str)
+        return self
 
     def lower(self):
         self.obj_str = self.obj_str.lower()
@@ -64,6 +69,7 @@ class StringClear(object):
     def remove_diacritics(self):
         # 去除音标 转换成字母
         self.obj_str = get_diacritic_variant(self.obj_str)
+        return self
 
     def remove_brackets(self):
         # 移除 方括号里面的内容
@@ -81,4 +87,12 @@ class StringClear(object):
 
 def rel_clear(str_obj):
     # 为融合数据定制的 清理规则
-    return StringClear(str_obj).qj_to_bj().remove_special_chars().collapse_spaces().lower().get_str()
+    return (StringClear(str_obj)
+            .None_to_str()  # 空对象转str 防止空对象
+            .to_str()  # 防止其他类型传入
+            .qj_to_bj()  # 全角转半角
+            .remove_special_chars()  # 移除特殊字符，仅保留字母、数字、空格和汉字 \w 已经包括所有 Unicode 字母 下划线 _ 会被保留
+            .collapse_spaces()  # 移除多余空格,连续多个空格变一个
+            .lower()  # 小写
+            .get_str()  # 获取str
+            .strip())  # 去掉空格

re_common/v2/baselibrary/utils/stringutils.py

@@ -1,3 +1,6 @@
+import re
+
+import regex
 import unicodedata
 
 
@@ -57,4 +60,36 @@ def get_diacritic_variant(char1):
     base_char1 = ''.join(c for c in normalized_char1 if unicodedata.category(c) != 'Mn')
 
     # 判断基本字符是否相同
-    return base_char1
+    return base_char1
+
+def get_alphabetic_ratio(text: str) -> float:
+    if not text:
+        return 0
+
+    text = re.sub(r'\d+', '', text)
+
+    # 正则表达式匹配字母型文字（包括拉丁字母、希腊字母、西里尔字母、阿拉伯字母等）
+    alphabetic_pattern = (
+        r"[\u0041-\u005A\u0061-\u007A"  # 拉丁字母 (A-Z, a-z)
+        r"\u00C0-\u00FF"  # 带重音符号的拉丁字母 (À-ÿ)
+        r"\u0080–\u00FF"  # 拉丁字母补充1
+        r"\u0100–\u017F"  # 拉丁字母扩展A
+        r"\u1E00-\u1EFF"  # 拉丁扩展 (Latin Extended Additional)
+        r"\u0180-\u024F"  # 拉丁扩展-B (Latin Extended-B)
+        r"\u2C60-\u2C7F"  # 拉丁扩展-C (Latin Extended Additional)
+        r"\uA720-\uA7FF"  # 拉丁扩展-D (Latin Extended Additional)
+        r"\uAB30-\uAB6F"  # 拉丁扩展-E (Latin Extended Additional)
+        r"]"
+    )
+
+    # 使用正则表达式过滤出语言文字
+    clean_text = regex.sub(r"[^\p{L}]", "", text)
+
+    if len(clean_text) == 0:
+        return 1.0
+
+    # 匹配所有字母型字符
+    alphabetic_chars = re.findall(alphabetic_pattern, clean_text)
+
+    # 返回字母型字符所占比例
+    return len(alphabetic_chars) / len(clean_text)

{re_common-2.0.0.dist-info → re_common-10.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: re_common
-Version: 2.0.0
+Version: 10.0.0
 Summary: a library about all python projects
 Home-page: https://gitee.com/xujiangios/re-common
 Author: vic

{re_common-2.0.0.dist-info → re_common-10.0.0.dist-info}/RECORD

@@ -167,15 +167,19 @@ re_common/v2/baselibrary/s3object/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 re_common/v2/baselibrary/s3object/baseboto3.py,sha256=mXuIFx99pnrPGQ4LJCZwlN1HLbaU-OWLwck0cVzW6hc,11203
 re_common/v2/baselibrary/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 re_common/v2/baselibrary/tools/dict_tools.py,sha256=HW-YZOUhv5GMzFsF-ArLfDoszui1K3_M7IiRIe4VEXA,909
+re_common/v2/baselibrary/tools/list_tools.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+re_common/v2/baselibrary/tools/search_hash_tools.py,sha256=o-PNjmcYDkfyiR75Jci_9sSn4cGi_F9jPCIrwYdnb1U,1013
+re_common/v2/baselibrary/tools/text_matcher.py,sha256=F4WtLO-b7H6V9TIvOntCD9ZXSQP_KijPuLLYcLPtrKQ,7021
 re_common/v2/baselibrary/tools/unionfind_tools.py,sha256=VYHZZPXwBYljsm7TjV1B6iCgDn3O3btzNf9hMvQySVU,2965
-re_common/v2/baselibrary/utils/BusinessStringUtil.py,sha256=HxW2aCFyKIu_hKOrTxtMpRCIo5x-jmVJrxmAJqW-Clk,2622
+re_common/v2/baselibrary/utils/BusinessStringUtil.py,sha256=dxrWO800wElZM_4aKolUHSPBYZlxqzXukE4M-LZ13jA,2644
 re_common/v2/baselibrary/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+re_common/v2/baselibrary/utils/author_smi.py,sha256=_P3I5JXvxHqNNWUwhAyHiJuBFiC0tXvGD8-_HxNiuEU,11051
 re_common/v2/baselibrary/utils/basedict.py,sha256=tSV85pARe8ZQDY77_h_heS81EWwcgJW076DcA9WQyjY,1161
 re_common/v2/baselibrary/utils/basehdfs.py,sha256=NVV5Q0OMPlM_zTrs9ZDoPJv29GQv5wi9-AP1us5dBrQ,4651
 re_common/v2/baselibrary/utils/json_cls.py,sha256=dHOkWafG9lbQDoub9cbDwT2fDjMKtblQnjFLeA4hECA,286
 re_common/v2/baselibrary/utils/string_bool.py,sha256=f5qYdKvTufxmfSsxXN41WFLV--vCwDWU2LeQPbDvKZY,178
-re_common/v2/baselibrary/utils/string_clear.py,sha256=YnDv4f5zMOuXNxWR3uMwuQlT3CcFoGBBrYisLR-3p60,2669
-re_common/v2/baselibrary/utils/stringutils.py,sha256=_UYtntEUJAFUXk6hkl1k_CleJwU0ssk39wY9zD6wdok,1394
+re_common/v2/baselibrary/utils/string_clear.py,sha256=LqGvv-UZnsVwiDBN3-PdzDUTfWlAsKsvKlkXqySI0eE,3244
+re_common/v2/baselibrary/utils/stringutils.py,sha256=lhDvRL60S6gjhU4D0nfk2Y-c25IyYdYOD0TMoCx-huE,2658
 re_common/vip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 re_common/vip/base_step_process.py,sha256=VXXiNj0I5CpzXIMCgOPU86bzDJkSBkUS-9CpZIl_GOk,205
 re_common/vip/baseencodeid.py,sha256=nERoe89ueFM52bG7xwJdflcZHk6T2RQQKbc5uUZc3RM,3272
@@ -202,8 +206,8 @@ re_common/vip/title/transform/TransformRegulationTitleToZt.py,sha256=LKRdIsWKues
 re_common/vip/title/transform/TransformStandardTitleToZt.py,sha256=-fCKAbSBzXVyQDCE61CalvR9E_QzQMA08QOO_NePFNI,5563
 re_common/vip/title/transform/TransformThesisTitleToZt.py,sha256=QS-uV0cQrpUFAcKucuJQ9Ue2VRQH-inmfn_X3IplfRo,5488
 re_common/vip/title/transform/__init__.py,sha256=m83-CWyRq_VHPYHaALEQlmXrkTdrZ3e4B_kCfBYE-uc,239
-re_common-2.0.0.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-re_common-2.0.0.dist-info/METADATA,sha256=pGdA5Wa4mN6r__SLPmqXm5HKnw4gW3tICtObKZPdaUI,580
-re_common-2.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-re_common-2.0.0.dist-info/top_level.txt,sha256=_H9H23zoLIalm1AIY_KYTVh_H0ZnmjxQIxsvXtLv45o,10
-re_common-2.0.0.dist-info/RECORD,,
+re_common-10.0.0.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+re_common-10.0.0.dist-info/METADATA,sha256=C8xtx6EWq_g7ScVYYKNZRwq7IuZ_z2esfPwhztPshE0,581
+re_common-10.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+re_common-10.0.0.dist-info/top_level.txt,sha256=_H9H23zoLIalm1AIY_KYTVh_H0ZnmjxQIxsvXtLv45o,10
+re_common-10.0.0.dist-info/RECORD,,