re-common 0.2.54__py3-none-any.whl → 2.0.1__py3-none-any.whl

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/basedict.py

@@ -0,0 +1,26 @@
+import logging
+
+logger = logging.getLogger(__name__)  # 创建 logger 实例
+
+
+class BaseDict(object):
+    @classmethod
+    def flip_dict(cls, original_dict, raise_on_conflict=False):
+        """
+        翻转字典：将 key 是字符串、value 是列表的字典，转换为 key 是原 value 列表中的元素、value 是原 key 的字典。
+        :param original_dict: 原始字典
+        :param raise_on_conflict: 是否在键冲突时抛出异常，默认为 False
+        :return: 翻转后的字典
+        """
+        flipped_dict = {}
+        for key, value_list in original_dict.items():
+            for value in value_list:
+                if value in flipped_dict:
+                    if raise_on_conflict:
+                        raise ValueError(f"Key conflict detected: {value} already exists in the flipped dictionary.")
+                    else:
+                        # 覆盖冲突的键
+                        logger.warning(
+                            f"Warning: Key conflict detected for {value}. Overwriting with new value: {key}.")
+                flipped_dict[value] = key
+        return flipped_dict

re_common/v2/baselibrary/utils/basehdfs.py

@@ -0,0 +1,127 @@
+import gzip
+from io import BytesIO
+
+from hdfs import InsecureClient
+
+
+class HDFSUtils(object):
+    """
+    HDFS 工具类，封装常见的 HDFS 操作。
+    """
+
+    def __init__(self, hdfs_url, hdfs_user):
+        """
+        初始化 HDFS 客户端。
+        :param hdfs_url: HDFS 的 URL，例如 "http://namenode:50070"
+        :param hdfs_user: HDFS 用户名
+        """
+        self.hdfs_url = hdfs_url
+        self.hdfs_user = hdfs_user
+        self.client = InsecureClient(hdfs_url, user=hdfs_user)
+
+    def upload_file(self, local_path, hdfs_path, overwrite=False):
+        """
+        将本地文件上传到 HDFS。
+        :param local_path: 本地文件路径
+        :param hdfs_path: HDFS 文件路径
+        :param overwrite: 是否覆盖已存在的文件
+        :return: None
+        """
+        self.client.upload(hdfs_path, local_path, overwrite=overwrite)
+        print(f"文件上传成功: {local_path} -> {hdfs_path}")
+
+    def download_file(self, hdfs_path, local_path, overwrite=False):
+        """
+        从 HDFS 下载文件到本地。
+        :param hdfs_path: HDFS 文件路径
+        :param local_path: 本地文件路径
+        :param overwrite: 是否覆盖已存在的文件
+        :return: None
+        """
+        self.client.download(hdfs_path, local_path, overwrite=overwrite)
+        print(f"文件下载成功: {hdfs_path} -> {local_path}")
+
+    def delete_file(self, hdfs_path, recursive=False):
+        """
+        删除 HDFS 上的文件或目录。
+        :param hdfs_path: HDFS 文件或目录路径
+        :param recursive: 是否递归删除目录
+        :return: None
+        """
+        self.client.delete(hdfs_path, recursive=recursive)
+        print(f"文件/目录删除成功: {hdfs_path}")
+
+    def create_directory(self, hdfs_path):
+        """
+        在 HDFS 上创建目录。
+        :param hdfs_path: HDFS 目录路径
+        :return: None
+        """
+        self.client.makedirs(hdfs_path)
+        print(f"目录创建成功: {hdfs_path}")
+
+    def list_files(self, hdfs_path):
+        """
+        列出 HDFS 目录下的文件和子目录。
+        :param hdfs_path: HDFS 目录路径
+        :return: 文件/目录列表
+        """
+        files = self.client.list(hdfs_path)
+        return files
+
+    def read_file(self, hdfs_path):
+        """
+        读取 HDFS 文件内容。
+        :param hdfs_path: HDFS 文件路径
+        :return: 文件内容
+        """
+        with self.client.read(hdfs_path) as reader:
+            content = reader.read()
+            print(f"文件读取成功: {hdfs_path}")
+            return content
+
+    def read_gz_file(self, hdfs_path, encoding='utf-8'):
+        """
+        读取 HDFS 上的 .gz 文件内容。
+        :param hdfs_path: HDFS 文件路径（必须以 .gz 结尾）
+        :param encoding: 文件编码格式（默认 utf-8）
+        :return: 文件内容
+        """
+        with self.client.read(hdfs_path) as reader:  # 以二进制模式读取
+            compressed_data = reader.read()  # 读取压缩数据
+            with gzip.GzipFile(fileobj=BytesIO(compressed_data)) as gz_file:  # 解压缩
+                content = gz_file.read().decode(encoding)  # 解码为字符串
+                print(f"文件读取成功: {hdfs_path}")
+                return content
+
+    def write_file(self, hdfs_path, content, overwrite=False, encoding='utf-8'):
+        """
+        向 HDFS 文件写入内容。
+        :param hdfs_path: HDFS 文件路径
+        :param content: 要写入的内容
+        :param overwrite: 是否覆盖已存在的文件
+        :param encoding: 文件编码格式
+        :return: None
+        """
+        with self.client.write(hdfs_path, overwrite=overwrite, encoding=encoding) as writer:
+            writer.write(content)
+            print(f"文件写入成功: {hdfs_path}")
+
+    def file_exists(self, hdfs_path):
+        """
+        检查 HDFS 文件或目录是否存在。
+        :param hdfs_path: HDFS 文件或目录路径
+        :return: 是否存在
+        """
+        status = self.client.status(hdfs_path, strict=False)
+        return status is not None
+
+    def rename_file(self, hdfs_src_path, hdfs_dst_path):
+        """
+        重命名或移动 HDFS 文件/目录。
+        :param hdfs_src_path: 源路径
+        :param hdfs_dst_path: 目标路径
+        :return: None
+        """
+        self.client.rename(hdfs_src_path, hdfs_dst_path)
+        print(f"文件/目录重命名成功: {hdfs_src_path} -> {hdfs_dst_path}")

