re-common 10.0.12__tar.gz → 10.0.14__tar.gz

{re_common-10.0.12 → re_common-10.0.14}/PKG-INFO

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

re_common-10.0.14/re_common/v2/baselibrary/decorators/utils.py

@@ -0,0 +1,59 @@
+import warnings
+import functools
+
+# 全局集合，用于记录已警告的函数或类
+_warned_once = set()
+
+
+def deprecated(message=None):
+    """
+    装饰器：标记函数或类为已废弃，整个进程只发出一次警告。
+
+    Args:
+        message (str): 自定义警告信息，默认为 None。
+    """
+
+    def decorator(obj):
+        # 如果是函数
+        if isinstance(obj, type(lambda: None)):
+            @functools.wraps(obj)
+            def wrapper(*args, **kwargs):
+                obj_id = id(obj)  # 使用对象的内存地址作为唯一标识
+                if obj_id not in _warned_once:
+                    default_msg = f"函数 {obj.__name__} 已不建议使用。"
+                    warn_msg = f"{default_msg} {message}" if message else default_msg
+                    warnings.warn(
+                        warn_msg,
+                        category=DeprecationWarning,
+                        stacklevel=2
+                    )
+                    _warned_once.add(obj_id)  # 记录已警告
+                return obj(*args, **kwargs)
+
+            return wrapper
+
+        # 如果是类
+        elif isinstance(obj, type):
+            orig_init = obj.__init__
+
+            @functools.wraps(orig_init)
+            def new_init(self, *args, **kwargs):
+                obj_id = id(obj)
+                if obj_id not in _warned_once:
+                    default_msg = f"类 {obj.__name__} 已不建议使用。"
+                    warn_msg = f"{default_msg} {message}" if message else default_msg
+                    warnings.warn(
+                        warn_msg,
+                        category=DeprecationWarning,
+                        stacklevel=2
+                    )
+                    _warned_once.add(obj_id)  # 记录已警告
+                orig_init(self, *args, **kwargs)
+
+            obj.__init__ = new_init
+            return obj
+
+        else:
+            raise TypeError("此装饰器仅适用于函数和类")
+
+    return decorator

re_common-10.0.14/re_common/v2/baselibrary/tools/ac_ahocorasick.py

@@ -0,0 +1,76 @@
+import pickle
+
+import ahocorasick
+
+
+class ACTool(object):
+
+    def __init__(self):
+        self.automaton = ahocorasick.Automaton()
+
+    def add_word(self, key, value, overwrite=True) -> bool:
+        """
+        为 AC 机添加数据,默认情况下 key重复直接覆盖
+        :param key: 要添加的关键字
+        :param value: 对应的值
+        :param overwrite: 是否覆盖已有的 key，默认为 True
+        :return: 是否成功添加或覆盖
+        """
+        if key in self.automaton:  # 检查 key 是否已存在
+            if overwrite:  # 如果允许覆盖
+                self.automaton.add_word(key, value)
+                return True
+            else:  # 不允许覆盖，跳过
+                return False
+        else:  # key 不存在，直接添加
+            self.automaton.add_word(key, value)
+            return True
+
+    def is_exists_key(self, key) -> bool:
+        # 是否存在key
+        if self.automaton.exists(key):
+            return True
+        else:
+            return False
+
+    def make_automaton(self):
+        """
+        添加完词后需要构建
+        """
+        self.automaton.make_automaton()
+
+    def iter(self, key):
+        """
+        结果为可迭代对象 可通过list 转换 [(end_index, value)]
+        tool.add_word("he", "word1")
+        tool.add_word("hello", "word2")
+
+        # 在字符串中查找匹配
+        input_string = "hello world"
+        matches = list(tool.automaton.iter(input_string))
+        print(matches)  # [(1, 'word1'), (4, 'word2')]
+
+        (1, 'word1'):
+        end_index = 1: 表示匹配的关键字 "he" 在 input_string = "hello world" 中的结束位置是索引 1（即字符串 "he" 的最后一个字符 'e' 的位置）。
+        "hello world" 的索引：h(0)e(1)l(2)l(3)o(4) (5)w(6)o(7)r(8)l(9)d(10)。
+        value = 'word1': 表示匹配的关键字 "he" 对应的值是 "word1"。
+        (4, 'word2'):
+        end_index = 4: 表示匹配的关键字 "hello" 在 input_string = "hello world" 中的结束位置是索引 4（即字符串 "hello" 的最后一个字符 'o' 的位置）。
+        value = 'word2': 表示匹配的关键字 "hello" 对应的值是 "word2"。
+
+        注意: 结果只会返回 value 不会返回 key，如果需要key  请将key 组合到结果中
+        """
+
+        result_iter = self.automaton.iter(key)  # ahocorasick.AutomatonSearchIter
+        return result_iter
+    def save(self,local_temp_path):
+        """
+        将构建好的ac自动机保存到本地
+        """
+        self.automaton.save(local_temp_path,pickle.dumps)
+
+    def load(self,local_temp_path):
+        """
+        加载已经构建好的ac自动机
+        """
+        self.automaton=ahocorasick.load(local_temp_path, pickle.loads)

