commodutil 3.2.3__tar.gz → 3.3.0__tar.gz

{commodutil-3.2.3 → commodutil-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commodutil
-Version: 3.2.3
+Version: 3.3.0
 Summary: common commodity/oil analytics utils
 Author-email: aeorxc <author@example.com>
 Project-URL: Homepage, https://dev.azure.com/RWEST-MFI-TE/Oil/_git/commodutil

commodutil-3.3.0/commodutil/stats.py

@@ -0,0 +1,453 @@
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+
+from commodutil import dates
+from commodutil import transforms
+
+
+def curve_seasonal_zscore(hist, fwd):
+    """
+    Given some history for a timeseries and a forward curve, calculate the monthly
+    z-score (std dev away from mean) along the forward curve
+    """
+
+    d = transforms.monthly_mean(hist).T.describe()
+
+    if isinstance(fwd, pd.Series):
+        fwd = pd.DataFrame(fwd)
+    fwd["zscore"] = fwd.apply(
+        lambda x: (d[x.name.month].loc["mean"] - x.iloc[0])
+        / d[x.name.month].loc["std"],
+        1,
+    )
+    return fwd
+
+
+def reindex_zscore(df, range=10, calc_year_start: int = None):
+    """
+    Given a dataframe of contracts (or spreads), calculate z-score for current year onwards
+    Essentially returns how far away the 'curve' is from historical trading range
+    """
+    df = df
+    df = df.rename(
+        columns={x: int(re.findall("\d\d\d\d", str(x))[0]) for x in df.columns}
+    )  # turn columns into years
+    d = df.loc[
+        :, dates.curyear - range - 1 : dates.curyear - 1
+    ]  # get subset of range years
+    d = d[:-10]  # exclude last 10 rows to due to volatility close to expire
+
+    dfs = []
+    if not calc_year_start:
+        calc_year_start = dates.curyear
+    for year in df.loc[:, calc_year_start : df.columns[-1]]:
+        z = (d.mean(axis=1) - df.loc[:, year]) / d.std(axis=1)
+        z.name = year
+        dfs.append(z)
+    if len(dfs) > 0:
+        res = pd.concat(dfs, axis=1)
+        return res
+
+
+@dataclass(frozen=True)
+class PointStats:
+    """
+    Summary statistics for a single "as-of" point against a historical reference set.
+
+    Percentile is returned as an empirical CDF in [0, 1], i.e. fraction of reference
+    values <= current value.
+    """
+
+    asof: pd.Timestamp
+    current_year: int | None
+    current_value: float | None
+    reference_years: list[int]
+    reference_values: list[float]
+    mean: float | None
+    std: float | None
+    zscore: float | None
+    percentile: float | None
+
+
+def last_value_at_or_before(series: pd.Series, asof: datetime | str | pd.Timestamp) -> float | None:
+    """
+    Return the last non-null value at or before `asof`.
+
+    Returns None if no value exists in the window.
+    """
+    ts = pd.Timestamp(asof)
+    s = series.loc[:ts].dropna()
+    if s.empty:
+        return None
+    val = s.iloc[-1]
+    try:
+        return float(val)
+    except Exception:
+        return None
+
+
+def empirical_percentile(value: float, reference_values: Iterable[float]) -> float | None:
+    """
+    Empirical percentile as fraction of reference values <= value.
+
+    Returns None if reference is empty after filtering.
+    """
+    ref = [float(x) for x in reference_values if x is not None and not np.isnan(x)]
+    if not ref:
+        return None
+    return float(np.mean([x <= value for x in ref]))
+
+
+def point_stats(value: float | None, reference_values: Iterable[float]) -> tuple[float | None, float | None, float | None, float | None]:
+    """
+    Compute (mean, std, zscore, percentile) for a value vs reference values.
+
+    Std is sample std (ddof=1) when at least 2 reference values exist, else 0.0.
+    """
+    ref = np.array([float(x) for x in reference_values if x is not None and not np.isnan(x)], dtype=float)
+    if value is None or np.isnan(value) or ref.size == 0:
+        return None, None, None, None
+
+    mean = float(np.mean(ref))
+    std = float(np.std(ref, ddof=1)) if ref.size >= 2 else 0.0
+    z = None if std == 0.0 else float((float(value) - mean) / std)
+    p = empirical_percentile(float(value), ref.tolist())
+    return mean, std, z, p
+
+
+def select_reindex_prompt_column(df_reindexed: pd.DataFrame, *, within_days: int = 10):
+    """
+    Determine the "prompt" column for a reindex-year dataframe.
+
+    Mirrors the legacy behavior in `commodplot.commodplotutil.reindex_year_df_rel_col`:
+    - Prefer a column whose label contains `dates.curyear`.
+    - If that column ends within `within_days` of the max x-date, prefer next year's column.
+    """
+    if df_reindexed is None or df_reindexed.empty:
+        return None
+
+    res_col = df_reindexed.columns[0]
+
+    year_map = dates.find_year(df_reindexed)
+    last_val_date = df_reindexed.index[-1]
+
+    current_year_cols = [c for c in df_reindexed.columns if str(dates.curyear) in str(c)]
+    if not current_year_cols:
+        return res_col
+
+    res_col = current_year_cols[0]
+    res_year = year_map.get(res_col)
+    if not isinstance(res_year, int):
+        return res_col
+
+    relyear = pd.to_datetime(f"{res_year}-01-01")
+
+    dft = df_reindexed[current_year_cols].dropna()
+    if len(dft) == 0:
+        return res_col
+
+    relcol_series = df_reindexed[res_col].dropna()
+    if relcol_series.empty:
+        return res_col
+
+    relcol_date = relcol_series.index[-1]
+    delta = last_val_date - relcol_date
+    if delta.days < within_days:
+        relyear1 = (relyear + pd.DateOffset(years=1)).year
+        relyear1_cols = [c for c in df_reindexed.columns if str(relyear1) in str(c)]
+        if relyear1_cols:
+            return relyear1_cols[0]
+
+    return res_col
+
+
+def reindex_year_point_stats(
+    df: pd.DataFrame,
+    *,
+    asof: datetime | str | pd.Timestamp | None = None,
+    lookback_years: int = 5,
+    within_days: int = 10,
+) -> PointStats:
+    """
+    Compute point stats for a reindex-year view.
+
+    - Reindex to current year (`commodutil.transforms.reindex_year`).
+    - Pick the prompt column via `select_reindex_prompt_column`.
+    - Compare prompt value at `asof` vs prior `lookback_years` years at the same as-of date.
+    """
+    if df is None or df.empty:
+        return PointStats(
+            asof=pd.NaT,
+            current_year=None,
+            current_value=None,
+            reference_years=[],
+            reference_values=[],
+            mean=None,
+            std=None,
+            zscore=None,
+            percentile=None,
+        )
+
+    dft = transforms.reindex_year(df)
+    if dft is None or dft.empty:
+        return PointStats(
+            asof=pd.NaT,
+            current_year=None,
+            current_value=None,
+            reference_years=[],
+            reference_values=[],
+            mean=None,
+            std=None,
+            zscore=None,
+            percentile=None,
+        )
+
+    asof_ts = pd.Timestamp(dft.index.max()) if asof is None else pd.Timestamp(asof)
+
+    prompt_col = select_reindex_prompt_column(dft, within_days=within_days)
+    year_map = dates.find_year(dft)
+    prompt_year = year_map.get(prompt_col) if prompt_col is not None else None
+    prompt_year_int = prompt_year if isinstance(prompt_year, int) else None
+
+    current_value = (
+        last_value_at_or_before(dft[prompt_col], asof_ts) if prompt_col is not None else None
+    )
+
+    reference_years: list[int] = []
+    reference_values: list[float] = []
+    if prompt_year_int is not None:
+        start_year = prompt_year_int - lookback_years
+        end_year = prompt_year_int - 1
+        for col in dft.columns:
+            col_year = year_map.get(col)
+            if not isinstance(col_year, int):
+                continue
+            if start_year <= col_year <= end_year:
+                val = last_value_at_or_before(dft[col], asof_ts)
+                if val is not None:
+                    reference_years.append(col_year)
+                    reference_values.append(val)
+
+    mean, std, z, p = point_stats(current_value, reference_values)
+    return PointStats(
+        asof=asof_ts,
+        current_year=prompt_year_int,
+        current_value=current_value,
+        reference_years=reference_years,
+        reference_values=reference_values,
+        mean=mean,
+        std=std,
+        zscore=z,
+        percentile=p,
+    )
+
+
+def seasonal_point_stats(
+    seas: pd.DataFrame,
+    *,
+    asof: datetime | str | pd.Timestamp | None = None,
+    lookback_years: int = 5,
+) -> PointStats:
+    """
+    Compute point stats from a seasonalized dataframe.
+
+    Expects:
+    - Index: current-year dates
+    - Columns: years (ints)
+
+    Uses `dates.curyear` as the current year column if present; otherwise uses max year column.
+    """
+    if seas is None or seas.empty:
+        return PointStats(
+            asof=pd.NaT,
+            current_year=None,
+            current_value=None,
+            reference_years=[],
+            reference_values=[],
+            mean=None,
+            std=None,
+            zscore=None,
+            percentile=None,
+        )
+
+    year_cols = [c for c in seas.columns if isinstance(c, (int, np.integer))]
+    if not year_cols:
+        return PointStats(
+            asof=pd.NaT,
+            current_year=None,
+            current_value=None,
+            reference_years=[],
+            reference_values=[],
+            mean=None,
+            std=None,
+            zscore=None,
+            percentile=None,
+        )
+
+    current_year = dates.curyear if dates.curyear in year_cols else int(max(year_cols))
+    asof_ts = pd.Timestamp(seas.index.max()) if asof is None else pd.Timestamp(asof)
+    asof_ts = min(asof_ts, pd.Timestamp(seas.index.max()))
+
+    # Use the last index <= asof, to avoid KeyError for non-trading days.
+    valid_idx = seas.index[seas.index <= asof_ts]
+    if len(valid_idx) == 0:
+        return PointStats(
+            asof=pd.NaT,
+            current_year=int(current_year),
+            current_value=None,
+            reference_years=[],
+            reference_values=[],
+            mean=None,
+            std=None,
+            zscore=None,
+            percentile=None,
+        )
+
+    asof_row = pd.Timestamp(valid_idx.max())
+    try:
+        current_value = float(seas.loc[asof_row, current_year])
+    except Exception:
+        current_value = None
+
+    reference_years = [
+        int(y)
+        for y in year_cols
+        if (current_year - lookback_years) <= int(y) <= (current_year - 1)
+    ]
+    reference_values: list[float] = []
+    for y in reference_years:
+        try:
+            reference_values.append(float(seas.loc[asof_row, y]))
+        except Exception:
+            continue
+
+    mean, std, z, p = point_stats(current_value, reference_values)
+    return PointStats(
+        asof=asof_row,
+        current_year=int(current_year),
+        current_value=current_value,
+        reference_years=reference_years,
+        reference_values=reference_values,
+        mean=mean,
+        std=std,
+        zscore=z,
+        percentile=p,
+    )
+
+
+def _base_label_from_column(col) -> str | None:
+    """
+    Derive a stable group key from a column label by stripping year-like tokens.
+
+    Intended for grouping structures like:
+    - "JunAug 2026" -> "JunAug"
+    - "Q1Q2 2026" -> "Q1Q2"
+    - "CAL 2025-2026" -> "CAL"
+
+    Returns None if the label cannot be converted to a non-empty key.
+    """
+    s = str(col).strip()
+    if not s:
+        return None
+
+    # Remove year ranges and single years (prefer full year tokens).
+    s = re.sub(r"\b(19|20)\d{2}\s*-\s*(19|20)\d{2}\b", "", s)
+    s = re.sub(r"\b(19|20)\d{2}\b", "", s)
+
+    # Cleanup leftover separators/spaces.
+    s = re.sub(r"[-/]+", " ", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s or None
+
+
+def reindex_year_point_stats_table(
+    df: pd.DataFrame,
+    *,
+    asof: datetime | str | pd.Timestamp | None = None,
+    lookback_years: int = 5,
+    within_days: int = 10,
+    min_columns: int = 3,
+) -> pd.DataFrame:
+    """
+    Compute prompt-vs-history point stats for many structures in one dataframe.
+
+    This is designed for frames where columns encode both a structure key and a year,
+    e.g. "JunAug 2025", "JunAug 2026", "DecJan 2025", etc.
+
+    The function:
+    - groups columns by a "base label" (column label with year tokens stripped),
+    - runs `reindex_year_point_stats` per group,
+    - returns a sortable table (z-score/percentile) for scanning cheap/rich structures.
+
+    Notes:
+    - Columns must include a 4-digit year somewhere for `dates.find_year` to work reliably.
+    - Groups with fewer than `min_columns` columns are skipped.
+    """
+    if df is None or df.empty:
+        return pd.DataFrame(
+            columns=[
+                "group",
+                "asof",
+                "prompt_year",
+                "value",
+                "mean",
+                "std",
+                "zscore",
+                "percentile",
+                "n_reference",
+            ]
+        )
+
+    groups: dict[str, list] = {}
+    for col in df.columns:
+        key = _base_label_from_column(col)
+        if key is None:
+            continue
+        groups.setdefault(key, []).append(col)
+
+    rows: list[dict] = []
+    for key, cols in groups.items():
+        if len(cols) < min_columns:
+            continue
+        stats_res = reindex_year_point_stats(
+            df[cols],
+            asof=asof,
+            lookback_years=lookback_years,
+            within_days=within_days,
+        )
+        rows.append(
+            {
+                "group": key,
+                "asof": stats_res.asof,
+                "prompt_year": stats_res.current_year,
+                "value": stats_res.current_value,
+                "mean": stats_res.mean,
+                "std": stats_res.std,
+                "zscore": stats_res.zscore,
+                "percentile": stats_res.percentile,
+                "n_reference": len(stats_res.reference_values),
+            }
+        )
+
+    if not rows:
+        return pd.DataFrame(
+            columns=[
+                "group",
+                "asof",
+                "prompt_year",
+                "value",
+                "mean",
+                "std",
+                "zscore",
+                "percentile",
+                "n_reference",
+            ]
+        )
+
+    res = pd.DataFrame(rows).set_index("group").sort_values(["zscore", "percentile"], ascending=[True, True])
+    return res

{commodutil-3.2.3 → commodutil-3.3.0}/commodutil/transforms.py

@@ -44,6 +44,40 @@ def seasonailse(df, fillna=True):
     return seas
 
 
+def seasonalize(data, histfreq: str | None = None, fillna: bool = True):
+    """
+    Canonical seasonalization helper.
+
+    This mirrors the logic historically living in `commodplot.commodplottransform.seasonalise`,
+    but keeps the core transformation in `commodutil`.
+
+    Args:
+        data: Series or DataFrame with a DatetimeIndex.
+        histfreq: Optional frequency hint. If None, inferred from index; defaults to "D".
+        fillna: Passed through to `seasonailse` for daily/monthly paths.
+
+    Returns:
+        Seasonalized DataFrame aligned to the current year index, with year columns.
+    """
+    if isinstance(data, pd.Series):
+        data = pd.DataFrame(data)
+
+    if histfreq is None:
+        histfreq = pd.infer_freq(data.index)
+        if histfreq is None:
+            histfreq = "D"
+
+    if histfreq.startswith("W"):
+        seas = seasonalise_weekly(data)
+    else:
+        # `seasonailse` expects a Series (takes first column when given DataFrame),
+        # but we normalize above to DataFrame so this stays consistent with legacy behavior.
+        seas = seasonailse(data, fillna=fillna)
+
+    seas = seas.dropna(how="all", axis=1)
+    return seas
+
+
 def cleanup_weekly_data(df):
     """
     Processes dates in a DataFrame to ensure that the intended weekday data is present for each week.

{commodutil-3.2.3 → commodutil-3.3.0}/commodutil.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commodutil
-Version: 3.2.3
+Version: 3.3.0
 Summary: common commodity/oil analytics utils
 Author-email: aeorxc <author@example.com>
 Project-URL: Homepage, https://dev.azure.com/RWEST-MFI-TE/Oil/_git/commodutil

commodutil-3.3.0/tests/test_stats.py

@@ -0,0 +1,131 @@
+import os
+import unittest
+
+import numpy as np
+import pandas as pd
+
+from commodutil import dates
+from commodutil import forwards
+from commodutil import stats
+from commodutil.forward.util import convert_contract_to_date
+
+
+class TestForwards(unittest.TestCase):
+    def test_curve_zscore(self):
+        dirname, filename = os.path.split(os.path.abspath(__file__))
+        cl = pd.read_csv(
+            os.path.join(dirname, "test_cl.csv"),
+            index_col=0,
+            parse_dates=True,
+            dayfirst=True,
+        )
+        contracts = cl.rename(
+            columns={x: pd.to_datetime(convert_contract_to_date(x)) for x in cl.columns}
+        )
+        hist = contracts[["2020-01-01"]].dropna()
+        fwd = contracts[["2020-01-01"]]
+
+        res = stats.curve_seasonal_zscore(hist, fwd)
+        self.assertAlmostEqual(res["zscore"]["2019-01-02"], 0.92, 2)
+
+    def test_reindex_zscore(self):
+        dirname, filename = os.path.split(os.path.abspath(__file__))
+        cl = pd.read_csv(
+            os.path.join(dirname, "test_cl.csv"),
+            index_col=0,
+            parse_dates=True,
+            dayfirst=True,
+        )
+        contracts = cl.rename(
+            columns={x: pd.to_datetime(convert_contract_to_date(x)) for x in cl.columns}
+        )
+
+        q = forwards.quarterly_contracts(contracts)
+        q = q[[x for x in q.columns if "Q1" in x]]
+
+        res = stats.reindex_zscore(q, calc_year_start=2022)
+        self.assertIsNotNone(res)
+
+    def test_select_reindex_prompt_column(self):
+        """
+        If the current-year column ends within 10 days of the max x-date, prefer next year.
+        Otherwise prefer current year.
+        """
+        idx = pd.date_range(f"{dates.curyear}-01-01", f"{dates.curyear}-01-31", freq="D")
+        df = pd.DataFrame(
+            {
+                f"Spread {dates.curyear}": np.arange(len(idx), dtype=float),
+                f"Spread {dates.curyear + 1}": np.arange(len(idx), dtype=float) + 100.0,
+            },
+            index=idx,
+        )
+
+        df1 = df.copy()
+        df1.loc[idx[-20:], f"Spread {dates.curyear}"] = np.nan
+        sel1 = stats.select_reindex_prompt_column(df1, within_days=10)
+        self.assertEqual(sel1, f"Spread {dates.curyear}")
+
+        df2 = df.copy()
+        df2.loc[idx[-5:], f"Spread {dates.curyear}"] = np.nan
+        sel2 = stats.select_reindex_prompt_column(df2, within_days=10)
+        self.assertEqual(sel2, f"Spread {dates.curyear + 1}")
+
+    def test_reindex_year_point_stats(self):
+        """
+        Ensure point-stats uses aligned as-of values across years after reindexing.
+        """
+        years = [dates.curyear - 2, dates.curyear - 1, dates.curyear, dates.curyear + 1]
+        frames = []
+        for y in years:
+            # Extend y+1 so the overall max x-date is later than current-year column,
+            # making the prompt selection stay on current year (delta>=10 days).
+            end_day = "01-31" if y == dates.curyear + 1 else "01-10"
+            idx = pd.date_range(f"{y}-01-01", f"{y}-{end_day}", freq="D")
+            if y == dates.curyear - 2:
+                vals = np.full(len(idx), 10.0)
+            elif y == dates.curyear - 1:
+                vals = np.full(len(idx), 12.0)
+            elif y == dates.curyear:
+                vals = np.full(len(idx), 15.0)
+            else:
+                vals = np.full(len(idx), 99.0)
+
+            frames.append(pd.DataFrame({f"Spread {y}": vals}, index=idx))
+
+        df = pd.concat(frames, axis=1, join="outer")
+
+        asof = f"{dates.curyear}-01-10"
+        res = stats.reindex_year_point_stats(df, asof=asof, lookback_years=2, within_days=10)
+
+        self.assertEqual(res.current_year, dates.curyear)
+        self.assertAlmostEqual(res.current_value, 15.0, 6)
+        self.assertEqual(sorted(res.reference_years), [dates.curyear - 2, dates.curyear - 1])
+        self.assertAlmostEqual(res.mean, 11.0, 6)
+        self.assertAlmostEqual(res.std, np.sqrt(2.0), 6)
+        self.assertAlmostEqual(res.zscore, 2.828427, 4)
+        self.assertAlmostEqual(res.percentile, 1.0, 6)
+
+    def test_reindex_year_point_stats_table_groups(self):
+        idx = pd.date_range(f"{dates.curyear}-01-01", f"{dates.curyear}-01-10", freq="D")
+        df = pd.DataFrame(
+            {
+                # Group A (3 years -> should be included with min_columns=3)
+                "JunAug 2024": np.full(len(idx), 10.0),
+                "JunAug 2025": np.full(len(idx), 11.0),
+                "JunAug 2026": np.full(len(idx), 12.0),
+                # Group B (2 years -> should be excluded with min_columns=3)
+                "DecJan 2025": np.full(len(idx), 5.0),
+                "DecJan 2026": np.full(len(idx), 6.0),
+            },
+            index=idx,
+        )
+
+        table = stats.reindex_year_point_stats_table(df, lookback_years=2, min_columns=3)
+        self.assertIn("JunAug", table.index)
+        self.assertNotIn("DecJan", table.index)
+        self.assertIn("zscore", table.columns)
+        self.assertEqual(int(table.loc["JunAug", "prompt_year"]), dates.curyear)
+
+
+if __name__ == "__main__":
+    unittest.main()

commodutil-3.2.3/commodutil/stats.py

@@ -1,50 +0,0 @@
-import re
-
-import pandas as pd
-
-from commodutil import dates
-from commodutil import transforms
-
-
-def curve_seasonal_zscore(hist, fwd):
-    """
-    Given some history for a timeseries and a forward curve, calculate the monthly
-    z-score (std dev away from mean) along the forward curve
-    """
-
-    d = transforms.monthly_mean(hist).T.describe()
-
-    if isinstance(fwd, pd.Series):
-        fwd = pd.DataFrame(fwd)
-    fwd["zscore"] = fwd.apply(
-        lambda x: (d[x.name.month].loc["mean"] - x.iloc[0])
-        / d[x.name.month].loc["std"],
-        1,
-    )
-    return fwd
-
-
-def reindex_zscore(df, range=10, calc_year_start: int = None):
-    """
-    Given a dataframe of contracts (or spreads), calculate z-score for current year onwards
-    Essentially returns how far away the 'curve' is from historical trading range
-    """
-    df = df
-    df = df.rename(
-        columns={x: int(re.findall("\d\d\d\d", str(x))[0]) for x in df.columns}
-    )  # turn columns into years
-    d = df.loc[
-        :, dates.curyear - range - 1 : dates.curyear - 1
-    ]  # get subset of range years
-    d = d[:-10]  # exclude last 10 rows to due to volatility close to expire
-
-    dfs = []
-    if not calc_year_start:
-        calc_year_start = dates.curyear
-    for year in df.loc[:, calc_year_start : df.columns[-1]]:
-        z = (d.mean(axis=1) - df.loc[:, year]) / d.std(axis=1)
-        z.name = year
-        dfs.append(z)
-    if len(dfs) > 0:
-        res = pd.concat(dfs, axis=1)
-        return res

commodutil-3.2.3/tests/test_stats.py

@@ -1,57 +0,0 @@
-import os
-import unittest
-
-import pandas as pd
-
-from commodutil import forwards
-from commodutil import stats
-from commodutil.forward.util import convert_contract_to_date
-
-
-class TestForwards(unittest.TestCase):
-    def test_curve_zscore(self):
-        dirname, filename = os.path.split(os.path.abspath(__file__))
-        cl = pd.read_csv(
-            os.path.join(dirname, "test_cl.csv"),
-            index_col=0,
-            parse_dates=True,
-            dayfirst=True,
-        )
-        contracts = cl.rename(
-            columns={
-                x: pd.to_datetime(convert_contract_to_date(x))
-                for x in cl.columns
-            }
-        )
-        hist = contracts[["2020-01-01"]].dropna()
-
-        fwd = contracts[["2020-01-01"]]
-
-        res = stats.curve_seasonal_zscore(hist, fwd)
-
-        self.assertAlmostEqual(res["zscore"]["2019-01-02"], 0.92, 2)
-
-    def test_reindex_zscore(self):
-        dirname, filename = os.path.split(os.path.abspath(__file__))
-        cl = pd.read_csv(
-            os.path.join(dirname, "test_cl.csv"),
-            index_col=0,
-            parse_dates=True,
-            dayfirst=True,
-        )
-        contracts = cl.rename(
-            columns={
-                x: pd.to_datetime(convert_contract_to_date(x))
-                for x in cl.columns
-            }
-        )
-
-        q = forwards.quarterly_contracts(contracts)
-        q = q[[x for x in q.columns if "Q1" in x]]
-
-        res = stats.reindex_zscore(q, calc_year_start=2022)
-        self.assertIsNotNone(res)
-
-
-if __name__ == "__main__":
-    unittest.main()