polars-ta 0.5.6__tar.gz → 0.5.9__tar.gz

{polars_ta-0.5.6 → polars_ta-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polars_ta
-Version: 0.5.6
+Version: 0.5.9
 Summary: polars expressions
 Author-email: wukan <wu-kan@163.com>
 License: MIT License
@@ -29,6 +29,7 @@ Keywords: expression,polars,talib
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Requires-Python: >=3.8
+Requires-Dist: more-itertools
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: pandas

polars_ta-0.5.9/polars_ta/_version.py

@@ -0,0 +1 @@
+__version__ = "0.5.9"

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/prefix/tdx.py

@@ -128,6 +128,8 @@ from polars_ta.tdx.statistic import STDP as ts_STDP  # noqa
 from polars_ta.tdx.statistic import VAR as ts_VAR  # noqa
 from polars_ta.tdx.statistic import VARP as ts_VARP  # noqa
 from polars_ta.tdx.statistic import ts_up_stat  # noqa
+from polars_ta.tdx.times import FROMOPEN  # noqa
+from polars_ta.tdx.times import FROMOPEN_1  # noqa
 from polars_ta.tdx.trend import ADX as ts_ADX  # noqa
 from polars_ta.tdx.trend import ADXR as ts_ADXR  # noqa
 from polars_ta.tdx.trend import DPO as ts_DPO  # noqa

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/tdx/__init__.py

@@ -9,6 +9,7 @@ from polars_ta.tdx.pattern_feature import *  # noqa
 from polars_ta.tdx.pressure_support import *  # noqa
 from polars_ta.tdx.reference import *  # noqa
 from polars_ta.tdx.statistic import *  # noqa
+from polars_ta.tdx.times import *  # noqa
 from polars_ta.tdx.trend import *  # noqa
 from polars_ta.tdx.trend_feature import *  # noqa
 from polars_ta.tdx.volume import *  # noqa

polars_ta-0.5.9/polars_ta/tdx/times.py

@@ -0,0 +1,74 @@
+from datetime import time, timedelta
+
+from polars import Expr, when
+
+
+def FROMOPEN(t: Expr) -> Expr:
+    """返回当前时刻距开盘有多少分钟
+
+    范围0~240,开盘前为0，10点为31
+
+    Examples
+    --------
+    from datetime import datetime
+
+    import polars as pl
+
+    from polars_ta.tdx.times import FROMOPEN, FROMOPEN1
+
+    df = pl.DataFrame({'datetime': [
+        datetime(2025, 1, 1, 0, 0),
+        datetime(2025, 1, 1, 9, 25),
+        datetime(2025, 1, 1, 9, 30, 57),
+        datetime(2025, 1, 1, 9, 31),
+        datetime(2025, 1, 1, 10, 0),
+        datetime(2025, 1, 1, 13, 0),
+    ]})
+
+    df = df.with_columns(
+        FROMOPEN=FROMOPEN(pl.col('datetime')),
+        FROMOPEN1=FROMOPEN_1(pl.col('datetime'), 0),
+        FROMOPEN2=FROMOPEN_1(pl.col('datetime'), 60),
+    )
+
+    shape: (6, 4)
+    ┌─────────────────────┬──────────┬───────────┬───────────┐
+    │ datetime            ┆ FROMOPEN ┆ FROMOPEN1 ┆ FROMOPEN2 │
+    │ ---                 ┆ ---      ┆ ---       ┆ ---       │
+    │ datetime[μs]        ┆ i64      ┆ i64       ┆ i64       │
+    ╞═════════════════════╪══════════╪═══════════╪═══════════╡
+    │ 2025-01-01 00:00:00 ┆ 0        ┆ 240       ┆ 240       │
+    │ 2025-01-01 09:25:00 ┆ 0        ┆ 1         ┆ 1         │
+    │ 2025-01-01 09:30:57 ┆ 1        ┆ 1         ┆ 2         │
+    │ 2025-01-01 09:31:00 ┆ 2        ┆ 2         ┆ 3         │
+    │ 2025-01-01 10:00:00 ┆ 31       ┆ 31        ┆ 32        │
+    │ 2025-01-01 13:00:00 ┆ 121      ┆ 121       ┆ 122       │
+    └─────────────────────┴──────────┴───────────┴───────────┘
+
+    """
+    am = (t.dt.time() - time(9, 29)).dt.total_minutes().clip(0, 120)
+    pm = (t.dt.time() - time(12, 59)).dt.total_minutes().clip(0, 120)
+    return am + pm
+
+
+def FROMOPEN_1(t: Expr, offset: int) -> Expr:
+    """返回当前时刻距开盘有多少分钟。范围1~240
+
+    用于计算量比
+    1. 竞价量比，分母应当为1
+    2. 日线数据0~8点时，返回240
+    3. 日线数据9点时，返回1
+
+    Parameters
+    ----------
+    t : Expr
+        时间列
+    offset : int
+        偏移量，单位秒
+
+    Notes
+    -----
+    每根K线结束时，标签是当前时间的50多秒，而结束时时间已经到下以分钟了，所以建议加60秒
+
+    """
+    return when(t.dt.time() >= time(8, 45)).then(FROMOPEN(t + timedelta(seconds=offset)).clip(1, 240)).otherwise(240)

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/utils/numba_.py

@@ -2,6 +2,7 @@
 Demo for using numba to implement rolling functions.
 本文件是使用numba实现rolling的函数，演示用
 """
+from functools import lru_cache
 from typing import List
 
 import numpy as np
@@ -160,3 +161,12 @@ def roll_sum(x: Expr, n: int) -> Expr:
 
 def roll_cov(a: Expr, b: Expr, n: int) -> Expr:
     return struct([a, b]).map_batches(lambda xx: batches_i2_o1(struct_to_numpy(xx, 2), nb_roll_cov, n))
+
+
+@lru_cache
+@jit(nopython=True, nogil=True, fastmath=True, cache=True)
+def get_exponent_weights(
+        window: int = 10,
+        half_life: int = 5,
+) -> np.ndarray:
+    return np.repeat(0.5 ** (1 / half_life), window) ** np.arange(window - 1, -1, -1)

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/__init__.py

@@ -1,5 +1,6 @@
 from polars_ta.wq.arithmetic import *  # noqa
 from polars_ta.wq.cross_sectional import *  # noqa
+from polars_ta.wq.half_life import *  # noqa
 from polars_ta.wq.logical import *  # noqa
 from polars_ta.wq.preprocess import *  # noqa
 from polars_ta.wq.time_series import *  # noqa

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/_nb.py

@@ -312,7 +312,13 @@ def _signals_to_size(is_long_entry: np.ndarray, is_long_exit: np.ndarray,
 
 
 @jit(nopython=True, nogil=True, cache=True)
-def roll_decay_linear(x1, window, min_periods):
+def _roll_decay_linear(x1, window, min_periods):
+    """
+    def ts_decay_linear(x: Expr, d: int = 30, min_samples: Optional[int] = None) -> Expr:
+        minp = min_samples or polars_ta.MIN_SAMPLES or d
+        return x.map_batches(lambda x1: batches_i1_o1(x1.to_numpy().astype(float), _roll_decay_linear, d, minp))
+
+    """
     weights = np.arange(1., window + 1)
 
     out1 = full_with_window_size(x1, np.nan, dtype=np.float64, window_size=window)
@@ -327,7 +333,13 @@ def roll_decay_linear(x1, window, min_periods):
 
 
 @jit(nopython=True, nogil=True, cache=True)
-def roll_decay_exp_window(x1, window, min_periods, factor):
+def _roll_decay_exp_window(x1, window, min_periods, factor):
+    """
+    def ts_decay_exp_window(x: Expr, d: int = 30, factor: float = 1.0, min_samples: Optional[int] = None) -> Expr:
+        minp = min_samples or polars_ta.MIN_SAMPLES or d
+        return x.map_batches(lambda x1: batches_i1_o1(x1.to_numpy().astype(float), _roll_decay_exp_window, d, minp, factor))
+
+    """
     weights = factor ** np.arange(window - 1, -1, -1)
 
     out1 = full_with_window_size(x1, np.nan, dtype=np.float64, window_size=window)

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/cross_sectional.py

@@ -290,7 +290,7 @@ def cs_rank(x: Expr, pct: bool = True) -> Expr:
 
 
 def cs_rank_if(condition: Expr, x: Expr, pct: bool = True) -> Expr:
-    """动态票池过滤排名
+    """横截面筛选排名。可实现动态票池
 
     Parameters
     ----------
@@ -299,17 +299,34 @@ def cs_rank_if(condition: Expr, x: Expr, pct: bool = True) -> Expr:
     x:Expr
         因子
     pct:bool
+        排名百分比。范围：[0,1]
 
     Examples
     --------
     ```python
     df = pl.DataFrame({
         'a': [None, 1, 1, 1, 2, 2, 3, 10],
-        'b': [1, 2, 3, 4, 5, 6, 7, 8],
+        'b': [1, 2, 3, 4, 5, 6, None, 8],
     }).with_columns(
-        out1=cs_rank_if(True, pl.col('a'), True), # 与cs_rank等价
+        out1=cs_rank_if(True, pl.col('a'), True),  # 与cs_rank等价
         out2=cs_rank_if(pl.col('b') > 3, -pl.col('a'), False),
     )
+
+    shape: (8, 4)
+    ┌──────┬──────┬──────────┬──────┐
+    │ a    ┆ b    ┆ out1     ┆ out2 │
+    │ ---  ┆ ---  ┆ ---      ┆ ---  │
+    │ i64  ┆ i64  ┆ f64      ┆ u32  │
+    ╞══════╪══════╪══════════╪══════╡
+    │ null ┆ 1    ┆ null     ┆ null │
+    │ 1    ┆ 2    ┆ 0.0      ┆ null │
+    │ 1    ┆ 3    ┆ 0.0      ┆ null │
+    │ 1    ┆ 4    ┆ 0.0      ┆ 3    │
+    │ 2    ┆ 5    ┆ 0.333333 ┆ 2    │
+    │ 2    ┆ 6    ┆ 0.333333 ┆ 2    │
+    │ 3    ┆ null ┆ 0.666667 ┆ null │
+    │ 10   ┆ 8    ┆ 1.0      ┆ 1    │
+    └──────┴──────┴──────────┴──────┘
     ```
 
     Notes

polars_ta-0.5.9/polars_ta/wq/half_life.py

@@ -0,0 +1,26 @@
+import numpy as np
+from polars import Expr
+
+from polars_ta.utils.numba_ import get_exponent_weights
+
+
+def ts_mean_hl(x: Expr, d: int, half_life: int):
+    """滚动均值。带半衰期"""
+    return x.fill_null(np.nan).rolling_mean(d, weights=get_exponent_weights(d, half_life)).fill_nan(None)
+
+
+def ts_sum_hl(x: Expr, d: int, half_life: int):
+    """滚动求和。带半衰期"""
+    return x.fill_null(np.nan).rolling_sum(d, weights=get_exponent_weights(d, half_life)).fill_nan(None)
+
+
+def ts_std_hl(x: Expr, d: int, half_life: int):
+    """滚动标准差。带半衰期"""
+    return x.fill_null(np.nan).rolling_std(d, weights=get_exponent_weights(d, half_life)).fill_nan(None)
+
+
+def ts_var_hl(x: Expr, d: int, half_life: int):
+    """滚动方差。带半衰期"""
+    return x.fill_null(np.nan).rolling_var(d, weights=get_exponent_weights(d, half_life)).fill_nan(None)
+
+# TODO 混动时序回归，带半衰期

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/preprocess.py

@@ -119,3 +119,12 @@ def cs_mad_zscore_resid_zscore(y: Expr, *more_x: Expr) -> Expr:
 def cs_quantile_zscore(y: Expr, low_limit: float = 0.025, up_limit: float = 0.975) -> Expr:
     """横截面分位数去极值、标准化"""
     return cs_zscore(cs_quantile(y, low_limit, up_limit))
+
+
+# ==========================
+def cs_resid_w(w: Expr, y: Expr, *more_x: Expr) -> Expr:
+    """横截面加权多元回归取残差
+
+    Barra中权重采用流通市值的平方根
+    """
+    return pls.compute_least_squares(y, *more_x, sample_weights=w, mode='residuals', ols_kwargs=_ols_kwargs)

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/time_series.py

@@ -1,14 +1,18 @@
+import itertools
 from typing import Optional
 
+import more_itertools
+import numpy as np
 import polars_ols as pls
-from polars import Expr, UInt16, struct, when, Struct, Field, Float64, Boolean, UInt32
+from polars import Expr, UInt16, struct, when, Struct, Field, Float64, Boolean, UInt32, all_horizontal, any_horizontal
 from polars import rolling_corr, rolling_cov
 from polars_ols import RollingKwargs
 
 import polars_ta
 from polars_ta.utils.numba_ import batches_i1_o1, batches_i2_o1, batches_i2_o2, struct_to_numpy
 from polars_ta.utils.pandas_ import roll_rank
-from polars_ta.wq._nb import roll_argmax, roll_argmin, roll_co_kurtosis, roll_co_skewness, roll_moment, roll_partial_corr, roll_triple_corr, _cum_prod_by, _cum_sum_by, _signals_to_size, _cum_sum_reset, _sum_split_by, roll_decay_linear, roll_decay_exp_window, roll_prod
+from polars_ta.wq._nb import roll_argmax, roll_argmin, roll_co_kurtosis, roll_co_skewness, roll_moment, roll_partial_corr, roll_triple_corr, _cum_prod_by, _cum_sum_by, _signals_to_size, \
+    _cum_sum_reset, _sum_split_by, roll_prod
 
 
 def ts_arg_max(x: Expr, d: int = 5, reverse: bool = True, min_samples: Optional[int] = None) -> Expr:
@@ -165,6 +169,40 @@ def ts_count(x: Expr, d: int = 30, min_samples: Optional[int] = None) -> Expr:
     return x.cast(Boolean).cast(UInt32).rolling_sum(d, min_samples=minp)
 
 
+def ts_count_eq(x: Expr, d: int = 30, n: int = 10, min_samples: Optional[int] = None) -> Expr:
+    """D天内最近连续出现N次
+
+    Parameters
+    ----------
+    x
+    d: int
+        窗口大小
+    n: int
+        连续出现次数
+
+    """
+    minp = min_samples or polars_ta.MIN_SAMPLES
+    xx = x.cast(Boolean).cast(UInt32)
+    return (xx.rolling_sum(n) == n) & (xx.rolling_sum(d, min_samples=minp) == n)
+
+
+def ts_count_ge(x: Expr, d: int = 30, n: int = 10, min_samples: Optional[int] = None) -> Expr:
+    """D天内最近连续出现至少N次
+
+    Parameters
+    ----------
+    x
+    d: int
+        窗口大小
+    n: int
+        至少连续出现次数
+
+    """
+    minp = min_samples or polars_ta.MIN_SAMPLES
+    xx = x.cast(Boolean).cast(UInt32)
+    return (xx.rolling_sum(n) == n) & (xx.rolling_sum(d, min_samples=minp) >= n)
+
+
 def ts_count_nans(x: Expr, d: int = 5, min_samples: Optional[int] = None) -> Expr:
     """时序滚动统计nan出现次数
 
@@ -448,12 +486,11 @@ def ts_decay_exp_window(x: Expr, d: int = 30, factor: float = 1.0, min_samples:
     https://platform.worldquantbrain.com/learn/operators/detailed-operator-descriptions#ts_decay_exp_windowx-d-factor-10-nan-true
 
     """
-    # y = arange(d - 1, -1, step=-1, eager=False)
-    # weights = repeat(factor, d, eager=True).pow(y)
+    minp = min_samples or polars_ta.MIN_SAMPLES
+    weights = np.repeat(factor, d) ** np.arange(d - 1, -1, -1)
     # print(weights)
-    # return x.rolling_mean(d, weights=weights)
-    minp = min_samples or polars_ta.MIN_SAMPLES or d
-    return x.map_batches(lambda x1: batches_i1_o1(x1.to_numpy().astype(float), roll_decay_exp_window, d, minp, factor))
+    # pyo3_runtime.PanicException: weights not yet supported on array with null values
+    return x.fill_null(np.nan).rolling_mean(d, weights=weights, min_samples=minp).fill_nan(None)
 
 
 def ts_decay_linear(x: Expr, d: int = 30, min_samples: Optional[int] = None) -> Expr:
@@ -492,12 +529,12 @@ def ts_decay_linear(x: Expr, d: int = 30, min_samples: Optional[int] = None) ->
     https://platform.worldquantbrain.com/learn/operators/detailed-operator-descriptions#ts_decay_linearx-d-dense-false
 
     """
-    # # weights not yet supported on array with null values
-    # weights = arange(1, d + 1, eager=True)
-    # # print(weights)
-    # return x.rolling_mean(d, weights=weights)
-    minp = min_samples or polars_ta.MIN_SAMPLES or d
-    return x.map_batches(lambda x1: batches_i1_o1(x1.to_numpy().astype(float), roll_decay_linear, d, minp))
+    minp = min_samples or polars_ta.MIN_SAMPLES
+    weights = np.arange(1, d + 1)
+    # print(weights)
+    # pyo3_runtime.PanicException: weights not yet supported on array with null values
+    # null换成NaN就不报错了，再换回来
+    return x.fill_null(np.nan).rolling_mean(d, weights=weights, min_samples=minp).fill_nan(None)
 
 
 def ts_delay(x: Expr, d: int = 1, fill_value: float = None) -> Expr:
@@ -768,6 +805,140 @@ def ts_scale(x: Expr, d: int = 5, min_samples: Optional[int] = None) -> Expr:
     return when(a != b).then((x - a) / (b - a)).otherwise(0)
 
 
+def ts_shifts_v1(*args) -> Expr:
+    """时序上按顺序进行平移，然后逻辑与
+
+    比如今天反包，昨天阴跌，前天涨停。只需要写`ts_shifts_v1(反包,阴跌,涨停)`。使用此函数能一定程度上简化代码
+
+    Parameters
+    ----------
+    args
+        pl.col按照顺序排列
+
+    Examples
+    --------
+    ```python
+    df = pl.DataFrame({
+        'a': [None, False, False, True, True, True],
+        'b': [None, False, True, True, True, True],
+        'c': [None, True, True, True, True, True],
+    }).with_columns(
+        out1=ts_shifts_v1(pl.col('a'), pl.col('b'), pl.col('c')),
+        out2=pl.col('a').shift(0) & pl.col('b').shift(1) & pl.col('c').shift(2),
+    )
+
+    shape: (6, 5)
+    ┌──────┬───────┬───────┬───────┬───────┐
+    │ c    ┆ b     ┆ a     ┆ out1  ┆ out2  │
+    │ ---  ┆ ---   ┆ ---   ┆ ---   ┆ ---   │
+    │ bool ┆ bool  ┆ bool  ┆ bool  ┆ bool  │
+    ╞══════╪═══════╪═══════╪═══════╪═══════╡
+    │ null ┆ null  ┆ null  ┆ null  ┆ null  │
+    │ true ┆ false ┆ false ┆ false ┆ false │
+    │ true ┆ true  ┆ false ┆ false ┆ false │
+    │ true ┆ true  ┆ true  ┆ true  ┆ true  │
+    │ true ┆ true  ┆ true  ┆ true  ┆ true  │
+    │ true ┆ true  ┆ true  ┆ true  ┆ true  │
+    └──────┴───────┴───────┴───────┴───────┘
+    ```
+
+    """
+    return all_horizontal(arg.shift(i) for i, arg in enumerate(args))
+
+
+def ts_shifts_v2(*args) -> Expr:
+    """时序上按顺序进行平移，然后逻辑与
+
+    遇到连续条件时可简化参数。如连续3天涨停后连续2天跌停，可用`ts_shifts_v2(跌停,2,涨停,3)`
+    另一种实现方法是：`ts_delay((ts_count(涨停,3)==3),2)&(ts_count(跌停,2)==2)`
+
+    Parameters
+    ----------
+    args
+        pl.col, repeat。两个参数循环
+
+    Examples
+    --------
+    ```python
+    df = pl.DataFrame({
+        'a': [None, False, False, True, True, True],
+        'b': [None, False, True, True, True, True],
+        'c': [None, True, True, True, True, True],
+    }).with_columns(
+        out1=ts_shifts_v1(pl.col('a'), pl.col('b'), pl.col('b')),
+        out2=ts_shifts_v2(pl.col('a'), 1, pl.col('b'), 2),
+        out3=pl.col('a').shift(0) & pl.col('b').shift(1) & pl.col('b').shift(2),
+    )
+
+    shape: (6, 6)
+    ┌───────┬───────┬──────┬───────┬───────┬───────┐
+    │ a     ┆ b     ┆ c    ┆ out1  ┆ out2  ┆ out3  │
+    │ ---   ┆ ---   ┆ ---  ┆ ---   ┆ ---   ┆ ---   │
+    │ bool  ┆ bool  ┆ bool ┆ bool  ┆ bool  ┆ bool  │
+    ╞═══════╪═══════╪══════╪═══════╪═══════╪═══════╡
+    │ null  ┆ null  ┆ null ┆ null  ┆ null  ┆ null  │
+    │ false ┆ false ┆ true ┆ false ┆ false ┆ false │
+    │ false ┆ true  ┆ true ┆ false ┆ false ┆ false │
+    │ true  ┆ true  ┆ true ┆ false ┆ false ┆ false │
+    │ true  ┆ true  ┆ true ┆ true  ┆ true  ┆ true  │
+    │ true  ┆ true  ┆ true ┆ true  ┆ true  ┆ true  │
+    └───────┴───────┴──────┴───────┴───────┴───────┘
+    ```
+
+    """
+    return ts_shifts_v1(*itertools.chain.from_iterable([item] * count for item, count in more_itertools.chunked(args, 2)))
+
+
+def ts_shifts_v3(*args) -> Expr:
+    """时序上按顺序进行平移，然后逻辑或
+
+    如：涨停后连续下跌1~3天。这个案例会导致涨停可能出现在动态的一天。`ts_shifts_v3(下跌,1,3,涨停,1,1)`
+    它本质上是`ts_shifts_v2(下跌,1,涨停,1)|ts_shifts_v2(下跌,2,涨停,1)|ts_shifts_v2(下跌,3,涨停,1)|`
+
+    Parameters
+    ----------
+    args
+        pl.col, [start, end]。三个参数循环。start/end都是闭区间
+
+    Examples
+    --------
+    ```python
+    df = pl.DataFrame({
+        'a': [None, False, False, True, True, True],
+        'b': [None, False, True, True, True, True],
+        'c': [None, True, True, True, True, True],
+    }).with_columns(
+        out0=ts_shifts_v3(pl.col('a'), 1, 3, pl.col('b'), 2, 2),
+        out1=ts_shifts_v2(pl.col('a'), 1, pl.col('b'), 2),
+        out2=ts_shifts_v2(pl.col('a'), 2, pl.col('b'), 2),
+        out3=ts_shifts_v2(pl.col('a'), 3, pl.col('b'), 2)
+    ).with_columns(
+        out4=pl.col('out1') | pl.col('out2') | pl.col('out3')
+    )
+
+    shape: (6, 8)
+    ┌───────┬───────┬──────┬───────┬───────┬───────┬───────┬───────┐
+    │ a     ┆ b     ┆ c    ┆ out0  ┆ out1  ┆ out2  ┆ out3  ┆ out4  │
+    │ ---   ┆ ---   ┆ ---  ┆ ---   ┆ ---   ┆ ---   ┆ ---   ┆ ---   │
+    │ bool  ┆ bool  ┆ bool ┆ bool  ┆ bool  ┆ bool  ┆ bool  ┆ bool  │
+    ╞═══════╪═══════╪══════╪═══════╪═══════╪═══════╪═══════╪═══════╡
+    │ null  ┆ null  ┆ null ┆ null  ┆ null  ┆ null  ┆ null  ┆ null  │
+    │ false ┆ false ┆ true ┆ false ┆ false ┆ false ┆ false ┆ false │
+    │ false ┆ true  ┆ true ┆ false ┆ false ┆ false ┆ false ┆ false │
+    │ true  ┆ true  ┆ true ┆ false ┆ false ┆ false ┆ false ┆ false │
+    │ true  ┆ true  ┆ true ┆ true  ┆ true  ┆ false ┆ false ┆ true  │
+    │ true  ┆ true  ┆ true ┆ true  ┆ true  ┆ true  ┆ false ┆ true  │
+    └───────┴───────┴──────┴───────┴───────┴───────┴───────┴───────┘
+    ```
+
+    """
+    exprs = [a for a, b, c in more_itertools.chunked(args, 3)]
+    ranges = [range(b, c + 1) for a, b, c in more_itertools.chunked(args, 3)]
+    # 参数整理成col,repeat模式
+    outputs = [itertools.chain.from_iterable(zip(exprs, d)) for d in itertools.product(*ranges)]
+    return any_horizontal(ts_shifts_v2(*_) for _ in outputs)
+
+
 def ts_skewness(x: Expr, d: int = 5, bias: bool = False, min_samples: Optional[int] = None) -> Expr:
     """时序滚动偏度
 

{polars_ta-0.5.6 → polars_ta-0.5.9}/polars_ta/wq/transformational.py

@@ -275,3 +275,8 @@ def bool_(a: Expr) -> Expr:
 def float_(a: Expr) -> Expr:
     """int转成float"""
     return a.cast(Float32)
+
+
+def nop(x: Expr) -> Expr:
+    """空操作"""
+    return x

{polars_ta-0.5.6 → polars_ta-0.5.9}/pyproject.toml

@@ -18,6 +18,7 @@ dependencies = [
     "numpy",
     "numba",
     "pandas",
+    "more_itertools",
 ]
 dynamic = ["version"]
 

polars_ta-0.5.6/polars_ta/_version.py

@@ -1 +0,0 @@
-__version__ = "0.5.6"