powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/factor/computation/operators/time_series_operator.py

@@ -0,0 +1,342 @@
+# Derived from vn.py fa5206fe63836f3f8cd1ebd7168fbd19a5e2ff09.
+# Copyright (c) 2015-present, Xiaoyou Chen. MIT; see app/factor/LICENSE.vnpy.
+"""Time Series Operators"""
+
+from typing import cast
+
+import numpy as np
+import polars as pl
+from scipy import stats
+
+from quant_core.app.factor.computation.panel_expression import PanelExpression
+
+
+def ts_delay(feature: PanelExpression, window: int) -> PanelExpression:
+    """Get the value from a fixed time in the past"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"), pl.col("vt_symbol"), pl.col("data").shift(window).over("vt_symbol")
+    )
+    return PanelExpression(df)
+
+
+def ts_min(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the minimum value over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_min(window, min_samples=1).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_max(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the maximum value over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_max(window, min_samples=1).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_argmax(feature: PanelExpression, window: int) -> PanelExpression:
+    """Return the index of the maximum value over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_map(lambda s: cast(int, s.arg_max()) + 1, window).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_argmin(feature: PanelExpression, window: int) -> PanelExpression:
+    """Return the index of the minimum value over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_map(lambda s: cast(int, s.arg_min()) + 1, window).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_rank(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the percentile rank of the current value within the window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data")
+        .rolling_map(lambda s: stats.percentileofscore(s, s[-1]) / 100, window)
+        .over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_sum(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the sum over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_sum(window).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_mean(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the mean over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data")
+        .rolling_map(lambda s: np.nanmean(s), window, min_samples=1)
+        .over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_std(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the standard deviation over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data")
+        .rolling_map(lambda s: np.nanstd(s, ddof=0), window, min_samples=1)
+        .over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_slope(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the slope of linear regression over a rolling window (optimized)"""
+    # 预计算 x 相关的常数 (x = 0, 1, 2, ..., window-1)
+    n = window
+    sum_x = n * (n - 1) / 2  # 等差数列求和
+    sum_x2 = (n - 1) * n * (2 * n - 1) / 6  # 平方和公式
+    denominator = n * sum_x2 - sum_x * sum_x
+
+    # 计算 sum(i * y[t-window+1+i]) for i in 0..window-1
+    # 等价于 sum((window-1-j) * y[t-j]) for j in 0..window-1
+    sum_xy_expr: pl.Expr = pl.sum_horizontal(
+        [(window - 1 - j) * pl.col("data").shift(j) for j in range(window)]
+    )
+
+    df: pl.DataFrame = feature.df.with_columns(
+        [
+            pl.col("data").rolling_sum(window, min_samples=window).over("vt_symbol").alias("sum_y"),
+            sum_xy_expr.over("vt_symbol").alias("sum_xy"),
+        ]
+    )
+
+    df = df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        ((n * pl.col("sum_xy") - sum_x * pl.col("sum_y")) / denominator).alias("data"),
+    )
+    return PanelExpression(df)
+
+
+def ts_quantile(feature: PanelExpression, window: int, quantile: float) -> PanelExpression:
+    """Calculate the quantile value over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data")
+        .rolling_map(lambda s: s.quantile(quantile=quantile, interpolation="linear"), window)
+        .over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_rsquare(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the R-squared value of linear regression over a rolling window (optimized)"""
+    # 预计算 x 相关的常数 (x = 0, 1, 2, ..., window-1)
+    n = window
+    sum_x2 = (n - 1) * n * (2 * n - 1) / 6  # 平方和公式
+    mean_x = (n - 1) / 2
+    var_x = sum_x2 / n - mean_x * mean_x  # 总体方差
+
+    # 计算 sum(i * y[t-window+1+i]) for i in 0..window-1
+    sum_xy_expr: pl.Expr = pl.sum_horizontal(
+        [(window - 1 - j) * pl.col("data").shift(j) for j in range(window)]
+    )
+
+    df: pl.DataFrame = feature.df.with_columns(
+        [
+            pl.col("data").rolling_sum(window, min_samples=window).over("vt_symbol").alias("sum_y"),
+            pl.col("data")
+            .rolling_var(window, min_samples=window, ddof=0)
+            .over("vt_symbol")
+            .alias("var_y"),
+            sum_xy_expr.over("vt_symbol").alias("sum_xy"),
+        ]
+    )
+
+    # mean_y 和 cov(x, y) = E(xy) - E(x)E(y)
+    df = df.with_columns(
+        [
+            (pl.col("sum_y") / n).alias("mean_y"),
+        ]
+    )
+
+    df = df.with_columns([(pl.col("sum_xy") / n - mean_x * pl.col("mean_y")).alias("cov_xy")])
+
+    # r = cov(x,y) / (std_x * std_y), r^2 = cov(x,y)^2 / (var_x * var_y)
+    df = df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        (pl.col("cov_xy").pow(2) / (var_x * pl.col("var_y"))).alias("data"),
+    )
+
+    df = df.with_columns(
+        pl.when(pl.col("data").is_infinite() | pl.col("data").is_nan())
+        .then(None)
+        .otherwise(pl.col("data"))
+        .alias("data")
+    )
+
+    return PanelExpression(df)
+
+
+def ts_resi(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the residual of linear regression over a rolling window (optimized)"""
+    # 预计算 x 相关的常数 (x = 0, 1, 2, ..., window-1)
+    n = window
+    sum_x = n * (n - 1) / 2  # 等差数列求和
+    sum_x2 = (n - 1) * n * (2 * n - 1) / 6  # 平方和公式
+    mean_x = (n - 1) / 2
+    denominator = n * sum_x2 - sum_x * sum_x
+
+    # 计算 sum(i * y[t-window+1+i]) for i in 0..window-1
+    sum_xy_expr: pl.Expr = pl.sum_horizontal(
+        [(window - 1 - j) * pl.col("data").shift(j) for j in range(window)]
+    )
+
+    df: pl.DataFrame = feature.df.with_columns(
+        [
+            pl.col("data").rolling_sum(window, min_samples=window).over("vt_symbol").alias("sum_y"),
+            sum_xy_expr.over("vt_symbol").alias("sum_xy"),
+        ]
+    )
+
+    # 计算 slope 和 intercept
+    df = df.with_columns(
+        [
+            ((n * pl.col("sum_xy") - sum_x * pl.col("sum_y")) / denominator).alias("slope"),
+            (pl.col("sum_y") / n).alias("mean_y"),
+        ]
+    )
+
+    df = df.with_columns([(pl.col("mean_y") - pl.col("slope") * mean_x).alias("intercept")])
+
+    # residual = y - (slope * (n-1) + intercept)，最后一个点的 x = n-1
+    df = df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        (pl.col("data") - (pl.col("slope") * (n - 1) + pl.col("intercept"))).alias("data"),
+    )
+
+    return PanelExpression(df)
+
+
+def ts_corr(feature1: PanelExpression, feature2: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the correlation between two features over a rolling window"""
+    df_merged: pl.DataFrame = feature1.df.join(feature2.df, on=["datetime", "vt_symbol"])
+
+    df: pl.DataFrame = df_merged.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.rolling_corr("data", "data_right", window_size=window, min_samples=1)
+        .over("vt_symbol")
+        .alias("data"),
+    )
+
+    df = df.with_columns(
+        pl.when(pl.col("data").is_infinite()).then(None).otherwise(pl.col("data")).alias("data")
+    )
+
+    return PanelExpression(df)
+
+
+def ts_less(feature1: PanelExpression, feature2: PanelExpression | float) -> PanelExpression:
+    """Return the minimum value between two features"""
+    if isinstance(feature2, PanelExpression):
+        df_merged: pl.DataFrame = feature1.df.join(feature2.df, on=["datetime", "vt_symbol"])
+    else:
+        df_merged = feature1.df.with_columns(pl.lit(feature2).alias("data_right"))
+
+    df: pl.DataFrame = df_merged.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.min_horizontal("data", "data_right").over("vt_symbol").alias("data"),
+    )
+
+    return PanelExpression(df)
+
+
+def ts_greater(feature1: PanelExpression, feature2: PanelExpression | float) -> PanelExpression:
+    """Return the maximum value between two features"""
+    if isinstance(feature2, PanelExpression):
+        df_merged: pl.DataFrame = feature1.df.join(feature2.df, on=["datetime", "vt_symbol"])
+
+    else:
+        df_merged = feature1.df.with_columns(pl.lit(feature2).alias("data_right"))
+
+    df: pl.DataFrame = df_merged.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.max_horizontal("data", "data_right").over("vt_symbol").alias("data"),
+    )
+
+    return PanelExpression(df)
+
+
+def ts_log(feature: PanelExpression) -> PanelExpression:
+    """Calculate the natural logarithm of the feature"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"), pl.col("vt_symbol"), pl.col("data").log().over("vt_symbol")
+    )
+    return PanelExpression(df)
+
+
+def ts_abs(feature: PanelExpression) -> PanelExpression:
+    """Calculate the absolute value of the feature"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"), pl.col("vt_symbol"), pl.col("data").abs().over("vt_symbol")
+    )
+    return PanelExpression(df)
+
+
+def ts_delta(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate difference between current value and value from window periods ago"""
+    return feature - ts_delay(feature, window)
+
+
+def ts_cov(feature1: PanelExpression, feature2: PanelExpression, window: int) -> PanelExpression:
+    """Calculate covariance between two features over a rolling window"""
+    return ts_corr(feature1, feature2, window) * ts_std(feature1, window) * ts_std(feature2, window)
+
+
+def ts_decay_linear(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate linear decay weighted average"""
+
+    def decay_func(s: pl.Series) -> float:
+        """Calculate linear decay weighted average for a series"""
+        weights = pl.Series(range(window, 0, -1))
+        denominator: int = window * (window + 1) // 2
+        return float((s * weights).sum() / denominator)
+
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_map(lambda s: decay_func(s), window).over("vt_symbol"),
+    )
+    return PanelExpression(df)
+
+
+def ts_product(feature: PanelExpression, window: int) -> PanelExpression:
+    """Calculate the product over a rolling window"""
+    df: pl.DataFrame = feature.df.select(
+        pl.col("datetime"),
+        pl.col("vt_symbol"),
+        pl.col("data").rolling_map(lambda s: s.product(), window).over("vt_symbol"),
+    )
+    return PanelExpression(df)

