re-common 10.0.22__py3-none-any.whl → 10.0.24__py3-none-any.whl

re_common/v2/baselibrary/utils/mq.py

@@ -1,83 +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)
+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)

re_common/v2/baselibrary/utils/n_ary_expression_tree.py

@@ -1,244 +1,244 @@
-class Node:
-    def __init__(self, value, children=None):
-        self.value = value
-        self.children = children if children is not None else []
-
-    def __repr__(self):
-        return f"Node(value={self.value}, children={self.children})"
-
-
-def tokenize(expression):
-    """将表达式分解为标记（token），仅以 and, or, not 和括号作为分界符
-
-    Args:
-        expression (str): 输入的字符串表达式，例如 'a = 3 + (b > 2) and c'
-
-    Returns:
-        list: 分解后的标记列表，例如 ['a = 3 + (b > 2)', 'and', 'c']
-    """
-    tokens = []  # 存储最终的标记列表
-    current = ""  # 当前正在构建的标记字符串
-    i = 0  # 当前字符的索引
-    length = len(expression)  # 输入表达式的长度
-
-    def is_delimiter_match(expression, i, delimiter_len=3, delimiter="and"):
-        """检查当前位置是否匹配指定的分隔符（and, or, not）
-
-        Args:
-            expression (str): 输入的表达式字符串
-            i (int): 当前检查的起始索引
-            delimiter_len (int): 分隔符的长度，默认为 3（适用于 'and' 和 'not'）
-            delimiter (str): 要检查的分隔符，默认为 'and'
-
-        Returns:
-            bool: 如果当前位置匹配分隔符且前后有空格，返回 True，否则返回 False
-        """
-        # 检查索引是否超出范围
-        if not i + delimiter_len <= length:
-            return False
-        # 检查当前位置是否匹配指定分隔符（忽略大小写）
-        if not expression[i:i + delimiter_len].lower() == delimiter:
-            return False
-
-        # 检查分隔符前是否有一个空格（如果不是字符串开头）
-        if i - 1 >= 0:
-            if not expression[i - 1].lower() == ' ':
-                return False
-
-        # 检查分隔符后是否有一个空格（如果不是字符串结尾）
-        if i + delimiter_len + 1 <= length:
-            if not expression[i + delimiter_len].lower() == ' ':
-                return False
-        return True
-
-    # 遍历表达式的每个字符
-    while i < length:
-        char = expression[i]  # 当前处理的字符
-
-        # 处理括号
-        if char in "()":
-            if current.strip():  # 如果当前标记有内容，先将其添加到 tokens
-                tokens.append(current.strip())
-                current = ""  # 重置当前标记
-            tokens.append(char)  # 将括号作为独立标记添加
-            i += 1  # 移动到下一个字符
-            continue
-
-        # 检查是否遇到 and, or, not 分隔符
-        if is_delimiter_match(expression, i, delimiter_len=3, delimiter="and"):
-            if current.strip():  # 如果当前标记有内容，先添加
-                tokens.append(current.strip())
-                current = ""  # 重置当前标记
-            tokens.append("and")  # 添加 'and' 标记
-            i += 3  # 跳过 'and' 的长度
-            continue
-        elif is_delimiter_match(expression, i, delimiter_len=2, delimiter="or"):
-            if current.strip():  # 如果当前标记有内容，先添加
-                tokens.append(current.strip())
-                current = ""  # 重置当前标记
-            tokens.append("or")  # 添加 'or' 标记
-            i += 2  # 跳过 'or' 的长度
-            continue
-        elif is_delimiter_match(expression, i, delimiter_len=3, delimiter="not"):
-            if current.strip():  # 如果当前标记有内容，先添加
-                tokens.append(current.strip())
-                current = ""  # 重置当前标记
-            tokens.append("not")  # 添加 'not' 标记
-            i += 3  # 跳过 'not' 的长度
-            continue
-
-        # 将非分隔符字符追加到当前标记中，包括空格
-        current += char
-        i += 1  # 移动到下一个字符
-
-    # 处理最后一个标记（如果有内容）
-    if current.strip():
-        tokens.append(current.strip())
-
-    return tokens  # 返回标记列表
-
-
-
-
-def parse_expression(tokens):
-    """递归下降解析表达式"""
-
-    def parse_or(tokens, pos):
-        """解析 OR 级别（最低优先级）"""
-        left, pos = parse_and(tokens, pos)
-        while pos < len(tokens) and tokens[pos] == 'or':
-            pos += 1
-            if pos >= len(tokens):
-                raise ValueError("Incomplete expression after 'or'")
-            right, pos = parse_and(tokens, pos)
-            left = Node('or', [left, right])
-        return left, pos
-
-    def parse_and(tokens, pos):
-        """解析 AND 级别（次高优先级）"""
-        left, pos = parse_not(tokens, pos)
-        while pos < len(tokens) and tokens[pos] == 'and':
-            pos += 1
-            if pos >= len(tokens):
-                raise ValueError("Incomplete expression after 'and'")
-            right, pos = parse_not(tokens, pos)
-            left = Node('and', [left, right])
-        return left, pos
-
-    def parse_not(tokens, pos):
-        """解析 NOT 级别（最高优先级）"""
-        if pos < len(tokens) and tokens[pos] == 'not':
-            pos += 1
-            if pos >= len(tokens):
-                raise ValueError("Incomplete expression after 'not'")
-            child, pos = parse_primary(tokens, pos)
-            return Node('not', [child]), pos
-        return parse_primary(tokens, pos)
-
-    def parse_primary(tokens, pos):
-        """解析基本单元（条件或括号表达式）"""
-        if pos >= len(tokens):
-            raise ValueError("Unexpected end of expression")
-
-        if tokens[pos] == '(':
-            pos += 1
-            subtree, pos = parse_or(tokens, pos)
-            if pos >= len(tokens) or tokens[pos] != ')':
-                raise ValueError("Missing closing parenthesis")
-            return subtree, pos + 1
-        else:
-            # 假设这是一个条件（如 A=1）
-            return Node(tokens[pos]), pos + 1
-
-    # 从头开始解析
-    tree, pos = parse_or(tokens, 0)
-    if pos < len(tokens):
-        raise ValueError(f"Extra tokens after expression: {tokens[pos:]}")
-    return tree
-
-
-def flatten_tree(node):
-    """清理语法树，将嵌套的同级 and/or 节点展平。
-
-    Args:
-        node (Node): 输入的语法树节点
-
-    Returns:
-        Node: 清理后的新语法树节点
-    """
-    # 如果没有子节点，直接返回原节点（条件节点）
-    if not node.children:
-        return Node(value=node.value, children=[])
-
-    # 递归清理所有子节点
-    cleaned_children = [flatten_tree(child) for child in node.children]
-
-    # 如果当前节点是 'and' 或 'or'，展平嵌套的同类节点
-    if node.value in ('and', 'or'):
-        flattened_children = []
-        for child in cleaned_children:
-            # 如果子节点的值与当前节点相同（例如 'or' 下的 'or'），将其子节点提升
-            if child.value == node.value:
-                flattened_children.extend(child.children)
-            else:
-                flattened_children.append(child)
-        return Node(value=node.value, children=flattened_children)
-
-    # 对于其他节点（例如 'not'），保持结构不变，只更新子节点
-    return Node(value=node.value, children=cleaned_children)
-
-
-def pretty_print_tree(node, indent=0, prefix=""):
-    """生成语法树的格式化字符串表示，带有层次缩进。
-
-    Args:
-        node (Node): 要格式化的语法树节点
-        indent (int): 当前缩进级别（空格数），默认从 0 开始
-        prefix (str): 前缀字符串，用于表示当前行的开头
-
-    Returns:
-        str: 格式化后的树形字符串
-    """
-    # 基本缩进单位
-    spaces = " " * indent
-
-    # 如果没有子节点，返回单行表示
-    if not node.children:
-        return f"{spaces}{prefix}Node(value='{node.value}', children=[])"
-
-    # 构建当前节点的字符串
-    result = [f"{spaces}{prefix}Node(value='{node.value}', children=["]
-
-    # 递归处理每个子节点
-    for i, child in enumerate(node.children):
-        is_last = i == len(node.children) - 1
-        child_prefix = " " if is_last else " "
-        result.append(pretty_print_tree(child, indent + 4, child_prefix))
-
-    # 添加结束括号
-    result.append(f"{spaces}])")
-
-    # 将所有行连接成一个字符串
-    return "\n".join(result)
-
-# 测试代码
-expressions = [
-    "not A=1 and B= 2",
-    "A=1 and (not B=2 or (C=3 or D=4))",
-    "A=1 and not (B=2 or C=3 and D=4 or E=5)",
-    "(A=1 and not (B=2 or C=3 or D=4))",
-    "A=1 and",  # 不完整表达式
-    "and A=1",  # 不完整表达式
-]
-
-for expr in expressions:
-    try:
-        print(f"\nExpression: {expr}")
-        tokens = tokenize(expr)
-        print("Tokens:", tokens)
-        tree = parse_expression(tokens)
-        tree = flatten_tree(tree)
-        tree = pretty_print_tree(tree)
-        print("Tree:", tree)
-    except ValueError as e:
+class Node:
+    def __init__(self, value, children=None):
+        self.value = value
+        self.children = children if children is not None else []
+
+    def __repr__(self):
+        return f"Node(value={self.value}, children={self.children})"
+
+
+def tokenize(expression):
+    """将表达式分解为标记（token），仅以 and, or, not 和括号作为分界符
+
+    Args:
+        expression (str): 输入的字符串表达式，例如 'a = 3 + (b > 2) and c'
+
+    Returns:
+        list: 分解后的标记列表，例如 ['a = 3 + (b > 2)', 'and', 'c']
+    """
+    tokens = []  # 存储最终的标记列表
+    current = ""  # 当前正在构建的标记字符串
+    i = 0  # 当前字符的索引
+    length = len(expression)  # 输入表达式的长度
+
+    def is_delimiter_match(expression, i, delimiter_len=3, delimiter="and"):
+        """检查当前位置是否匹配指定的分隔符（and, or, not）
+
+        Args:
+            expression (str): 输入的表达式字符串
+            i (int): 当前检查的起始索引
+            delimiter_len (int): 分隔符的长度，默认为 3（适用于 'and' 和 'not'）
+            delimiter (str): 要检查的分隔符，默认为 'and'
+
+        Returns:
+            bool: 如果当前位置匹配分隔符且前后有空格，返回 True，否则返回 False
+        """
+        # 检查索引是否超出范围
+        if not i + delimiter_len <= length:
+            return False
+        # 检查当前位置是否匹配指定分隔符（忽略大小写）
+        if not expression[i:i + delimiter_len].lower() == delimiter:
+            return False
+
+        # 检查分隔符前是否有一个空格（如果不是字符串开头）
+        if i - 1 >= 0:
+            if not expression[i - 1].lower() == ' ':
+                return False
+
+        # 检查分隔符后是否有一个空格（如果不是字符串结尾）
+        if i + delimiter_len + 1 <= length:
+            if not expression[i + delimiter_len].lower() == ' ':
+                return False
+        return True
+
+    # 遍历表达式的每个字符
+    while i < length:
+        char = expression[i]  # 当前处理的字符
+
+        # 处理括号
+        if char in "()":
+            if current.strip():  # 如果当前标记有内容，先将其添加到 tokens
+                tokens.append(current.strip())
+                current = ""  # 重置当前标记
+            tokens.append(char)  # 将括号作为独立标记添加
+            i += 1  # 移动到下一个字符
+            continue
+
+        # 检查是否遇到 and, or, not 分隔符
+        if is_delimiter_match(expression, i, delimiter_len=3, delimiter="and"):
+            if current.strip():  # 如果当前标记有内容，先添加
+                tokens.append(current.strip())
+                current = ""  # 重置当前标记
+            tokens.append("and")  # 添加 'and' 标记
+            i += 3  # 跳过 'and' 的长度
+            continue
+        elif is_delimiter_match(expression, i, delimiter_len=2, delimiter="or"):
+            if current.strip():  # 如果当前标记有内容，先添加
+                tokens.append(current.strip())
+                current = ""  # 重置当前标记
+            tokens.append("or")  # 添加 'or' 标记
+            i += 2  # 跳过 'or' 的长度
+            continue
+        elif is_delimiter_match(expression, i, delimiter_len=3, delimiter="not"):
+            if current.strip():  # 如果当前标记有内容，先添加
+                tokens.append(current.strip())
+                current = ""  # 重置当前标记
+            tokens.append("not")  # 添加 'not' 标记
+            i += 3  # 跳过 'not' 的长度
+            continue
+
+        # 将非分隔符字符追加到当前标记中，包括空格
+        current += char
+        i += 1  # 移动到下一个字符
+
+    # 处理最后一个标记（如果有内容）
+    if current.strip():
+        tokens.append(current.strip())
+
+    return tokens  # 返回标记列表
+
+
+
+
+def parse_expression(tokens):
+    """递归下降解析表达式"""
+
+    def parse_or(tokens, pos):
+        """解析 OR 级别（最低优先级）"""
+        left, pos = parse_and(tokens, pos)
+        while pos < len(tokens) and tokens[pos] == 'or':
+            pos += 1
+            if pos >= len(tokens):
+                raise ValueError("Incomplete expression after 'or'")
+            right, pos = parse_and(tokens, pos)
+            left = Node('or', [left, right])
+        return left, pos
+
+    def parse_and(tokens, pos):
+        """解析 AND 级别（次高优先级）"""
+        left, pos = parse_not(tokens, pos)
+        while pos < len(tokens) and tokens[pos] == 'and':
+            pos += 1
+            if pos >= len(tokens):
+                raise ValueError("Incomplete expression after 'and'")
+            right, pos = parse_not(tokens, pos)
+            left = Node('and', [left, right])
+        return left, pos
+
+    def parse_not(tokens, pos):
+        """解析 NOT 级别（最高优先级）"""
+        if pos < len(tokens) and tokens[pos] == 'not':
+            pos += 1
+            if pos >= len(tokens):
+                raise ValueError("Incomplete expression after 'not'")
+            child, pos = parse_primary(tokens, pos)
+            return Node('not', [child]), pos
+        return parse_primary(tokens, pos)
+
+    def parse_primary(tokens, pos):
+        """解析基本单元（条件或括号表达式）"""
+        if pos >= len(tokens):
+            raise ValueError("Unexpected end of expression")
+
+        if tokens[pos] == '(':
+            pos += 1
+            subtree, pos = parse_or(tokens, pos)
+            if pos >= len(tokens) or tokens[pos] != ')':
+                raise ValueError("Missing closing parenthesis")
+            return subtree, pos + 1
+        else:
+            # 假设这是一个条件（如 A=1）
+            return Node(tokens[pos]), pos + 1
+
+    # 从头开始解析
+    tree, pos = parse_or(tokens, 0)
+    if pos < len(tokens):
+        raise ValueError(f"Extra tokens after expression: {tokens[pos:]}")
+    return tree
+
+
+def flatten_tree(node):
+    """清理语法树，将嵌套的同级 and/or 节点展平。
+
+    Args:
+        node (Node): 输入的语法树节点
+
+    Returns:
+        Node: 清理后的新语法树节点
+    """
+    # 如果没有子节点，直接返回原节点（条件节点）
+    if not node.children:
+        return Node(value=node.value, children=[])
+
+    # 递归清理所有子节点
+    cleaned_children = [flatten_tree(child) for child in node.children]
+
+    # 如果当前节点是 'and' 或 'or'，展平嵌套的同类节点
+    if node.value in ('and', 'or'):
+        flattened_children = []
+        for child in cleaned_children:
+            # 如果子节点的值与当前节点相同（例如 'or' 下的 'or'），将其子节点提升
+            if child.value == node.value:
+                flattened_children.extend(child.children)
+            else:
+                flattened_children.append(child)
+        return Node(value=node.value, children=flattened_children)
+
+    # 对于其他节点（例如 'not'），保持结构不变，只更新子节点
+    return Node(value=node.value, children=cleaned_children)
+
+
+def pretty_print_tree(node, indent=0, prefix=""):
+    """生成语法树的格式化字符串表示，带有层次缩进。
+
+    Args:
+        node (Node): 要格式化的语法树节点
+        indent (int): 当前缩进级别（空格数），默认从 0 开始
+        prefix (str): 前缀字符串，用于表示当前行的开头
+
+    Returns:
+        str: 格式化后的树形字符串
+    """
+    # 基本缩进单位
+    spaces = " " * indent
+
+    # 如果没有子节点，返回单行表示
+    if not node.children:
+        return f"{spaces}{prefix}Node(value='{node.value}', children=[])"
+
+    # 构建当前节点的字符串
+    result = [f"{spaces}{prefix}Node(value='{node.value}', children=["]
+
+    # 递归处理每个子节点
+    for i, child in enumerate(node.children):
+        is_last = i == len(node.children) - 1
+        child_prefix = " " if is_last else " "
+        result.append(pretty_print_tree(child, indent + 4, child_prefix))
+
+    # 添加结束括号
+    result.append(f"{spaces}])")
+
+    # 将所有行连接成一个字符串
+    return "\n".join(result)
+
+# 测试代码
+expressions = [
+    "not A=1 and B= 2",
+    "A=1 and (not B=2 or (C=3 or D=4))",
+    "A=1 and not (B=2 or C=3 and D=4 or E=5)",
+    "(A=1 and not (B=2 or C=3 or D=4))",
+    "A=1 and",  # 不完整表达式
+    "and A=1",  # 不完整表达式
+]
+
+for expr in expressions:
+    try:
+        print(f"\nExpression: {expr}")
+        tokens = tokenize(expr)
+        print("Tokens:", tokens)
+        tree = parse_expression(tokens)
+        tree = flatten_tree(tree)
+        tree = pretty_print_tree(tree)
+        print("Tree:", tree)
+    except ValueError as e:
         print(f"Error: {e}")