ygo 1.0.11__py3-none-any.whl → 1.1.1__py3-none-any.whl

ycat/qdf/udf/cs_udf.py

@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
----------------------------------------------
-Created on 2025/3/4 20:20
-@author: ZhangYundi
-@email: yundi.xxii@outlook.com
----------------------------------------------
-"""
-
-import polars as pl
-import numpy as np
-
-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"))

ycat/qdf/udf/d_udf.py

@@ -1,176 +0,0 @@
-# -*- 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()
-        )
-        .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()
-        )
-    )
-
-
-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()
-        )
-    )
-
-
-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()
-        )
-    )
-
-def d_zscore(expr: pl.Expr, windows):
-    return (expr - d_mean(expr, windows))/d_std(expr, windows)

ycat/qdf/udf/ind_udf.py

@@ -1,202 +0,0 @@
-# -*- 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 ind_mean(expr: pl.Expr, windows): return expr.rolling_mean(windows, min_samples=1).over(**over)
-
-
-def ind_std(expr: pl.Expr, windows): return expr.rolling_std(windows, min_samples=1).over(**over)
-
-
-def ind_sum(expr: pl.Expr, windows): return expr.rolling_sum(windows, min_samples=1).over(**over)
-
-
-def ind_var(expr: pl.Expr, windows): return expr.rolling_var(windows, min_samples=1).over(**over)
-
-
-def ind_skew(expr: pl.Expr, windows): return expr.rolling_skew(windows, ).over(**over)
-
-
-def ind_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()
-        )
-        .replace(np.nan, None)
-    )
-
-
-def ind_mid(expr: pl.Expr, windows): return expr.rolling_median(windows, min_samples=1).over(**over)
-
-
-def ind_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 ind_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()
-        )
-    )
-
-def ind_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()
-        )
-    )
-
-def ind_max(expr: pl.Expr, windows): return expr.rolling_max(windows, min_samples=1).over(**over)
-
-
-def ind_min(expr: pl.Expr, windows): return expr.rolling_min(windows, min_samples=1).over(**over)
-
-
-def ind_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 ind_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 ind_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 ind_cv(expr: pl.Expr, windows): return ind_std(expr, windows) / ind_mean(expr, windows)
-
-
-def ind_snr(expr: pl.Expr, windows): return ind_mean(expr, windows) / ind_std(expr,
-                                                                              windows)  # 信噪比: signal_to_noise ratio
-
-
-def ind_diff(expr: pl.Expr, windows=1): return expr.diff(windows).over(**over)
-
-
-def ind_pct(expr: pl.Expr, windows=1): return expr.pct_change(windows).over(**over)
-
-
-def ind_corr(left: pl.Expr, right: pl.Expr, windows): return pl.rolling_corr(left, right, window_size=windows,
-                                                                             min_samples=1).over(**over)
-
-
-def ind_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 ind_slope(left: pl.Expr, right: pl.Expr, windows): return (
-            ind_mean(left * right, windows) - ind_mean(right, windows) * ind_mean(left, windows)) / ind_var(right,
-                                                                                                            windows)
-
-
-def ind_resid(left: pl.Expr, right: pl.Expr, windows): return right - ind_slope(left, right, windows) * right
-
-
-def ind_quantile(expr: pl.Expr, windows, quantile):
-    return expr.rolling_quantile(window_size=windows, quantile=quantile, min_samples=1).over(**over)
-
-def ind_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()
-        )
-    )
-
-def ind_zscore(expr: pl.Expr, windows):
-    return (expr - ind_mean(expr, windows))/ind_std(expr, windows)
-
-def ind_norm(expr: pl.Expr, windows):
-    return (expr - ind_mid(expr, windows))/ind_mad(expr, windows)

ycat/qdf/udf/ts_udf.py

@@ -1,175 +0,0 @@
-# -*- 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()
-        )
-        .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()
-        )
-    )
-
-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()
-        )
-    )
-
-
-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()
-        )
-    )
-
-def ts_zscore(expr: pl.Expr, windows):
-    return (expr - ts_mean(expr, windows))/ts_std(expr, windows)