quant_core/app/factor/computation/panel_evaluator.py

@@ -0,0 +1,59 @@
+"""可信本地 Python 面板执行器，统一输出数值与键校验。"""
+
+from collections import deque
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any
+
+import polars as pl
+
+from quant_core.app.factor.computation.panel_expression import PanelExpression
+from quant_core.app.factor.computation.universe_filter import ELIGIBLE_KEYS
+from quant_core.app.factor.schema.factor_panel import FactorPanel
+from quant_core.app.factor.schema.factor_result_schema import PanelValues
+
+
+def evaluate_panel(
+    panel: FactorPanel,
+    recipe: Callable[[dict[str, PanelExpression]], PanelExpression],
+    lookback: int,
+    required: tuple[str, ...],
+) -> PanelValues:
+    """运行固定 Python 配方；缺字段、零成交和预热不足保持显式缺值。"""
+    rows = sorted(panel.rows, key=lambda row: (row.as_of, row.instrument_id))
+    if not rows:
+        return {}
+    columns: dict[str, Any] = {
+        "datetime": [row.as_of for row in rows],
+        "vt_symbol": [row.instrument_id for row in rows],
+    }
+    for field in required:
+        columns[field] = [
+            float(value) if (value := row.fields.get(field)) is not None else None for row in rows
+        ]
+    frame = pl.DataFrame(columns, schema_overrides={field: pl.Float64 for field in required})
+    fields = {
+        field: PanelExpression(frame.select("datetime", "vt_symbol", field)) for field in required
+    }
+    keys = frozenset((row.as_of, row.instrument_id) for row in rows if row.eligible)
+    token = ELIGIBLE_KEYS.set(keys)
+    try:
+        result = recipe(fields).df
+    finally:
+        ELIGIBLE_KEYS.reset(token)
+    history: dict[str, int] = {}
+    validity: dict[str, deque[bool]] = {}
+    values: PanelValues = {}
+    source = {(row.as_of, row.instrument_id): row for row in rows}
+    for timestamp, instrument_id, raw in result.iter_rows():
+        key = (timestamp, instrument_id)
+        history[instrument_id] = history.get(instrument_id, 0) + 1
+        window = validity.setdefault(instrument_id, deque(maxlen=lookback))
+        window.append(all(source[key].fields.get(field) is not None for field in required))
+        value = Decimal(str(raw)) if raw is not None else None
+        if not source[key].eligible or history[instrument_id] < lookback or not all(window):
+            value = None
+        if value is not None and not value.is_finite():
+            value = None
+        values[key] = value
+    return values

