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

re_common/v2/baselibrary/s3object/baseboto3.py

@@ -0,0 +1,230 @@
+from boto3.session import Session
+
+
+class BaseBoto3(object):
+
+    def __init__(self, aws_access_key_id="", aws_secret_access_key="", endpoint_url=""):
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.endpoint_url = endpoint_url
+        self.session = None
+        self.client = None
+        if self.aws_access_key_id and self.aws_secret_access_key and self.endpoint_url:
+            self.conn_session()
+            self.get_client()
+
+    def set_key(self, aws_access_key_id, aws_secret_access_key, endpoint_url):
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.endpoint_url = endpoint_url
+        return self
+
+    def conn_session(self):
+        assert self.aws_access_key_id not in (None, '')
+        assert self.aws_secret_access_key not in (None, '')
+        self.session = Session(aws_access_key_id=self.aws_access_key_id,
+                               aws_secret_access_key=self.aws_secret_access_key)
+        return self.session
+
+    def get_client(self):
+        assert self.session is not None
+        self.client = self.session.client('s3', endpoint_url=self.endpoint_url)
+        return self
+
+    def get_all_buckets(self):
+        """
+        获取所有的桶信息
+        :return:
+        """
+        return self.client.list_buckets()
+
+    def create_buckets(self, buckets_name):
+        """
+         如果get_client 使用 client 返回
+        {'ResponseMetadata': {'RequestId': '16BC90EED4A433C4', 'HostId': '', 'HTTPStatusCode': 200, 'HTTPHeaders': {'accept-ranges': 'bytes', 'content-length': '0', 'content-security-policy': 'block-all-mixed-content', 'location': '/create1', 'server': 'MinIO', 'strict-transport-security': 'max-age=31536000; includeSubDomains', 'vary': 'Origin, Accept-Encoding', 'x-amz-request-id': '16BC90EED4A433C4', 'x-content-type-options': 'nosniff', 'x-xss-protection': '1; mode=block', 'date': 'Wed, 01 Dec 2021 07:28:39 GMT'}, 'RetryAttempts': 0}, 'Location': '/create1'}
+        """
+        assert buckets_name.find("_") == -1, "新建一个bucket桶(bucket name 中不能有_下划线)"
+        # 新建一个bucket桶(bucket name 中不能有_下划线)
+        return self.client.create_bucket(Bucket=buckets_name)
+
+    def delete_buckets(self, bucket_name):
+        """
+        删除桶 删除bucket(只能删除空的bucket)
+        :return:
+        """
+        response = self.client.delete_bucket(Bucket=bucket_name)
+        return response
+
+    def get_bucket(self, bucket_name):
+        raise Exception("无实现方法")
+
+    def get_all_objs(self, bucket_name, prefix=None, continuation_token=None):
+        """
+
+        continuation_token: 如果超过1000 需要传第一次获取结果中的 continuation_token
+
+        response 的结构
+        {'ResponseMetadata': {'RequestId': '1818F447C1E7BA3B', 'HostId': '', 'HTTPStatusCode': 200,
+        'HTTPHeaders': {'accept-ranges': 'bytes', 'content-length': '3182', 'content-security-policy': 'block-all-mixed-content', 'content-type': 'application/xml',
+        'server': 'MinIO', 'strict-transport-security': 'max-age=31536000; includeSubDomains', 'vary': 'Origin, Accept-Encoding', 'x-amz-request-id': '1818F447C1E7BA3B',
+         'x-content-type-options': 'nosniff', 'x-xss-protection': '1; mode=block', 'date': 'Thu, 09 Jan 2025 07:04:05 GMT'}, 'RetryAttempts': 0},
+         'IsTruncated': False, 'Contents':
+         [
+         {'Key': 'zt_file/zt类型样例数据/11_part-00000.gz', 'LastModified': datetime.datetime(2024, 4, 28, 2, 56, 59, 716000, tzinfo=tzutc()), 'ETag': '"e0d635f171bce6a67ad72265e5f9137d-2"',
+          'Size': 18164139, 'StorageClass': 'STANDARD', 'Owner': {'DisplayName': 'minio', 'ID': '02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4'}},
+        {'Key': 'zt_file/zt类型样例数据/12_part-00000.gz', 'LastModified': datetime.datetime(2024, 4, 28, 2, 56, 57, 70000, tzinfo=tzutc()), 'ETag': '"f238fe9973a2bc0d3e1562c2938ce897-9"',
+        'Size': 93710911, 'StorageClass': 'STANDARD', 'Owner': {'DisplayName': 'minio', 'ID': '02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4'}},
+         ],
+         'Name': 'crawl.dc.cqvip.com', 'Prefix': 'zt_file/zt类型样例数据', 'Delimiter': '',
+         'MaxKeys': 1000, 'EncodingType': 'url', 'KeyCount': 7}
+
+        """
+        if continuation_token:
+            # 获取桶中以特定前缀开头的所有对象
+            response = self.client.list_objects_v2(Bucket=bucket_name,
+                                                   Prefix=prefix,
+                                                   ContinuationToken=continuation_token)
+        else:
+            # 获取桶中以特定前缀开头的所有对象
+            response = self.client.list_objects_v2(Bucket=bucket_name,
+                                                   Prefix=prefix)
+        object_list = []
+        # 检查是否有对象存在
+        if 'Contents' in response:
+            object_list = [obj['Key'] for obj in response['Contents']]
+
+        continuation_token = None
+        # 检查是否有更多对象
+        if response.get('IsTruncated'):  # 如果返回结果被截断，说明有更多对象
+            continuation_token = response.get('NextContinuationToken')
+
+        return object_list, continuation_token
+
+    def list_prefixes(self, bucket_name, prefix=None, Delimiter="/", continuation_token=None):
+        """
+        获取目录下一层的目录
+        prefix: 注意 这个要以 Delimiter 结尾 比如 Delimiter="/" 那么 prefix="a/"
+        continuation_token: 如果超过1000 需要传第一次获取结果中的 continuation_token
+        return:  ['a/b/', 'a/c/'] 注意 反回的 结果带有prefix 只能返回目录 不能返回文件
+        """
+        if continuation_token:
+            # 获取桶中以特定前缀开头的所有对象
+            response = self.client.list_objects_v2(Bucket=bucket_name,
+                                                   Prefix=prefix,
+                                                   Delimiter=Delimiter,  # 使用斜杠分隔符模拟目录结构
+                                                   ContinuationToken=continuation_token)
+        else:
+            # 获取桶中以特定前缀开头的所有对象
+            response = self.client.list_objects_v2(Bucket=bucket_name,
+                                                   Delimiter=Delimiter,  # 使用斜杠分隔符模拟目录结构
+                                                   Prefix=prefix)
+        object_list = []
+        # 检查是否有对象存在
+        if 'Contents' in response:
+            object_list = [obj['Key'] for obj in response['Contents']]
+
+        Prefix_list = []
+        # 检查是否有目录存在
+        if 'CommonPrefixes' in response:
+            Prefix_list = [obj['Prefix'] for obj in response['CommonPrefixes']]
+
+        continuation_token = None
+        # 检查是否有更多对象
+        if response.get('IsTruncated'):  # 如果返回结果被截断，说明有更多对象
+            continuation_token = response.get('NextContinuationToken')
+
+        return object_list, Prefix_list, continuation_token
+
+    def get_object_value(self, bucket_name, file_key, encoding='utf-8'):
+        """
+        读取文本数据
+        Returns:
+        """
+        obj = self.client.get_object(Bucket=bucket_name, Key=file_key)
+        body = obj['Body'].read().decode(encoding)
+        return body
+
+    def put_object(self, bucket_name, key, body):
+        """
+        直接写内容到文件
+        Args:
+            bucket_name:
+            key:
+            body: 需要 编码 .encode('utf-8')
+
+        Returns:
+        """
+        self.client.put_object(Bucket=bucket_name,
+                               Key=key,
+                               Body=body)
+
+    def download_file(self, bucket_name, key, local_file):
+        """
+        return: None
+        """
+        result = self.client.download_file(bucket_name, key, local_file)
+        return result
+
+    def upload_file(self, bucket_name, key, local_file):
+        """
+        # key 桶中的位置 test1/test.pdf
+        :param local_file:  本地文件路径
+        :param bucket_name: 桶名
+        :param key: 远程文件路径
+        :return:
+        """
+        self.client.upload_file(local_file, bucket_name, key)
+
+    def download_fileobj(self, bucket_name, key, fileobj):
+        """
+        return: None
+        """
+        result = self.client.download_fileobj(bucket_name, key, fileobj)
+        return result
+
+    def upload_fileobj(self, bucket_name, key, fileobj):
+        # fileobj 字节流
+        self.client.upload_fileobj(fileobj, bucket_name, key)
+
+    def check_exist_or_file_info(self, bucket_name, key):
+        """
+        检查文件是否存在且能获取文件info
+        {'ResponseMetadata': {'RequestId': '17E6A65A2B299D3B', 'HostId': '', 'HTTPStatusCode': 200, 'HTTPHeaders':
+         {'accept-ranges': 'bytes', 'content-length': '117', 'content-security-policy': 'block-all-mixed-content', 'content-type': 'binary/octet-stream',
+         'etag': '"2237a934f176003e41abf3d733291079"', 'last-modified': 'Thu, 25 Jul 2024 05:49:43 GMT', 'server': 'MinIO',
+         'strict-transport-security': 'max-age=31536000; includeSubDomains', 'vary': 'Origin, Accept-Encoding', 'x-amz-request-id': '17E6A65A2B299D3B',
+          'x-content-type-options': 'nosniff', 'x-xss-protection': '1; mode=block', 'date': 'Mon, 29 Jul 2024 09:53:33 GMT'}, 'RetryAttempts': 0},
+          'AcceptRanges': 'bytes', 'LastModified': datetime.datetime(2024, 7, 25, 5, 49, 43, tzinfo=tzutc()), 'ContentLength': 117, 'ETag': '"2237a934f176003e41abf3d733291079"',
+           'ContentType': 'binary/octet-stream', 'Metadata': {}}
+        """
+        try:
+            obj_info = self.client.head_object(
+                Bucket=bucket_name,
+                Key=key
+            )
+            return obj_info
+        except:
+            return None
+
+    def get_prefix_count(self, bucket_name, obj_count, prefix, continuation_token=None):
+        """
+        统计 某个目录的文件数据量，由于需要每个目录获取一次 性能很慢
+        """
+        for index in range(10000):
+            obj_list, dir_list, token = self.list_prefixes(bucket_name=bucket_name,
+                                                           prefix=prefix,
+                                                           continuation_token=continuation_token)
+
+            obj_count = obj_count + len(obj_list)
+            for dir_sub in dir_list:
+                obj_count = self.get_prefix_count(bucket_name, obj_count, dir_sub)
+
+            if token:
+                continuation_token = token
+            else:
+                break
+
+        if index > 10000 - 5:
+            raise Exception("循环耗尽，请检查逻辑正确性")
+
+        return obj_count

