quantnodes 3.0.0__py3-none-any.whl

QuantNodes/symbolic/optimizer.py

@@ -0,0 +1,165 @@
+# coding=utf-8
+"""
+符号计算引擎 - AST 优化器
+
+对 SQLExpression AST 进行优化，如常量折叠、死代码消除等。
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Set
+
+if TYPE_CHECKING:
+    from QuantNodes.symbolic.expression import SQLExpression
+
+
+class SQLOptimizer:
+    """
+    SQL AST 优化器
+
+    对表达式进行各种优化：
+    - 常量折叠
+    - 冗余括号消除
+    - 恒等变换
+    """
+
+    def __init__(self):
+        self._visited: Set[int] = set()
+
+    def optimize(self, expr: "SQLExpression") -> "SQLExpression":
+        """
+        优化表达式
+
+        Args:
+            expr: 输入表达式
+
+        Returns:
+            优化后的表达式
+        """
+        from QuantNodes.symbolic.expression import (
+            ColumnRef, LiteralValue, SQLBinaryOp, SQLUnaryOp,
+            SQLComparison, SQLLogicalOp, SQLFunction, SQLCase,
+        )
+
+        if id(expr) in self._visited:
+            return expr
+
+        self._visited.add(id(expr))
+
+        if isinstance(expr, ColumnRef):
+            return expr
+        if isinstance(expr, LiteralValue):
+            return expr
+        if isinstance(expr, SQLBinaryOp):
+            return self._optimize_binary_op(expr)
+        if isinstance(expr, SQLUnaryOp):
+            return self._optimize_unary_op(expr)
+        if isinstance(expr, SQLComparison):
+            return self._optimize_comparison(expr)
+        if isinstance(expr, SQLLogicalOp):
+            return self._optimize_logical_op(expr)
+        if isinstance(expr, SQLFunction):
+            return self._optimize_function(expr)
+        if isinstance(expr, SQLCase):
+            return self._optimize_case(expr)
+
+        return expr
+
+    def _optimize_binary_op(self, expr: "SQLBinaryOp") -> "SQLExpression":  # noqa: F821
+        """优化二元运算"""
+        left = self.optimize(expr.left)
+        right = self.optimize(expr.right)
+
+        from QuantNodes.symbolic.expression import LiteralValue, SQLBinaryOp
+
+        if isinstance(left, LiteralValue) and isinstance(right, LiteralValue):
+            return self._fold_binary_op(expr.op, left.value, right.value)
+
+        if expr.op == "+" and isinstance(right, LiteralValue) and right.value == 0:
+            return left
+        if expr.op == "-" and isinstance(right, LiteralValue) and right.value == 0:
+            return left
+        if expr.op == "*" and isinstance(right, LiteralValue) and right.value == 1:
+            return left
+        if expr.op == "*" and isinstance(left, LiteralValue) and left.value == 1:
+            return right
+        if expr.op == "/" and isinstance(right, LiteralValue) and right.value == 1:
+            return left
+
+        return SQLBinaryOp(left, expr.op, right)
+
+    def _optimize_unary_op(self, expr: "SQLUnaryOp") -> "SQLExpression":  # noqa: F821
+        """优化一元运算"""
+        from QuantNodes.symbolic.expression import LiteralValue, SQLUnaryOp
+        operand = self.optimize(expr.operand)
+
+        if isinstance(operand, LiteralValue):
+            return self._fold_unary_op(expr.op, operand.value)
+
+        return SQLUnaryOp(expr.op, operand)
+
+    def _optimize_comparison(self, expr: "SQLComparison") -> "SQLExpression":  # noqa: F821
+        """优化比较运算"""
+        left = self.optimize(expr.left)  # noqa: F841 (placeholder for future folding)
+        right = self.optimize(expr.right)  # noqa: F841
+        return expr
+
+    def _optimize_logical_op(self, expr: "SQLLogicalOp") -> "SQLExpression":  # noqa: F821
+        """优化逻辑运算"""
+        from QuantNodes.symbolic.expression import LiteralValue, SQLLogicalOp
+        operands = [self.optimize(op) for op in expr.operands]
+
+        if expr.op == "AND":
+            for op in operands:
+                if isinstance(op, LiteralValue) and not op.value:
+                    return LiteralValue(False)
+        if expr.op == "OR":
+            for op in operands:
+                if isinstance(op, LiteralValue) and op.value:
+                    return LiteralValue(True)
+
+        return SQLLogicalOp(expr.op, *operands)
+
+    def _optimize_function(self, expr: "SQLFunction") -> "SQLExpression":  # noqa: F821
+        """优化函数调用"""
+        args = [self.optimize(arg) for arg in expr.args]  # noqa: F841 (placeholder)
+        kwargs = {k: self.optimize(v) for k, v in expr.kwargs.items()}  # noqa: F841
+        return expr
+
+    def _optimize_case(self, expr: "SQLCase") -> "SQLExpression":  # noqa: F821
+        """优化 CASE 表达式"""
+        return expr
+
+    def _fold_binary_op(self, op: str, a: Any, b: Any) -> "SQLExpression":
+        """常量折叠 - 二元运算"""
+        from QuantNodes.symbolic.expression import LiteralValue
+        try:
+            if op == "+":
+                return LiteralValue(a + b)
+            if op == "-":
+                return LiteralValue(a - b)
+            if op == "*":
+                return LiteralValue(a * b)
+            if op == "/":
+                return LiteralValue(a / b)
+        except Exception:
+            pass
+        return None
+
+    def _fold_unary_op(self, op: str, a: Any) -> "SQLExpression":
+        """常量折叠 - 一元运算"""
+        from QuantNodes.symbolic.expression import LiteralValue
+        try:
+            if op == "-":
+                return LiteralValue(-a)
+            if op == "+":
+                return LiteralValue(+a)
+        except Exception:
+            pass
+        return None
+
+
+def optimize_expression(expr: "SQLExpression") -> "SQLExpression":
+    """便捷函数：优化表达式"""
+    optimizer = SQLOptimizer()
+    return optimizer.optimize(expr)

QuantNodes/ui_node/__init__.py

@@ -0,0 +1,30 @@
+# coding=utf-8
+"""
+DisplayNode - 数据可视化节点模块
+
+提供通用数据可视化节点，用于 Pipeline 中数据预处理。
+"""
+from QuantNodes.ui_node.base import (
+    VisualizationType,
+    VisualizationData,
+    DisplayNode,
+    TableDisplayNode,
+    ChartDisplayNode,
+    MetricDisplayNode,
+    TextDisplayNode,
+)
+
+__all__ = [
+    "VisualizationType",
+    "VisualizationData",
+    "DisplayNode",
+    "TableDisplayNode",
+    "ChartDisplayNode",
+    "MetricDisplayNode",
+    "TextDisplayNode",
+]
+
+# 向后兼容别名
+DisplayType = VisualizationType
+UIDisplayResult = VisualizationData
+UINode = DisplayNode

QuantNodes/ui_node/base.py

@@ -0,0 +1,222 @@
+# coding=utf-8
+"""
+DisplayNode - 数据可视化节点模块
+
+提供通用数据可视化节点，将处理后的数据转换为前端可用的格式。
+支持表格、图表、指标、文本等可视化类型。
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+import pandas as pd
+
+from QuantNodes.core.node import BaseNode
+
+
+class VisualizationType(str, Enum):
+    """可视化类型枚举"""
+    TABLE = "table"
+    CHART = "chart"
+    METRIC = "metric"
+    TEXT = "text"
+    IMAGE = "image"
+
+
+@dataclass
+class VisualizationData:
+    """可视化数据容器"""
+    viz_type: VisualizationType = VisualizationType.TABLE
+    title: str = ""
+    data: Any = None
+    columns: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class DisplayNode(BaseNode[Any, VisualizationData], ABC):
+    """
+    数据可视化节点基类
+
+    提供统一的数据可视化接口，将处理后的数据转换为可视化格式。
+
+    Subclasses must implement:
+        _prepare_data(): 准备可视化数据
+    """
+
+    _enable_validation: bool = False
+    _enable_stats: bool = True
+
+    def __init__(self, name: str = None, config: Dict[str, Any] = None, **kwargs):
+        super().__init__(name=name or self.__class__.__name__, config=config, **kwargs)
+        self._viz_data: Optional[VisualizationData] = None
+
+    @abstractmethod
+    def _prepare_data(self, input_data: Any, **kwargs) -> VisualizationData:
+        """
+        准备可视化数据
+
+        Args:
+            input_data: 输入数据
+            **kwargs: 额外参数
+
+        Returns:
+            可视化数据
+        """
+        pass
+
+    def _execute(self, input_data: Any = None, **kwargs) -> VisualizationData:
+        """
+        执行可视化数据准备
+
+        Args:
+            input_data: 输入数据
+            **kwargs: 额外参数
+
+        Returns:
+            可视化数据
+        """
+        self._viz_data = self._prepare_data(input_data, **kwargs)
+        return self._viz_data
+
+
+class TableDisplayNode(DisplayNode):
+    """
+    表格显示节点
+
+    将 DataFrame 或类表格数据转换为表格可视化格式。
+    """
+
+    def __init__(
+        self,
+        name: str = None,
+        config: Dict[str, Any] = None,
+        title: str = "",
+        **kwargs
+    ):
+        super().__init__(name=name or "TableDisplay", config=config, **kwargs)
+        self.title = title
+
+    def _prepare_data(self, input_data: Any, **kwargs) -> VisualizationData:
+        """准备表格数据"""
+        if isinstance(input_data, pd.DataFrame):
+            data = input_data
+            columns = list(input_data.columns)
+        elif isinstance(input_data, dict):
+            data = pd.DataFrame([input_data])
+            columns = list(input_data.keys())
+        else:
+            data = input_data
+            columns = []
+
+        return VisualizationData(
+            viz_type=VisualizationType.TABLE,
+            title=self.title,
+            data=data,
+            columns=columns,
+            metadata={}
+        )
+
+
+class ChartDisplayNode(DisplayNode):
+    """
+    图表显示节点
+
+    将数据转换为图表可视化格式（Line/Bar/Area/Pie）。
+    """
+
+    CHART_TYPES = ["line", "bar", "area", "pie", "scatter"]
+
+    def __init__(
+        self,
+        name: str = None,
+        config: Dict[str, Any] = None,
+        title: str = "",
+        chart_type: str = "line",
+        **kwargs
+    ):
+        super().__init__(name=name or "ChartDisplay", config=config, **kwargs)
+        self.title = title
+        self.chart_type = chart_type if chart_type in self.CHART_TYPES else "line"
+
+    def _prepare_data(self, input_data: Any, **kwargs) -> VisualizationData:
+        """准备图表数据"""
+        if isinstance(input_data, pd.DataFrame):
+            data = input_data
+        elif isinstance(input_data, dict):
+            data = pd.DataFrame([input_data])
+        else:
+            data = input_data
+
+        return VisualizationData(
+            viz_type=VisualizationType.CHART,
+            title=self.title,
+            data=data,
+            metadata={"chart_type": self.chart_type}
+        )
+
+
+class MetricDisplayNode(DisplayNode):
+    """
+    指标显示节点
+
+    将单个或多个指标值转换为指标可视化格式。
+    """
+
+    def __init__(
+        self,
+        name: str = None,
+        config: Dict[str, Any] = None,
+        title: str = "",
+        **kwargs
+    ):
+        super().__init__(name=name or "MetricDisplay", config=config, **kwargs)
+        self.title = title
+
+    def _prepare_data(self, input_data: Any, **kwargs) -> VisualizationData:
+        """准备指标数据"""
+        value = input_data
+        metadata = {}
+
+        if isinstance(input_data, dict):
+            value = input_data.get('value', input_data)
+            if 'delta' in input_data:
+                metadata['delta'] = input_data['delta']
+            if 'description' in input_data:
+                metadata['description'] = input_data['description']
+
+        return VisualizationData(
+            viz_type=VisualizationType.METRIC,
+            title=self.title,
+            data=value,
+            metadata=metadata
+        )
+
+
+class TextDisplayNode(DisplayNode):
+    """
+    文本显示节点
+
+    将文本内容转换为文本可视化格式。
+    """
+
+    def __init__(
+        self,
+        name: str = None,
+        config: Dict[str, Any] = None,
+        title: str = "",
+        **kwargs
+    ):
+        super().__init__(name=name or "TextDisplay", config=config, **kwargs)
+        self.title = title
+
+    def _prepare_data(self, input_data: Any, **kwargs) -> VisualizationData:
+        """准备文本数据"""
+        return VisualizationData(
+            viz_type=VisualizationType.TEXT,
+            title=self.title,
+            data=input_data,
+            metadata={}
+        )