{re_common-10.0.12 → re_common-10.0.14}/re_common/v2/baselibrary/tools/search_hash_tools.py

@@ -3,9 +3,10 @@ from typing import List
 import jieba
 from datasketch import MinHash, minhash
 
+from re_common.v2.baselibrary.decorators.utils import deprecated
 from re_common.v2.baselibrary.utils.string_bool import is_single_cjk_char
 
-
+@deprecated("请使用 TextMatcherV2 中的方法代替。")
 def tokenize(text: str, stopwords=None) -> List[str]:
     """
     分词并移除停用词
@@ -32,7 +33,7 @@ def tokenize(text: str, stopwords=None) -> List[str]:
     words = [w for w in words if w not in stopwords and w.strip()]
     return words
 
-
+@deprecated("请使用 TextMatcherV2 中的方法代替。")
 def create_minhash(words: List[str], num_perm=128) -> MinHash:
     """
     为分词结果创建 MinHash
@@ -42,7 +43,7 @@ def create_minhash(words: List[str], num_perm=128) -> MinHash:
         minhash.update(word.encode("utf-8"))
     return minhash
 
-
+@deprecated("请使用 TextMatcherV2 中的方法代替。")
 def get_str_minhash(title):
     from re_common.v2.baselibrary.utils.string_clear import rel_clear
     rel_title = rel_clear(title)

{re_common-10.0.12 → re_common-10.0.14}/re_common/v2/baselibrary/tools/text_matcher.py

@@ -1,10 +1,16 @@
+import pickle
+
 import jieba
 import re
-from typing import List, Dict, Tuple, Set, Optional, Union
+from typing import List, Dict, Tuple, Set, Optional, Union, Hashable, Protocol
 from datasketch import MinHash, MinHashLSH
 
+from re_common.v2.baselibrary.decorators.utils import deprecated
+from re_common.v2.baselibrary.utils.string_bool import is_single_cjk_char
+
 
