lidb 2.0.20__py3-none-any.whl

lidb/qdf/udf/cs_udf.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/3/4 20:20
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+
+import polars as pl
+
+over = dict(
+    partition_by=["date", "time"],
+    order_by=["asset", ]
+)
+
+EPS = 1e-12
+
+
+def cs_ufit(expr: pl.Expr): return (expr - expr.median().over(**over)).abs()
+
+
+def cs_rank(expr: pl.Expr): return expr.rank().over(**over)
+
+
+def cs_demean(expr: pl.Expr): return expr - expr.mean().over(**over)
+
+
+def cs_mean(expr: pl.Expr): return expr.mean().over(**over)
+
+
+def cs_mid(expr: pl.Expr): return expr.median().over(**over)
+
+
+def cs_moderate(expr: pl.Expr): return (expr - expr.mean().over(**over)).abs()
+
+
+def cs_qcut(expr: pl.Expr, N=10):
+    return expr.qcut(N, labels=[str(i) for i in range(1, N + 1)], allow_duplicates=True).cast(pl.Int32)
+
+
+def cs_ic(left: pl.Expr, right: pl.Expr, ): return pl.corr(left, right, method="spearman").over(**over)
+
+
+def cs_corr(left: pl.Expr, right: pl.Expr): return pl.corr(left, right, method="pearson").over(**over)
+
+
+def cs_std(expr: pl.Expr): return expr.std().over(**over)
+
+
+def cs_var(expr: pl.Expr): return expr.var().over(**over)
+
+
+def cs_skew(expr: pl.Expr): return expr.skew().over(**over)
+
+
+def cs_slope(left: pl.Expr, right: pl.Expr): return cs_corr(left, right) * cs_std(left) / cs_std(right)
+
+
+def cs_resid(left: pl.Expr, right: pl.Expr): return left - cs_slope(left, right) * right
+
+
+def cs_mad(expr: pl.Expr):
+    return 1.4826 * (expr - expr.median()).abs().median().over(**over)
+
+
+def cs_zscore(expr: pl.Expr): return (expr - cs_mean(expr)) / cs_std(expr)
+
+
+def cs_norm(expr: pl.Expr): return (expr - cs_mid(expr)) / cs_mad(expr)
+
+
+def cs_midby(expr: pl.Expr, *by: pl.Expr): return expr.median().over(partition_by=[*over.get("partition_by"), *by],
+                                                                     order_by=over.get("order_by"))
+
+
+def cs_madby(expr: pl.Expr, *by: pl.Expr): return 1.4826 * (expr - expr.median()).abs().median().over(
+    partition_by=[*over.get("partition_by"), *by], order_by=over.get("order_by"))
+
+
+def cs_normby(expr: pl.Expr, *by: pl.Expr): return (expr - cs_midby(expr, *by)) / (cs_madby(expr, *by) + EPS)
+
+
+def cs_meanby(expr: pl.Expr, *by: pl.Expr): return expr.mean().over(partition_by=[*over.get("partition_by"), *by],
+                                                                    order_by=over.get("order_by"))
+
+
+def cs_stdby(expr: pl.Expr, *by: pl.Expr): return expr.std().over(partition_by=[*over.get("partition_by"), *by],
+                                                                  order_by=over.get("order_by"))
+
+
+def cs_sumby(expr: pl.Expr, *by: pl.Expr): return expr.sum().over(partition_by=[*over.get("partition_by"), *by],
+                                                                  order_by=over.get("order_by"))
+
+
+def cs_max(expr: pl.Expr): return expr.max().over(**over)
+
+
+def cs_min(expr: pl.Expr): return expr.min().over(**over)
+
+
+def cs_peakmax(expr: pl.Expr): return expr.peak_max().over(**over)
+
+
+def cs_peakmin(expr: pl.Expr): return expr.peak_min().over(**over)
+
+
+def cs_zscoreby(expr: pl.Expr, *by: pl.Expr): return (expr - cs_meanby(expr, *by)) / cs_stdby(expr, *by)
+
+
+def cs_entropy(expr: pl.Expr): return expr.entropy().over(**over)
+
+
+def cs_entropyby(expr: pl.Expr, *by: pl.Expr): return expr.entropy().over(partition_by=[*over.get("partition_by"), *by],
+                                                                          order_by=over.get("order_by"))

