quantnodes 3.0.0__py3-none-any.whl

QuantNodes/database_node/mysql_node.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+"""MySQL 节点
+
+支持连接池，基于 pymysql + SQLAlchemy
+"""
+from typing import Optional
+
+import pandas as pd
+from sqlalchemy import create_engine, pool
+
+from QuantNodes.database_node.base import BaseDBNode
+
+
+class MySQLNode(BaseDBNode):
+    """MySQL 数据库节点
+
+    支持连接池
+
+    Args:
+        host: 主机地址
+        port: 端口 (默认 3306)
+        user: 用户名
+        passwd: 密码
+        db: 数据库名
+        charset: 字符集 (默认 UTF8)
+        pool_size: 连接池大小 (默认 10，可配置)
+        pool_recycle: 连接回收时间秒 (默认 3600，可配置)
+
+    Example:
+        >>> node = MySQLNode(
+        ...     host="localhost",
+        ...     user="root",
+        ...     passwd="password",
+        ...     db="mydb",
+        ...     pool_size=20
+        ... )
+        >>> node.query("SELECT * FROM users LIMIT 10")
+    """
+
+    def __init__(self, host: str, port: int = 3306,
+                 user: str = '', passwd: str = '', db: str = '',
+                 charset: str = 'UTF8',
+                 pool_size: int = 10,
+                 pool_recycle: int = 3600):
+        self._host = host
+        self._port = port
+        self._user = user
+        self._passwd = passwd
+        self._db = db
+        self._charset = charset
+        self._pool_size = pool_size
+        self._pool_recycle = pool_recycle
+        self._engine = None
+
+    def _build_url(self) -> str:
+        """构建 SQLAlchemy URL"""
+        return (
+            f"mysql+pymysql://{self._user}:{self._passwd}"
+            f"@{self._host}:{self._port}/{self._db}"
+            f"?charset={self._charset}&local_infile=1"
+        )
+
+    def connect(self):
+        """建立连接（返回 SQLAlchemy Engine）"""
+        self._engine = create_engine(
+            self._build_url(),
+            pool_size=self._pool_size,
+            pool_recycle=self._pool_recycle,
+            poolclass=pool.QueuePool,
+        )
+        return self._engine
+
+    def query(self, sql: str, params: Optional[tuple] = None) -> pd.DataFrame:
+        """执行查询"""
+        engine = self._engine or self.connect()
+        return pd.read_sql(sql, engine, params=params)
+
+    def execute(self, sql: str, params: Optional[tuple] = None) -> int:
+        """执行 DDL/DML"""
+        engine = self._engine or self.connect()
+        with engine.connect() as conn:
+            result = conn.execute(sql, params or ())
+            conn.commit()
+            try:
+                return result.rowcount
+            except Exception:
+                return 0
+
+    def insert_df(self, df: pd.DataFrame, table: str,
+                  if_exists: str = 'append') -> int:
+        """插入 DataFrame"""
+        engine = self._engine or self.connect()
+        df.to_sql(table, engine, if_exists=if_exists, index=False)
+        return len(df)
+
+    def disconnect(self) -> None:
+        """关闭连接"""
+        if self._engine:
+            self._engine.dispose()
+            self._engine = None