-class TextMatcher:
+@deprecated("请使用 TextMatcherV2 代替。")
+class TextMatcher(object):
     def __init__(
             self,
             threshold: float = 0.5,
@@ -188,36 +194,133 @@ class TextMatcher:
         self.doc_counter = 0
 
 
-if __name__ == "__main__":
-    # 创建匹配器实例
-    matcher = TextMatcher(
-        threshold=0.1,  # 相似度阈值
-        num_perm=128,  # MinHash 排列数
-    )
+# 定义一个协议，描述“像鸭子一样”的行为
+class TokenizeDuckLike(Protocol):
+    def get_words(self, text) -> List:
+        pass
+
+
+class JiebaTokenize(object):
+
+    def __init__(self, stopwords=None):
+        self.stopwords = stopwords
+
+    def get_words(self, text) -> List:
+
+        if self.stopwords is None:
+            stopwords = []
+        words = jieba.lcut(text)
+
+        # 统计单字符数据 长度，防止结巴分词分不了的单词 将数据分为单个字符
+
+        # 这里为什么使用函数 而不是在推导式中兼容，主要是在一些 spark中 推导式的if 条件不遵循最短路径原则会将表达式当做一个整体算子
+        def is_singel_en(i):
+            if len(i) == 1 and not is_single_cjk_char(i):
+                return True
+            return False
+
+        one_char_size = len([i for i in words if is_singel_en(i)])
+        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
+
+
+class TextMatcherV2:
+
+    def __init__(
+            self,
+            threshold: float = 0.5,
+            num_perm: int = 128,
+            tdk: TokenizeDuckLike = 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.tdk = tdk
+
+    def add_document(self, doc_id: str, minhash: Union[MinHash, str], tdk: TokenizeDuckLike = None):
+        if isinstance(minhash, str):
+            minhash = self.str_to_minihash(minhash, tdk)
 
-    # 添加单个文档
-    doc_id = matcher.add_document(
-        "北京是中国的首都"
-    )
+        self.lsh.insert(doc_id, minhash)
 
-    # 批量添加文档
-    docs = {"doc1": "北京是一座现代化的大都市", "doc2": "上海是中国最大的城市", "doc3": "中国的首都是北京"}
-    matcher.batch_add_documents(docs)
+    def batch_add_documents(self, betch_data: Union[list, dict], tdk: TokenizeDuckLike = None):
+        def _add_document(minhash_or_str, tdk):
+            if isinstance(minhash_or_str, str):
+                minhash_or_str = self.str_to_minihash(minhash_or_str, tdk)
+            self.add_document(docid, minhash_or_str, tdk)
+
+        if isinstance(betch_data, list):
+            # 必须是可解包的2个数据的元组或list
+            for docid, minhash_or_str in betch_data:
+                _add_document(minhash_or_str, tdk)
+        elif isinstance(betch_data, dict):
+            for docid, minhash_or_str in betch_data.items():
+                _add_document(minhash_or_str, tdk)
+        else:
+            raise Exception("数据类型错误")
+
+    def find_similar(self, query_minhash: Union[MinHash, str], tdk: TokenizeDuckLike = None) -> List[Hashable]:
+        # 使用 LSH 查找候选集
+        if isinstance(query_minhash, str):
+            query_minhash = self.str_to_minihash(query_minhash, tdk)
+        similar_docs = self.lsh.query(query_minhash)
+        return similar_docs
 
-    # 查找相似文档（不返回相似度分数）
-    similar_docs = matcher.find_similar("北京首都")
-    print("相似文档ID:", similar_docs)
+    def create_minhash(self, words: List[str], num_perm=None) -> MinHash:
+        """
+        为分词结果创建 MinHash
+        """
+        if num_perm is None:
+            num_perm = self.num_perm
+        minhash = MinHash(num_perm=num_perm)
+        for word in words:
+            minhash.update(word.encode("utf-8"))
+        return minhash
 
-    # 查找相似文档（返回相似度分数）
-    similar_docs_with_scores = matcher.find_similar("北京首都", return_similarities=True)
-    print("相似文档ID和分数:", similar_docs_with_scores)
+    def create_words(self, text: str, tdk: TokenizeDuckLike = None):
+        if tdk is None:
+            tdk = self.tdk
+        worlds = tdk.get_words(text)
+        return worlds
+
+    def str_to_minihash(self, text: str, tdk: TokenizeDuckLike = None):
+        if tdk is None:
+            tdk = self.tdk
+        words = self.create_words(text, tdk)
+        minhash = self.create_minhash(words, self.num_perm)
+        return minhash
 
-    # 获取原始文本
-    for doc_id, score in similar_docs_with_scores:
-        print(f"文档 {doc_id}: {matcher.get_text(doc_id)} (相似度: {score:.2f})")
+    def minhash_dumps(self, minhash) -> bytes:
+        """
+        序列化
+        """
+        serialized_minhash = pickle.dumps(minhash)
+        return serialized_minhash
 
-    # 删除文档
-    matcher.remove_document("doc1")
+    def minhash_loads(self, serialized_minhash) -> MinHash:
+        """
+        反序列化
+        """
+        minhash = pickle.loads(serialized_minhash)
+        return minhash
 
-    # 清空所有数据
-    matcher.clear()
+    def merge_other_minhashlsh(self, other_minhashlsh: MinHashLSH):
+        """
+        在其他地方创建好的lsh 合并进来
+        """
+        self.lsh.merge(other_minhashlsh)

{re_common-10.0.12 → re_common-10.0.14}/re_common/v2/baselibrary/utils/BusinessStringUtil.py

@@ -1,6 +1,8 @@
 # 某些业务中的字符串处理 算是特定场景的工具 不算通用工具
 import re
 
+from re_common.v2.baselibrary.utils.string_bool import is_all_symbols
+
 
 def clean_organ_postcode(organ):
     """
@@ -120,6 +122,11 @@ 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)
@@ -156,20 +163,27 @@ def deal_num_strs(input_str):
     return input_str
 
 
-def deal_num(strs):
+def deal_num(num_str):
     """
     将 期格式化 方便 group尤其是有横杆的数据
     该方法 为融合二次分割时使用，如果场景合适也可以用于其他地方
     :param strs:
     :return:
     """
-    strs = strs.replace("-", "_").replace(".", "_").upper()
-    if strs.find("_") > -1:
-        start, end = strs.split("_")
+    # 如果期是全符号清理掉
+    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.replace("-", "_").replace(".", "_").upper()
+    if num_str.find("_") > -1:
+        start, end = num_str.split("_")
         start = deal_num_strs(start)
         end = deal_num_strs(end)
-        strs = start + "_" + end
+        num_str = start + "_" + end
     else:
-        strs = deal_num_strs(strs)
+        num_str = deal_num_strs(num_str)
 
-    return strs
+    return num_str

re_common-10.0.14/re_common/v2/baselibrary/utils/basepika.py

@@ -0,0 +1,180 @@
+import pika
+
+
+# https://blog.csdn.net/songfreeman/article/details/50943603
+class BasePika(object):
+
+    def __init__(self, username=None, password=None, mqhost=None, virtual_host=None):
+        self.username = username
+        self.password = password
+        self.conn = None
+        self.host = mqhost
+        self.virtual_host = virtual_host
+        self.auto_ack = True
+
+    def set_default(self):
+        self.host = "192.168.31.79"
+        self.virtual_host = "vhost_NetDataGather"
+        self.username = "vip"
+        self.password = "piv$*123"
+
+    def connect_str(self,amqp_str):
+        parameters = pika.URLParameters(amqp_str)
+        self.conn = pika.BlockingConnection(parameters)
+
+    def connect(self):
+        """
+        设置用户名 密码 进行连接
+        :return:
+        """
+        credentials = pika.PlainCredentials(self.username, self.password)
+        # parameters = pika.URLParameters('amqp://guest:guest@rabbit-server1:5672/%2F')
+        # 可以通过将 heartbeat 设为 0，关闭 rabbitmq 的心跳检测
+        parameters = pika.ConnectionParameters(host=self.host,
+                                               virtual_host=self.virtual_host,
+                                               credentials=credentials,
+                                               heartbeat=0)
+        self.conn = pika.BlockingConnection(parameters)
+
+    def close(self):
+        # 关闭消息队列
+        self.conn.close()
+
+    def create_channel(self):
+        self.channel = self.conn.channel()
+
+    def __del__(self):
+        self.channel.close()
+        self.conn.close()
+
+    def random_queue_declare(self):
+        """
+        这样, result.method.queue 包含一个随机的队列名, 比如：看起来像 amq.gen-JzTY20BRgKO-HjmUJj0wLg.
+        其次：
+        一旦我们断开consumer连接，这个队列名将自动删除。这里有一个标识设置：
+        :return:
+        """
+        return self.channel.queue_declare("", exclusive=True)
+
+    def queue_declare(self, queue="hello", durable=False):
+        """
+        创建目的地队列hello 取消息时也可以调用
+        取消息和发送消息都调用 保证队列存在，也保证了不管服务端还是客户端先启动都有队列
+        durable True 为持久化
+        :return:
+        """
+        return self.channel.queue_declare(queue=queue, durable=durable)
+
+    def get_queue_size(self, queue="hello"):
+        """
+        获取某个队列的长度
+        :param queue:
+        :return:
+        """
+        queue = self.queue_declare(queue=queue, durable=True)
+        return queue.method.message_count
+
+    def get_properties(self):
+        """
+        与 queue_declare里的 durable = True 配合使用，
+        设置给 easy_send_msg的properties
+        :return:
+        """
+        return pika.BasicProperties(
+            delivery_mode=2,  # 设置消息为持久化的
+        )
+
+    def easy_send_msg(self, exchange="", routing_key="hello", body="hello world", properties=None):
+        """
+        空字符串标识默认的或者匿名的exchange,如果存在routing_key, 消息路由到routing_key指定的队列中。
+        routing_key 标识发送到哪个队列,就是服务器上的队列名
+        body 发送的消息
+
+        basic_publish 如果 exchange 不是"" 但没有绑定队列 消息会消失
+        :return:
+        """
+        self.channel.basic_publish(exchange=exchange,
+                                   routing_key=routing_key,
+                                   body=body,
+                                   properties=properties)
+
+    def basic_ack(self, ch, method):
+        """
+        callback的消息确认
+        :param ch:
+        :param method:
+        :return:
+        """
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    def callback(self, ch, method, properties, body):
+        """
+        从队列接收消息要更复杂一些，它需要为队列订阅一个 callback 函数来进行接收。
+        当我们接收一个消息后，这个 callback 函数将会被 pika函数库自动调用，
+        在我们的这个实例里面这个函数将用来打印接收的消息内容到屏幕
+        :param method:
+        :param properties:
+        :param body:
+        :return:
+        """
+        print(type(body))
+        print(" [x] Received %r" % body)
+        if self.auto_ack is False:
+            self.basic_ack(ch, method)
+
+    def set_get_msg_callback(self, routing_key="hello", callback=None, auto_ack=True):
+        """
+        设置取消息的callback
+        no_ack 如果设置为True，将使用自动确认模式
+        no_ack 如果设置为False，在callback中确认
+        :return:
+        """
+        self.auto_ack = auto_ack
+        if callback is None:
+            callback = self.callback
+        self.channel.basic_consume(routing_key,
+                                   callback,
+                                   auto_ack=auto_ack)
+
+    def start_get_msg(self):
+        """
+        开始取消息,会循环不停的取消息
+        :return:
+        """
+        self.channel.start_consuming()
+
+    def basic_qos(self, prefetch_count=1):
+        """
+        可以提前发送几个消息来，当auto_ack=True时无效
+        prefetch_count==1 消息未处理完前不要发送信息的消息
+        :return:
+        """
+        self.channel.basic_qos(prefetch_count=prefetch_count)
+
+    def exchange_declare(self, exchangename="logs", type="fanout"):
+        """
+        fanout exchange非常简单，你从这个名字中就能猜出来，它将从Producer方收到的消息广播给所有他知道的receiver方。而这正是我们的logger记录所需要的消息。
+        交换的类型
+        直接交换（direct exchange）的路由算法很简单 --  消息发送到绑定键值(binding key) 刚好完全符合路由键值( routing key) 的消息队列中。
+
+        消息发送到一个 topic交换不能是一个任意的 routing_key -- 它必须是一个用小数点 分割的单词列表。 这个字符可以是任何单词，但是通常是指定一些连接特定消息的功能。一些有效的路由键(routing key）比如：“stock.usd.nyse",
+        topic 是 直接交换的升级版
+
+        headers Exchange ：headers交换器允许你匹配AMQP消息的header而非路由键。除此之外，headers交换器和direct交换器完全一致，但性能会差很多。因此它并不太实用，而且几乎再也用不到了。
+        exchangename接下来会与队列绑定
+         direct  ,  topic ,  headers  和 fanout
+        :return:
+        """
+        return self.channel.exchange_declare(exchange=exchangename,
+                                             exchange_type=type)
+
+    def queue_bind(self, exchange="logs", queue="", routing_key=""):
+        """
+        queue 临时队列获取 self.random_queue_declare().method.queue
+        :param exchange:
+        :param queue:
+        :return:
+        """
+        self.channel.queue_bind(exchange=exchange,
+                                queue=queue,
+                                routing_key=routing_key)

re_common-10.0.14/re_common/v2/baselibrary/utils/mq.py

@@ -0,0 +1,83 @@
+import logging
+import traceback
+
+from re_common.v2.baselibrary.utils.basepika import BasePika
+from retry import retry
+
+logging_logger = logging.getLogger(__name__)
+
+
+class UseMq(object):
+
+    def __init__(self, queue, qos=1):
+        self.queue = queue
+        self.qos = qos
+        self.basepika = BasePika()
+        self.basepika.set_default()
+        self.basepika.connect()
+        self.basepika.create_channel()
+        self.basepika.queue_declare(queue=queue, durable=True)
+        self.basepika.basic_qos(qos)
+        self.properties = self.basepika.get_properties()
+
+    def re_conn(self):
+        """
+        重新连接
+        :return:
+        """
+        self.basepika.connect()
+        self.basepika.create_channel()
+        self.basepika.queue_declare(queue=self.queue, durable=True)
+        self.basepika.basic_qos(self.qos)
+
+    @retry(delay=5, backoff=2, max_delay=60 * 3, logger=logging_logger)
+    def get_mq(self):
+        try:
+            if self.basepika.channel.is_closed:
+                logging_logger.info("重连中......")
+                self.re_conn()
+                logging_logger.info("重连完成......")
+            self.basepika.set_get_msg_callback(routing_key=self.queue, callback=self.callback, auto_ack=False)
+            self.basepika.start_get_msg()
+        except:
+            traceback.print_exc()
+            logging_logger.info("重连中......")
+            self.re_conn()
+
+    def callback(self, ch, method, properties, body):
+        # print(type(body))
+        # print(" [x] Received %r" % body)
+        # body = body.decode()
+        self.callback2(ch, method, properties, body)
+        if self.basepika.auto_ack is False:
+            self.basepika.basic_ack(ch, method)
+
+    def callback2(self, ch, method, properties, body):
+        pass
+
+    @retry(delay=5, backoff=2, max_delay=60 * 3, logger=logging_logger)
+    def send_mq(self, body, num=100):
+        try:
+            if self.basepika.get_queue_size(self.queue) < num:
+                self.basepika.easy_send_msg(routing_key=self.queue,
+                                            body=body,
+                                            properties=self.properties)
+                return True
+            else:
+                return False
+        except:
+            traceback.print_exc()
+            logging_logger.info("重连中......")
+            self.re_conn()
+            return False
+
+    def get_server_mq_num(self, num=100):
+        if self.basepika.get_queue_size(self.queue) < num:
+            return True
+        else:
+            return False
+
+    def easy_send_mq(self, body):
+        self.basepika.easy_send_msg(routing_key=self.queue,
+                                    body=body,
+                                    properties=self.properties)