re_common/v2/baselibrary/tools/dict_tools.py

@@ -0,0 +1,24 @@
+class DotDict(dict):
+    """
+    让字典成为对象 既可以用字典方式访问 也可以用点访问key
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # 递归地将嵌套字典转换为 DotDict
+        for key, value in self.items():
+            if isinstance(value, dict):
+                self[key] = DotDict(value)
+
+    def __getattr__(self, key):
+        try:
+            value = self[key]
+            if isinstance(value, dict):  # 如果值是字典，继续转换为 DotDict
+                return DotDict(value)
+            return value
+        except KeyError:
+            raise AttributeError(f"'DotDict' object has no attribute '{key}'")
+
+    def __setattr__(self, key, value):
+        if isinstance(value, dict):  # 如果值是字典，转换为 DotDict
+            value = DotDict(value)
+        self[key] = value

re_common/v2/baselibrary/tools/unionfind_tools.py

@@ -0,0 +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  # 返回分组结果

re_common/v2/baselibrary/utils/BusinessStringUtil.py

@@ -0,0 +1,74 @@
+# 某些业务中的字符串处理 算是特定场景的工具
+import re
+
+
+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:
+            return organ_one
+
+    return ""
+
+
+def get_first_author(author: object) -> object:
+    if not author:
+        return ""
+    au_list = author.strip().split(";")
+    for au in au_list:
+        au = re.sub("\\[.*?]", "", au)
+        au = re.sub("\\(.*?\\)", "", au)
+        if au:
+            return au
+    return ""

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,84 @@
+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 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)
+
+    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)
+
+    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).qj_to_bj().remove_special_chars().collapse_spaces().lower().get_str()