QuantNodes/database_node/parquet_node.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""Parquet 读取节点
+
+支持 WHERE 子句过滤
+"""
+import os
+from typing import Optional
+
+import pandas as pd
+
+from QuantNodes.database_node.base import BaseDBNode
+
+
+class ParquetNode(BaseDBNode):
+    """Parquet 文件读取节点
+
+    支持 WHERE 子句过滤
+
+    Args:
+        filepath: Parquet 文件绝对路径
+
+    Example:
+        >>> node = ParquetNode("/data/users.parquet")
+        >>> # 全量读取
+        >>> df = node.query()
+        >>> # 带 WHERE 过滤
+        >>> df = node.query("SELECT * WHERE age > 18")
+    """
+
+    def __init__(self, filepath: str):
+        self._filepath = filepath
+        self._data: Optional[pd.DataFrame] = None
+
+    def connect(self) -> pd.DataFrame:
+        """读取 Parquet 到内存"""
+        self._data = pd.read_parquet(self._filepath)
+        return self._data
+
+    def query(self, sql: Optional[str] = None, params: Optional[tuple] = None) -> pd.DataFrame:
+        """执行查询
+
+        Args:
+            sql: SQL 查询语句（可选），支持 WHERE 子句
+            params: 查询参数（暂未使用）
+
+        Returns:
+            pd.DataFrame 查询结果
+        """
+        data = self._data or self.connect()
+
+        if sql is None:
+            return data
+
+        if 'WHERE' in sql.upper():
+            where_clause = sql.split('WHERE', 1)[1].strip()
+            return data.query(where_clause)
+
+        return data
+
+    def execute(self, sql: str, params: Optional[tuple] = None) -> int:
+        """Parquet 节点不支持 execute"""
+        raise NotImplementedError("ParquetNode 不支持 execute 操作")
+
+    def insert_df(self, df: pd.DataFrame, table: str,
+                  if_exists: str = 'append') -> int:
+        """Parquet 节点不支持 insert"""
+        raise NotImplementedError("ParquetNode 不支持 insert 操作")
+
+    def disconnect(self) -> None:
+        """释放内存"""
+        self._data = None
+
+    def health_check(self) -> bool:
+        """健康检查"""
+        return os.path.exists(self._filepath)

QuantNodes/database_node/sqlite_node.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""SQLite 节点
+
+支持内存模式和文件模式
+"""
+import sqlite3
+from typing import Optional
+
+import pandas as pd
+
+from QuantNodes.database_node.base import BaseDBNode
+
+
+class SQLiteNode(BaseDBNode):
+    """SQLite 数据库节点
+
+    支持内存模式 (`:memory:`) 和文件模式 (绝对路径)
+
+    Args:
+        database: 数据库路径，`:memory:` 表示内存模式，
+                 绝对路径表示文件模式
+
+    Example:
+        >>> # 内存模式
+        >>> node = SQLiteNode(":memory:")
+        >>> node.connect()
+        >>> node.execute("CREATE TABLE test (id INT, name TEXT)")
+        >>> node.query("SELECT * FROM test")
+
+        >>> # 文件模式
+        >>> node = SQLiteNode("/data/mydb.sqlite")
+    """
+
+    def __init__(self, database: str = ":memory:"):
+        self._database = database
+        self._conn: Optional[sqlite3.Connection] = None
+
+    def connect(self) -> sqlite3.Connection:
+        """建立 SQLite 连接"""
+        self._conn = sqlite3.connect(self._database)
+        return self._conn
+
+    def query(self, sql: str, params: Optional[tuple] = None) -> pd.DataFrame:
+        """执行查询"""
+        conn = self._conn or self.connect()
+        return pd.read_sql(sql, conn, params=params)
+
+    def execute(self, sql: str, params: Optional[tuple] = None) -> int:
+        """执行 DDL/DML"""
+        conn = self._conn or self.connect()
+        cur = conn.cursor()
+        cur.execute(sql, params or ())
+        conn.commit()
+        return cur.rowcount
+
+    def insert_df(self, df: pd.DataFrame, table: str,
+                  if_exists: str = 'append') -> int:
+        """插入 DataFrame"""
+        df.to_sql(table, self._conn or self.connect(),
+                  if_exists=if_exists, index=False)
+        return len(df)
+
+    def disconnect(self) -> None:
+        """关闭连接"""
+        if self._conn:
+            self._conn.close()
+            self._conn = None

QuantNodes/factor_node/__init__.py

@@ -0,0 +1,50 @@
+# coding=utf-8
+"""因子节点模块
+
+提供因子数据库、因子表、因子类和因子运算功能。
+"""
+from QuantNodes.factor_node.factor_db import FactorDB, WritableFactorDB
+from QuantNodes.factor_node.factor_table import FactorTable, CustomFT
+from QuantNodes.factor_node.factor import Factor, DataFactor, Factorize
+from QuantNodes.factor_node.factor_operation import (
+    DerivativeFactor,
+    PointOperation,
+    TimeOperation,
+    SectionOperation,
+    PanelOperation,
+)
+
+from QuantNodes.factor_node.quant_nodes_object import QuantNodesObject
+
+from QuantNodes.factor_node import factor_functions as ff
+
+__all__ = [
+    # factor_db
+    'FactorDB',
+    'WritableFactorDB',
+
+    # factor_table
+    'FactorTable',
+    'CustomFT',
+
+    # factor
+    'Factor',
+    'DataFactor',
+    'Factorize',
+
+    # factor_operation
+    'DerivativeFactor',
+    'PointOperation',
+    'TimeOperation',
+    'SectionOperation',
+    'PanelOperation',
+
+    # operations (moved from core/)
+    'QuantNodesObject',
+
+    # factor_functions
+    'ff',
+]
+
+if __name__ == '__main__':
+    pass