quant_core/app/factor/computation/panel_expression.py

@@ -0,0 +1,193 @@
+"""向量算子的数据代理；不包含表达式求值器。"""
+# Derived from vn.py fa5206fe63836f3f8cd1ebd7168fbd19a5e2ff09.
+# Copyright (c) 2015-present, Xiaoyou Chen. MIT; see app/factor/LICENSE.vnpy.
+
+from numbers import Real
+from typing import Union, cast
+
+import polars as pl
+
+
+class PanelExpression:
+    """Feature data proxy"""
+
+    def __init__(self, df: pl.DataFrame) -> None:
+        """Constructor"""
+        self.name: str = df.columns[-1]
+        self.df: pl.DataFrame = df.rename({self.name: "data"})
+
+        # Note that for numerical expressions, variables should be placed before numbers. e.g. a * 2
+
+    @staticmethod
+    def _as_series(value: object) -> pl.Series:
+        """Normalize an operator result to a Polars series."""
+        if isinstance(value, pl.Series):
+            return value
+
+        return cast(pl.Series, value)
+
+    def _comparison_series(self, value: object) -> pl.Series:
+        """Normalize comparison results to an Int32 series."""
+        if isinstance(value, pl.Series):
+            return value.cast(pl.Int32)
+
+        if isinstance(value, bool):
+            return pl.Series(name="data", values=[int(value)] * len(self.df))
+
+        if isinstance(value, Real):
+            return pl.Series(name="data", values=[int(bool(value))] * len(self.df))
+
+        raise TypeError(f"Unsupported comparison result type: {type(value)!r}")
+
+    def result(self, s: pl.Series) -> "PanelExpression":
+        """Convert series data to feature object"""
+        result: pl.DataFrame = self.df[["datetime", "vt_symbol"]]
+        result = result.with_columns(other=s)
+
+        return PanelExpression(result)
+
+    def __add__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Addition operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] + other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] + other)
+        return self.result(s)
+
+    def __radd__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Right addition operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(other.df["data"] + self.df["data"])
+        else:
+            s = self._as_series(other + self.df["data"])
+        return self.result(s)
+
+    def __sub__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Subtraction operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] - other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] - other)
+        return self.result(s)
+
+    def __rsub__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Right subtraction operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(other.df["data"] - self.df["data"])
+        else:
+            s = self._as_series(other - self.df["data"])
+        return self.result(s)
+
+    def __mul__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Multiplication operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] * other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] * other)
+        return self.result(s)
+
+    def __rmul__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Right multiplication operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] * other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] * other)
+        return self.result(s)
+
+    def __truediv__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Division operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] / other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] / other)
+        return self.result(s)
+
+    def __rtruediv__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Right division operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(other.df["data"] / self.df["data"])
+        else:
+            s = self._as_series(other / self.df["data"])
+        return self.result(s)
+
+    def __floordiv__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Floor division operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] // other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] // other)
+        return self.result(s)
+
+    def __mod__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Modulo operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"] % other.df["data"])
+        else:
+            s = self._as_series(self.df["data"] % other)
+        return self.result(s)
+
+    def __pow__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Power operation"""
+        if isinstance(other, PanelExpression):
+            s = self._as_series(self.df["data"].pow(other.df["data"]))
+        else:
+            s = self._as_series(self.df["data"].pow(cast(int | float, other)))
+        return self.result(s)
+
+    def __abs__(self) -> "PanelExpression":
+        """Get absolute value"""
+        s: pl.Series = self.df["data"].abs()
+        return self.result(s)
+
+    def __neg__(self) -> "PanelExpression":
+        """Negation operation"""
+        s: pl.Series = -self.df["data"]
+        return self.result(s)
+
+    def __gt__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Greater than comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] > other.df["data"]
+        else:
+            s = self.df["data"] > other
+        return self.result(self._comparison_series(s))
+
+    def __ge__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Greater than or equal comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] >= other.df["data"]
+        else:
+            s = self.df["data"] >= other
+        return self.result(self._comparison_series(s))
+
+    def __lt__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Less than comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] < other.df["data"]
+        else:
+            s = self.df["data"] < other
+        return self.result(self._comparison_series(s))
+
+    def __le__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":
+        """Less than or equal comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] <= other.df["data"]
+        else:
+            s = self.df["data"] <= other
+        return self.result(self._comparison_series(s))
+
+    def __eq__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":  # type: ignore[override]
+        """Equal comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] == other.df["data"]
+        else:
+            s = self.df["data"] == other
+        return self.result(self._comparison_series(s))
+
+    def __ne__(self, other: Union["PanelExpression", Real, int, float]) -> "PanelExpression":  # type: ignore[override]
+        """Not equal comparison"""
+        if isinstance(other, PanelExpression):
+            s: object = self.df["data"] != other.df["data"]
+        else:
+            s = self.df["data"] != other
+        return self.result(self._comparison_series(s))

quant_core/app/factor/computation/python_factor_executor.py

@@ -0,0 +1,87 @@
+"""Trusted local Python execution for user-authored factors."""
+
+from collections.abc import Callable
+from decimal import Decimal, InvalidOperation
+from types import CodeType
+from typing import Any
+
+from quant_core.app.data.schema.market_schema import BarResponse
+from quant_core.app.factor.schema.factor_computation_schema import FactorComputationSpec
+from quant_core.app.factor.schema.factor_panel import FactorPanel
+from quant_core.app.factor.schema.factor_result_schema import PanelValues
+
+
+def _load_function(source: str, name: str, compiled: dict[str, CodeType]) -> Callable[..., Any]:
+    """复用编译结果，每次执行仍使用独立命名空间；仅用于可信代码。"""
+    if len(source.encode("utf-8")) > 65536:
+        raise ValueError("因子源码超过 64 KiB")
+    if source not in compiled:
+        compiled[source] = compile(source, "<factor>", "exec")
+    namespace: dict[str, Any] = {
+        "__name__": "factor_panel_user_code" if name == "compute_panel" else "factor_user_code"
+    }
+    exec(compiled[source], namespace)
+    function = namespace.get(name)
+    if not callable(function):
+        raise ValueError(f"因子源码必须定义 {name}")
+    return function
+
+
+def _factor_number(value: Any) -> Decimal | None:
+    if value is None:
+        return None
+    try:
+        number = Decimal(str(value))
+    except (InvalidOperation, ValueError) as exc:
+        raise ValueError("因子计算结果不是数值") from exc
+    if not number.is_finite():
+        raise ValueError("因子计算结果必须为有限数值")
+    return number
+
+
+def execute_python_windows(
+    calls: list[tuple[str, list[BarResponse], dict[str, Any]]],
+) -> list[Decimal | None]:
+    """执行独立证券窗口函数，保留 Decimal 精度与逐次全局变量隔离。"""
+    compiled: dict[str, CodeType] = {}
+    results: list[Decimal | None] = []
+    for source, bars, parameters in calls:
+        compute = _load_function(source, "compute", compiled)
+        input_bars = [
+            {
+                "timestamp": bar.timestamp.isoformat(),
+                "open": str(bar.open),
+                "high": str(bar.high),
+                "low": str(bar.low),
+                "close": str(bar.close),
+                "volume": str(bar.volume),
+                "amount": str(bar.amount) if bar.amount is not None else None,
+                "previous_close": (
+                    str(bar.previous_close) if bar.previous_close is not None else None
+                ),
+                "suspended": bar.suspended,
+            }
+            for bar in bars
+        ]
+        results.append(_factor_number(compute(input_bars, dict(parameters))))
+    return results
+
+
+def execute_python_panel(spec: FactorComputationSpec, panel: FactorPanel) -> PanelValues:
+    """执行完整横截面函数并校验结果键和有限数值。"""
+    problems = spec.validate_definition()
+    if spec.input_kind != "panel" or problems:
+        raise ValueError(f"面板计算规格非法: {problems}")
+    if spec.frequency.value != panel.frequency:
+        raise ValueError("面板输入与因子频率不一致")
+    compute = _load_function(spec.python_source, "compute_panel", {})
+    result = compute(panel, dict(spec.parameters))
+    if not isinstance(result, dict):
+        raise ValueError("compute_panel 必须返回 (as_of, instrument_id) 到数值的映射")
+    expected = {(row.as_of, row.instrument_id) for row in panel.rows}
+    if set(result) != expected:
+        raise ValueError("面板结果必须完整覆盖输入键，不允许多出或遗漏")
+    values: PanelValues = {}
+    for key, raw in result.items():
+        values[key] = _factor_number(raw)
+    return values