lidb/qdf/udf/d_udf.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/3/5 01:04
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+import numpy as np
+import polars as pl
+
+over = dict(
+    partition_by=["time", "asset"],
+    order_by=["date"]
+)
+
+
+def d_mean(expr: pl.Expr, windows): return expr.rolling_mean(windows, min_samples=1).over(**over)
+
+
+def d_std(expr: pl.Expr, windows): return expr.rolling_std(windows, min_samples=1).over(**over)
+
+
+def d_sum(expr: pl.Expr, windows): return expr.rolling_sum(windows, min_samples=1).over(**over)
+
+
+def d_var(expr: pl.Expr, windows): return expr.rolling_var(windows, min_samples=1).over(**over)
+
+
+def d_skew(expr: pl.Expr, windows): return expr.rolling_skew(windows, ).over(**over)
+
+
+def d_ref(expr: pl.Expr, windows, dims):  # return expr.shift(int(abs(windows))).over(**over)
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((dims[0], -1))
+            )
+            .shift(windows)
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+        .replace(np.nan, None)
+    )
+
+
+def d_mid(expr: pl.Expr, windows): return expr.rolling_median(windows, min_samples=1).over(**over)
+
+
+def d_mad(expr: pl.Expr, windows):
+    return (expr-expr.rolling_median(windows, min_samples=1)).abs().rolling_median(windows, min_samples=1).over(**over)
+
+
+def d_rank(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((dims[0], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").rank().last())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+
+def d_prod(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((dims[0], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").cum_prod())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+
+def d_max(expr: pl.Expr, windows): return expr.rolling_max(windows, min_samples=1).over(**over)
+
+
+def d_min(expr: pl.Expr, windows): return expr.rolling_min(windows, min_samples=1).over(**over)
+
+
+def d_ewmmean(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_mean(com=com,
+                      span=span,
+                      half_life=half_life,
+                      alpha=alpha,
+                      adjust=False,
+                      min_samples=1)
+            .over(**over))
+
+
+def d_ewmstd(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_std(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def d_ewmvar(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_var(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def d_cv(expr: pl.Expr, windows): return d_std(expr, windows) / d_mean(expr, windows)
+
+
+def d_snr(expr: pl.Expr, windows): return d_mean(expr, windows) / d_std(expr, windows)  # 信噪比: signal_to_noise ratio
+
+
+def d_diff(expr: pl.Expr, windows=1): return expr.diff(windows).over(**over)
+
+
+def d_pct(expr: pl.Expr, windows=1): return expr.pct_change(windows).over(**over)
+
+
+def d_corr(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_corr(left, right, window_size=windows,
+                                                                           min_samples=1).over(**over)
+
+
+def d_cov(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_cov(left, right, window_size=windows,
+                                                                         min_samples=1).over(**over).replace(np.nan,
+                                                                                                             None)
+
+
+def d_slope(left: pl.Expr, right: pl.Expr, windows): return (
+        d_mean(left * right, windows) - d_mean(right, windows) * d_mean(left, windows)) / d_var(right, windows)
+
+
+def d_resid(left: pl.Expr, right: pl.Expr, windows): return right - d_slope(left, right, windows) * right
+
+
+def d_quantile(expr: pl.Expr, windows, quantile):
+    return expr.rolling_quantile(window_size=windows, quantile=quantile, min_samples=1).over(**over)
+
+def d_entropy(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((dims[0], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").entropy())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def d_zscore(expr: pl.Expr, windows):
+    return (expr - d_mean(expr, windows))/d_std(expr, windows)
+
+def d_fill_forward(expr: pl.Expr):
+    return expr.fill_null(strategy="forward").over(**over)

lidb/qdf/udf/itd_udf.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/3/5 01:04
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+import numpy as np
+import polars as pl
+
+over = dict(
+    partition_by=["date", "asset"],
+    order_by=["time"]
+)
+
+
+def itd_mean(expr: pl.Expr, windows): return expr.rolling_mean(windows, min_samples=1).over(**over)
+
+
+def itd_std(expr: pl.Expr, windows): return expr.rolling_std(windows, min_samples=1).over(**over)
+
+
+def itd_sum(expr: pl.Expr, windows): return expr.rolling_sum(windows, min_samples=1).over(**over)
+
+
+def itd_var(expr: pl.Expr, windows): return expr.rolling_var(windows, min_samples=1).over(**over)
+
+
+def itd_skew(expr: pl.Expr, windows): return expr.rolling_skew(windows, ).over(**over)
+
+
+def itd_ref(expr: pl.Expr, windows, dims):  # return expr.shift(int(abs(windows))).over(**over)
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x
+                .to_numpy()
+                .reshape(dims)
+                .transpose((1, 0, 2))
+                .reshape((dims[1], -1))
+            )
+            .shift(windows)
+            .to_numpy()
+            .reshape((dims[1], dims[0], dims[2]))
+            .transpose((1, 0, 2))
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+        .replace(np.nan, None)
+    )
+
+
+def itd_mid(expr: pl.Expr, windows): return expr.rolling_median(windows, min_samples=1).over(**over)
+
+
+def itd_mad(expr: pl.Expr, windows):
+    return 1.4826 * (expr - expr.rolling_median(windows, min_samples=1)).abs().rolling_median(windows, min_samples=1).over(**over)
+
+
+def itd_rank(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x
+                .to_numpy()
+                .reshape(dims)
+                .transpose((1, 0, 2))
+                .reshape((dims[1], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").rank().last())
+            .drop("index")
+            .to_numpy()
+            .reshape((dims[1], dims[0], dims[2]))
+            .transpose((1, 0, 2))
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def itd_prod(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x
+                .to_numpy()
+                .reshape(dims)
+                .transpose((1, 0, 2))
+                .reshape((dims[1], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").cum_prod())
+            .drop("index")
+            .to_numpy()
+            .reshape((dims[1], dims[0], dims[2]))
+            .transpose((1, 0, 2))
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def itd_max(expr: pl.Expr, windows): return expr.rolling_max(windows, min_samples=1).over(**over)
+
+
+def itd_min(expr: pl.Expr, windows): return expr.rolling_min(windows, min_samples=1).over(**over)
+
+
+def itd_ewmmean(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_mean(com=com,
+                      span=span,
+                      half_life=half_life,
+                      alpha=alpha,
+                      adjust=False,
+                      min_samples=1)
+            .over(**over))
+
+
+def itd_ewmstd(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_std(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def itd_ewmvar(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_var(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def itd_cv(expr: pl.Expr, windows): return itd_std(expr, windows) / itd_mean(expr, windows)
+
+
+def itd_snr(expr: pl.Expr, windows): return itd_mean(expr, windows) / itd_std(expr,
+                                                                              windows)  # 信噪比: signal_to_noise ratio
+
+
+def itd_diff(expr: pl.Expr, windows=1): return expr.diff(windows).over(**over)
+
+
+def itd_pct(expr: pl.Expr, windows=1): return expr.pct_change(windows).over(**over)
+
+
+def itd_corr(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_corr(left, right, window_size=windows,
+                                                                             min_samples=1).over(**over)
+
+
+def itd_cov(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_cov(left, right, window_size=windows,
+                                                                           min_samples=1).over(**over).replace(np.nan,
+                                                                                                               None)
+
+def itd_slope(left: pl.Expr, right: pl.Expr, windows): return (
+            itd_mean(left * right, windows) - itd_mean(right, windows) * itd_mean(left, windows)) / itd_var(right,
+                                                                                                            windows)
+
+
+def itd_resid(left: pl.Expr, right: pl.Expr, windows): return right - itd_slope(left, right, windows) * right
+
+
+def itd_quantile(expr: pl.Expr, windows, quantile):
+    return expr.rolling_quantile(window_size=windows, quantile=quantile, min_samples=1).over(**over)
+
+def itd_entropy(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x
+                .to_numpy()
+                .reshape(dims)
+                .transpose((1, 0, 2))
+                .reshape((dims[1], -1))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").entropy())
+            .drop("index")
+            .to_numpy()
+            .reshape((dims[1], dims[0], dims[2]))
+            .transpose((1, 0, 2))
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def itd_zscore(expr: pl.Expr, windows):
+    return (expr - itd_mean(expr, windows))/itd_std(expr, windows)
+
+def itd_norm(expr: pl.Expr, windows):
+    return (expr - itd_mid(expr, windows))/itd_mad(expr, windows)
+
+def itd_fill_forward(expr: pl.Expr):
+    return expr.fill_null(strategy="forward").over(**over)

lidb/qdf/udf/ts_udf.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""
+---------------------------------------------
+Created on 2025/3/5 01:04
+@author: ZhangYundi
+@email: yundi.xxii@outlook.com
+---------------------------------------------
+"""
+import numpy as np
+import polars as pl
+
+over = dict(
+    partition_by=["asset"],
+    order_by=["date", "time"]
+)
+
+
+def ts_mean(expr: pl.Expr, windows): return expr.rolling_mean(windows, min_samples=1).over(**over)
+
+
+def ts_std(expr: pl.Expr, windows): return expr.rolling_std(windows, min_samples=1).over(**over)
+
+
+def ts_sum(expr: pl.Expr, windows): return expr.rolling_sum(windows, min_samples=1).over(**over)
+
+
+def ts_var(expr: pl.Expr, windows): return expr.rolling_var(windows, min_samples=1).over(**over)
+
+
+def ts_skew(expr: pl.Expr, windows): return expr.rolling_skew(windows, ).over(**over)
+
+
+def ts_ref(expr: pl.Expr, windows, dims):  # return expr.shift(int(abs(windows))).over(**over)
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((-1, dims[-1]))
+            )
+            .shift(windows)
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+        .replace(np.nan, None)
+    )
+
+
+def ts_mid(expr: pl.Expr, windows): return expr.rolling_median(windows, min_samples=1).over(**over)
+
+
+def ts_mad(expr: pl.Expr, windows):
+    return 1.4826 * (expr - expr.rolling_median(windows, min_samples=1)).abs().rolling_median(windows, min_samples=1).over(**over)
+
+
+def ts_rank(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((-1, dims[-1]))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").rank().last())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def ts_prod(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((-1, dims[-1]))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").cum_prod())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+
+def ts_max(expr: pl.Expr, windows): return expr.rolling_max(windows, min_samples=1).over(**over)
+
+
+def ts_min(expr: pl.Expr, windows): return expr.rolling_min(windows, min_samples=1).over(**over)
+
+
+def ts_ewmmean(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_mean(com=com,
+                      span=span,
+                      half_life=half_life,
+                      alpha=alpha,
+                      adjust=False,
+                      min_samples=1)
+            .over(**over))
+
+
+def ts_ewmstd(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_std(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def ts_ewmvar(expr: pl.Expr, com=None, span=None, half_life=None, alpha=None):
+    return (expr
+            .ewm_var(com=com,
+                     span=span,
+                     half_life=half_life,
+                     alpha=alpha,
+                     adjust=False,
+                     min_samples=1)
+            .over(**over))
+
+
+def ts_cv(expr: pl.Expr, windows): return ts_std(expr, windows) / ts_mean(expr, windows)
+
+
+def ts_snr(expr: pl.Expr, windows): return ts_mean(expr, windows) / ts_std(expr, windows)  # 信噪比: signal_to_noise ratio
+
+
+def ts_diff(expr: pl.Expr, windows=1): return expr.diff(windows).over(**over)
+
+
+def ts_pct(expr: pl.Expr, windows=1): return expr.pct_change(windows).over(**over)
+
+
+def ts_corr(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_corr(left, right, window_size=windows,
+                                                                            min_samples=1).over(**over)
+
+
+def ts_cov(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_cov(left, right, window_size=windows,
+                                                                          min_samples=1).over(**over).replace(np.nan,
+                                                                                                              None)
+
+
+def ts_slope(left: pl.Expr, right: pl.Expr, windows): return (
+            ts_mean(left * right, windows) - ts_mean(right, windows) * ts_mean(left, windows)) / ts_var(right, windows)
+
+
+def ts_resid(left: pl.Expr, right: pl.Expr, windows): return right - ts_slope(left, right, windows) * right
+
+
+def ts_quantile(expr: pl.Expr, windows, quantile):
+    return expr.rolling_quantile(window_size=windows, quantile=quantile, min_samples=1).over(**over)
+
+def ts_entropy(expr: pl.Expr, windows, dims):
+    return (
+        expr
+        .map_batches(
+            lambda x: pl.DataFrame(
+                x.to_numpy().reshape((-1, dims[-1]))
+            )
+            .with_row_index()
+            .rolling("index", period=f"{windows}i")
+            .agg(pl.all().exclude("index").entropy())
+            .drop("index")
+            .to_numpy()
+            .ravel(),
+            return_dtype=pl.self_dtype()
+        )
+    )
+
+def ts_zscore(expr: pl.Expr, windows):
+    return (expr - ts_mean(expr, windows))/ts_std(expr, windows)
+
+def ts_fill_forward(expr: pl.Expr):
+    return expr.fill_null(strategy="forward").over(**over)

lidb/svc/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) ZhangYundi.
+# Licensed under the MIT License. 
+# Created on 2025/10/11 11:01
+# Description:
+
+from .data import DataService, D