re_common/v2/baselibrary/utils/json_cls.py

@@ -0,0 +1,11 @@
+import base64
+import json
+
+
+class BytesEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, bytes):
+            return base64.b64encode(obj).decode('utf-8')
+        return super().default(obj)
+
+# json.dumps(x, ensure_ascii=False, cls=BytesEncoder)

re_common/v2/baselibrary/utils/string_bool.py

@@ -0,0 +1,9 @@
+import re
+
+
+def is_all_english_chars(s):
+    return bool(re.match(r'^[A-Za-z]+$', s))
+
+
+def contains_chinese_chars(s):
+    return bool(re.search(r'[\u3400-\u9fff]', s))

re_common/v2/baselibrary/utils/string_clear.py

@@ -0,0 +1,98 @@
+import re
+import regex
+
+from re_common.v2.baselibrary.utils.stringutils import qj2bj, bj2qj, get_diacritic_variant
+
+
+class StringClear(object):
+
+    def __init__(self, obj_str):
+        self.obj_str = obj_str
+
+    def None_to_str(self):
+        if self.obj_str is None:
+            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)
+        return self
+
+    def bj_to_qj(self):
+        # 半角变全角
+        self.obj_str = bj2qj(self.obj_str)
+        return self
+
+    def lower(self):
+        self.obj_str = self.obj_str.lower()
+        return self
+
+    def upper(self):
+        self.obj_str = self.obj_str.upper()
+        return self
+
+    def collapse_spaces(self):
+        # 移除多余空格,连续多个空格变一个
+        self.obj_str = re.sub(r"\s+", " ", self.obj_str)
+        return self
+
+    def clear_all_spaces(self):
+        # 去除所有空格
+        self.obj_str = re.sub("\\s+", "", self.obj_str)
+        return self
+
+    def clean_symbols(self):
+        """
+        清理已知的符号
+        """
+        self.obj_str = regex.sub(
+            "[\\p{P}+~$`^=|<>～`$^+=|<>￥×\\\\*#$^|+%&~!,:.;'/{}()\\[\\]?<> 《》”“-（）。≤《〈〉》—、·―–‐‘’“”″…¨〔〕°■『』℃ⅠⅡⅢⅣⅤⅥⅦⅩⅪⅫ]",
+            "",
+            self.obj_str)  # \\p{P} 标点符号 后面的是一些其他符号， 也可以用 \p{S} 代替 但是这个很广 可能有误伤
+        return self
+
+    def remove_special_chars(self):
+        # 移除特殊字符，仅保留字母、数字、空格和汉字 \w 已经包括所有 Unicode 字母 下划线 _ 会被保留
+        self.obj_str = re.sub(r"[^\w\s]", "", self.obj_str)
+        return self
+
+    def remove_underline(self):
+        # 下划线在 \w 中 所以这里独立封装
+        self.obj_str = re.sub("[_]", "", self.obj_str)
+        return self
+
+    def remove_diacritics(self):
+        # 去除音标 转换成字母
+        self.obj_str = get_diacritic_variant(self.obj_str)
+        return self
+
+    def remove_brackets(self):
+        # 移除 方括号里面的内容
+        self.obj_str = re.sub("\\[.*?]", "", self.obj_str)
+        return self
+
+    def remove_parentheses(self):
+        # 移除圆括号的内容
+        self.obj_str = re.sub("\\(.*?\\)", "", self.obj_str)
+        return self
+
+    def get_str(self):
+        return self.obj_str
+
+
+def rel_clear(str_obj):
+    # 为融合数据定制的 清理规则
+    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

@@ -0,0 +1,95 @@
+import re
+
+import regex
+import unicodedata
+
+
+def bj2qj(src):
+    if src is None:
+        return src
+
+    DBC_SPACE = ' '
+    SBC_SPACE = '　'
+    DBC_CHAR_START = 33
+    DBC_CHAR_END = 126
+    CONVERT_STEP = 65248
+
+    buf = []
+    for char in src:
+        if char == DBC_SPACE:
+            buf.append(SBC_SPACE)
+        elif DBC_CHAR_START <= ord(char) <= DBC_CHAR_END:
+            buf.append(chr(ord(char) + CONVERT_STEP))
+        else:
+            buf.append(char)
+
+    return ''.join(buf)
+
+def qj2bj(src):
+    """
+    全角转半角
+    :param src:
+    :return:
+    """
+    if src is None:
+        return src
+
+    SBC_CHAR_START = 0xFF01
+    SBC_CHAR_END = 0xFF5E
+    CONVERT_STEP = 0xFEE0
+    DBC_SPACE = ' '
+    SBC_SPACE = '　'
+
+    buf = []
+    for char in src:
+        if SBC_CHAR_START <= ord(char) <= SBC_CHAR_END:
+            buf.append(chr(ord(char) - CONVERT_STEP))
+        elif char == SBC_SPACE:
+            buf.append(DBC_SPACE)
+        else:
+            buf.append(char)
+
+    return ''.join(buf)
+
+
+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 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-0.2.54.dist-info → re_common-2.0.1.dist-info}/METADATA

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