numerai-tools 0.5.0.dev2__tar.gz → 0.5.0.dev4__tar.gz

{numerai_tools-0.5.0.dev2 → numerai_tools-0.5.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: numerai-tools
-Version: 0.5.0.dev2
+Version: 0.5.0.dev4
 Summary: A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
 License: MIT
 Author: Numerai Engineering
@@ -26,3 +26,15 @@ Description-Content-Type: text/markdown
 # numerai-tools
 A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
 
+## Installation
+```
+pip install numerai-tools
+```
+
+## Structure
+
+- The `scoring.py` module contains critical functions used to score submissions. We use this code in our scoring system system. Leverage this to optimize your models for the tournaments.
+
+- The `submissions.py` module provides helper functions to ensure your submissions are valid and formatted correctly. Use this in your automated prediction pipelines to ensure uploads don't fail.
+
+- The `signals.py` module provides code specific to Numerai Signals such as churn and turnover. Use this to ensure your Signals submissions are properly formatted.

numerai_tools-0.5.0.dev4/README.md

@@ -0,0 +1,15 @@
+# numerai-tools
+A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
+
+## Installation
+```
+pip install numerai-tools
+```
+
+## Structure
+
+- The `scoring.py` module contains critical functions used to score submissions. We use this code in our scoring system system. Leverage this to optimize your models for the tournaments.
+
+- The `submissions.py` module provides helper functions to ensure your submissions are valid and formatted correctly. Use this in your automated prediction pipelines to ensure uploads don't fail.
+
+- The `signals.py` module provides code specific to Numerai Signals such as churn and turnover. Use this to ensure your Signals submissions are properly formatted.

{numerai_tools-0.5.0.dev2 → numerai_tools-0.5.0.dev4}/numerai_tools/scoring.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, Union, Optional, TypeVar, cast, Any
+from typing import List, Literal, Tuple, Union, Optional, TypeVar, cast, Any
 
 import numpy as np
 import pandas as pd
@@ -14,6 +14,7 @@ DEFAULT_MAX_FILTERED_INDEX_RATIO = 0.2
 
 S1 = TypeVar("S1", bound=Union[pd.DataFrame, pd.Series])
 S2 = TypeVar("S2", bound=Union[pd.DataFrame, pd.Series])
+RANK_METHOD_TYPE = Literal["average", "min", "max", "first", "dense"]
 
 
 def filter_sort_index(
@@ -109,22 +110,38 @@ def filter_sort_top_bottom_concat(s: pd.Series, top_bottom: int) -> pd.Series:
     return pd.concat([top, bot]).sort_index()
 
 
-def rank(df: pd.DataFrame, method: str = "average") -> pd.DataFrame:
-    """Percentile rank each column of a pandas DataFrame, centering values around 0.5
+def rank_series(s: pd.Series, method: RANK_METHOD_TYPE = "average") -> pd.Series:
+    """Percentile rank a pandas Series, centering values around 0.5.
 
     Arguments:
-        df: pd.DataFrame - the data to rank
+        s: pd.Series - the data to rank
         method: str - the pandas ranking method to use, options:
             'average' (default) - keeps ties
             'first' - breaks ties by index
 
     Returns:
-        pd.DataFrame - the ranked DataFrame
+        pd.Series - the ranked Series
     """
-    assert np.array_equal(df.index.sort_values(), df.index), "unsorted index found"
-    return df.apply(
-        lambda series: (series.rank(method=method).values - 0.5) / series.count()
-    )
+    assert np.array_equal(s.index.sort_values(), s.index), "unsorted index found"
+    return (s.rank(method=method) - 0.5) / s.count()
+
+
+def rank(s: S1, method: RANK_METHOD_TYPE = "average") -> S1:
+    """Percentile rank each columns or series, centering values around 0.5
+
+    Arguments:
+        s: pd.DataFrame | pd.Series - the data to rank
+        method: str - the pandas ranking method to use, options:
+            'average' (default) - keeps ties
+            'first' - breaks ties by index
+
+    Returns:
+        pd.DataFrame | pd.Series - the ranked input data
+    """
+    if isinstance(s, pd.Series):
+        return cast(S1, rank_series(s, method))
+    else:
+        return s.apply(lambda series: rank(series, method=method))
 
 
 def tie_broken_rank(df: pd.DataFrame) -> pd.DataFrame:
@@ -132,9 +149,9 @@ def tie_broken_rank(df: pd.DataFrame) -> pd.DataFrame:
     return rank(df, "first")
 
 
-def tie_kept_rank(df: pd.DataFrame) -> pd.DataFrame:
+def tie_kept_rank(s: S1) -> S1:
     """Rank columns, but keep ties."""
-    return rank(df, "average")
+    return cast(S1, rank(s, "average"))
 
 
 def min_max_normalize(s: pd.Series) -> pd.Series:
@@ -539,14 +556,26 @@ def max_feature_correlation(
 
 
 def generate_neutralized_weights(
-    predictions: pd.Series,
+    predictions: pd.DataFrame,
     neutralizers: pd.DataFrame,
     sample_weights: pd.Series,
+    center_and_normalize: bool = False,
 ) -> pd.Series:
-    neutral_preds = predictions - (
-        neutralizers @ (neutralizers.T @ (sample_weights * predictions))
+    assert not predictions.isna().any().any(), "Predictions contain NaNs"
+    assert not neutralizers.isna().any().any(), "Normalization factors contain NaNs"
+    assert not sample_weights.isna().any(), "Weights contain NaNs"
+    ranked_predictions = tie_kept_rank__gaussianize__pow_1_5(predictions)
+    ranked_predictions, neutralizers, sample_weights = filter_sort_index_many(
+        [ranked_predictions, neutralizers, sample_weights]
+    )
+    neutral_weights = ranked_predictions.apply(
+        lambda s_prime: (
+            s_prime - neutralizers @ (neutralizers.T @ (sample_weights * s_prime))
+        )
+        * sample_weights
     )
-    neutral_weights = neutral_preds * sample_weights
+    if center_and_normalize:
+        neutral_weights = weight_normalize(center(neutral_weights))
     return neutral_weights
 
 
@@ -568,18 +597,8 @@ def alpha(
         targets: pd.Series - the live targets to evaluate against
     """
     targets = center(targets)
-    assert not predictions.isna().any().any(), "Predictions contain NaNs"
-    assert not neutralizers.isna().any().any(), "Normalization factors contain NaNs"
-    assert not sample_weights.isna().any(), "Weights contain NaNs"
-    predictions, neutralizers, sample_weights, targets = filter_sort_index_many(
-        [predictions, neutralizers, sample_weights, targets]
-    )
-    ranked_preds = tie_kept_rank__gaussianize__pow_1_5(predictions)
-    weights = ranked_preds.apply(
-        lambda s_prime: generate_neutralized_weights(
-            s_prime, neutralizers, sample_weights
-        )
-    )
+    predictions, targets = filter_sort_index(predictions, targets)
+    weights = generate_neutralized_weights(predictions, neutralizers, sample_weights)
     alpha_scores = weights.apply(lambda w: w @ targets) / len(targets)
     return alpha_scores
 
@@ -605,19 +624,10 @@ def meta_portfolio_contribution(
         targets: pd.Series - the live targets to evaluate against
     """
     targets = center(targets)
-    assert not predictions.isna().any().any(), "Predictions contain NaNs"
-    assert not neutralizers.isna().any().any(), "Normalization factors contain NaNs"
-    assert not sample_weights.isna().any(), "Weights contain NaNs"
-    predictions, neutralizers, sample_weights, targets = filter_sort_index_many(
-        [predictions, neutralizers, sample_weights, targets]
-    )
+    predictions, targets = filter_sort_index(predictions, targets)
     stake_weights = weight_normalize(stakes.fillna(0))
     assert np.isclose(stake_weights.sum(), 1), "Stakes must sum to 1"
-    weights = tie_kept_rank__gaussianize__pow_1_5(predictions).apply(
-        lambda s_prime: generate_neutralized_weights(
-            s_prime, neutralizers, sample_weights
-        )
-    )
+    weights = generate_neutralized_weights(predictions, neutralizers, sample_weights)
     w = cast(np.ndarray, weights[stakes.index].values)
     s = cast(np.ndarray, stake_weights.values)
     t = cast(np.ndarray, targets.values)

{numerai_tools-0.5.0.dev2 → numerai_tools-0.5.0.dev4}/numerai_tools/signals.py

@@ -1,16 +1,14 @@
 from typing import Tuple, Optional
 
-from numerai_tools.submissions import validate_headers_signals, validate_ids_signals
 from numerai_tools.scoring import (
     filter_sort_index,
     filter_sort_top_bottom,
     spearman_correlation,
-    tie_kept_rank,
-    tie_kept_rank__gaussianize__pow_1_5,
-    filter_sort_index_many,
     generate_neutralized_weights,
-    weight_normalize,
-    center,
+)
+from numerai_tools.submissions import (
+    validate_and_clean_submission_signals,
+    remap_ids,
 )
 
 import pandas as pd
@@ -79,48 +77,6 @@ def turnover(
     return turnover
 
 
-def neutral_weight(
-    submission: pd.Series,
-    signal_col: str,
-    neutralizer: pd.DataFrame,
-    weight: pd.Series,
-) -> pd.Series:
-    s_prime = tie_kept_rank__gaussianize__pow_1_5(submission.to_frame())
-    s_prime, neutralizer, weight = filter_sort_index_many(
-        [s_prime, neutralizer, weight]
-    )
-    neutral_weights = generate_neutralized_weights(
-        s_prime[signal_col], neutralizer, weight
-    )
-    neutral_weights = weight_normalize(center(neutral_weights.to_frame()))[0]
-    return neutral_weights.sort_index()
-
-
-def remap_ticker_col(
-    predictions: pd.DataFrame,
-    universe: pd.DataFrame,
-    ticker_col: str,
-) -> pd.DataFrame:
-    return (
-        predictions.join(universe, how="right")
-        .reset_index()
-        .set_index(ticker_col)
-        .sort_index()
-    )
-
-
-def rank_and_fill_signal(
-    universe: pd.DataFrame,
-    submission: pd.Series,
-    signal_col: str,
-) -> pd.Series:
-    uni_joined_sub = universe.sort_index().join(
-        tie_kept_rank(submission.sort_index().to_frame())
-    )[[signal_col]]
-    filled_sub = uni_joined_sub.fillna(uni_joined_sub.median()).sort_index()
-    return filled_sub[signal_col]
-
-
 def calculate_max_churn_and_turnover(
     curr_sub: pd.DataFrame,
     curr_neutralizer: pd.DataFrame,
@@ -141,7 +97,7 @@ def calculate_max_churn_and_turnover(
         prev_week_subs -- a dictionary of datestamps to submissions
         prev_neutralizers -- a dictionary of datestamps to neutralizers
         prev_sample_weights -- a dictionary of datestamps to sample weights
-        universe -- the internal universe DataFrame
+        universe -- the universe DataFrame for the current era
         curr_signal_col -- the column name for signal in the current submission
         curr_ticker_col -- the column name for tickers in the current submission
 
@@ -149,49 +105,48 @@ def calculate_max_churn_and_turnover(
         prev_week_max_churn -- the maximum churn from previous submissions
         prev_week_max_turnover -- the maximum turnover from previous submissions
     """
-    curr_sub_vector: pd.Series = rank_and_fill_signal(
-        universe,
-        curr_sub.reset_index().set_index(curr_ticker_col).sort_index()[curr_signal_col],
-        curr_signal_col,
+    universe = universe.reset_index()
+    curr_sub_vector = validate_and_clean_submission_signals(
+        universe=universe,
+        submission=curr_sub,
+        id_col=curr_ticker_col,
+        rename_as=curr_signal_col,
+        rank_and_fill=True,
     )
     churn_stats = []
     turnover_stats = []
-    neutralized_weights = neutral_weight(
-        curr_sub_vector, curr_signal_col, curr_neutralizer, curr_weight
+    neutralized_weights = generate_neutralized_weights(
+        curr_sub_vector.to_frame(), curr_neutralizer, curr_weight
     )
     for datestamp in prev_week_subs:
         prev_sub = prev_week_subs[datestamp]
         prev_neutralizer = prev_neutralizers[datestamp]
         prev_weight = prev_sample_weights[datestamp]
-        prev_ticker_col, prev_signal_col = validate_headers_signals(prev_sub)
-        prev_universe = universe.reset_index().set_index(prev_ticker_col)
-        filtered_prev_sub_df, _ = validate_ids_signals(
-            prev_universe.index.to_series(), prev_sub, prev_ticker_col
-        )
-        # in case the previous submission has a different ticker column,
-        # remap the ticker column of prev data to the current ticker column
-        filtered_prev_sub = remap_ticker_col(
-            filtered_prev_sub_df.set_index(prev_ticker_col),
-            universe=prev_universe,
-            ticker_col=curr_ticker_col,
-        )[curr_signal_col]
-        filtered_prev_sub = rank_and_fill_signal(
+        filtered_prev_sub = validate_and_clean_submission_signals(
             universe=universe,
-            submission=filtered_prev_sub,
-            signal_col=curr_signal_col,
+            submission=prev_sub,
+            id_col=curr_ticker_col,
+            rename_as=curr_signal_col,
+            rank_and_fill=True,
+        )
+        prev_neutralizer = (
+            remap_ids(
+                prev_neutralizer.reset_index(),
+                universe,
+                str(prev_neutralizer.index.name),
+                curr_ticker_col,
+            )
+            .set_index(curr_ticker_col)
+            .filter(like="neutralizer_")
         )
-        prev_neutralizer = remap_ticker_col(
-            prev_neutralizer,
-            universe=prev_universe,
-            ticker_col=curr_ticker_col,
-        ).filter(like="neutralizer_")
-        prev_weight = remap_ticker_col(
-            prev_weight.to_frame(),
-            universe=prev_universe,
-            ticker_col=curr_ticker_col,
-        )[prev_weight.name]
-        prev_neutralized_weights = neutral_weight(
-            filtered_prev_sub, prev_signal_col, prev_neutralizer, prev_weight
+        prev_weight = remap_ids(
+            prev_weight.reset_index(),
+            universe,
+            str(prev_weight.index.name),
+            curr_ticker_col,
+        ).set_index(curr_ticker_col)[prev_weight.name]
+        prev_neutralized_weights = generate_neutralized_weights(
+            filtered_prev_sub.to_frame(), prev_neutralizer, prev_weight
         )
         try:
             churn_val = abs(churn(curr_sub_vector, filtered_prev_sub))

{numerai_tools-0.5.0.dev2 → numerai_tools-0.5.0.dev4}/numerai_tools/submissions.py

@@ -1,7 +1,7 @@
 from numerai_tools.scoring import tie_kept_rank
 
 import logging
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 
 import pandas as pd
 import numpy as np
@@ -49,9 +49,10 @@ def _validate_headers(
     ]
     columns = submission.columns
     valid_headers = list(columns) in expected_headers
-    assert (
-        valid_headers
-    ), f"headers must be one of {expected_id_cols} and one of {expected_pred_cols}"
+    assert valid_headers, (
+        "invalid_submission_headers: headers must be one of"
+        f" {expected_id_cols} and one of {expected_pred_cols}"
+    )
     return columns[0], columns[1]
 
 
@@ -62,17 +63,6 @@ def validate_headers_numerai(submission: pd.DataFrame) -> Tuple[str, str]:
 
 
 def validate_headers_signals(submission: pd.DataFrame) -> Tuple[str, str]:
-    if "data_type" in submission.columns:
-        logger.warning(
-            "data_type column found in Signals submission. This is deprecated and will be removed in the future. "
-            "Please remove the data_type column from your Signals submission."
-        )
-        date_col = [
-            date_col
-            for date_col in SIGNALS_ALLOWED_DATE_COLS
-            if date_col in list(submission.columns)
-        ]
-        submission = submission.drop(columns=["data_type", *date_col], errors="ignore")
     return _validate_headers(
         SIGNALS_ALLOWED_ID_COLS, SIGNALS_ALLOWED_PRED_COLS, submission
     )
@@ -95,13 +85,13 @@ def validate_values(submission: pd.DataFrame, prediction_col: str) -> None:
     """
     assert (
         submission[prediction_col].isna().sum() == 0
-    ), "submission must not contain NaNs"
+    ), "invalid_submission_values: submission must not contain NaNs"
     assert (
         submission[prediction_col].between(0, 1).all()
-    ), "values must be between 0 and 1 exclusive"
+    ), "invalid_submission_values: values must be between 0 and 1 exclusive"
     assert not np.isclose(
         0, submission[prediction_col].std()
-    ), "submission must have non-zero standard deviation"
+    ), "invalid_submission_values: submission must have non-zero standard deviation"
 
 
 def _validate_ids(
@@ -127,7 +117,7 @@ def _validate_ids(
     """
     assert (
         not submission[id_col].isna().any()
-    ), f"Submission must not contain NaNs in the {id_col} column."
+    ), f"invalid_submission_ids: Submission must not contain NaNs in the {id_col} column."
 
     index_sub = submission.copy()
     index_sub[id_col] = index_sub[id_col].astype(str)
@@ -136,12 +126,13 @@ def _validate_ids(
     live_sub = index_sub[index_sub[id_col].isin(live_ids)].sort_values(id_col)
     assert (
         not live_sub[id_col].duplicated().any()
-    ), f"Duplicates detected in {id_col} for live period."
+    ), f"invalid_submission_ids: Duplicates detected in {id_col} for live period."
 
     # join on live_ids and ensure min tickers reached
-    assert (
-        len(live_sub) >= min_tickers
-    ), f"Not enough stocks submitted. Are you using the latest live ids or live universe?"
+    assert len(live_sub) >= min_tickers, (
+        "invalid_submission_ids: Not enough stocks submitted."
+        " Are you using the latest live ids or live universe?"
+    )
 
     invalid_tickers = list(set(index_sub[id_col]).difference(set(live_sub[id_col])))
     return live_sub, invalid_tickers
@@ -165,12 +156,34 @@ def validate_ids_crypto(
     return _validate_ids(live_ids, submission, id_col, CRYPTO_MIN_TICKERS)
 
 
-def clean_predictions(
-    live_ids: pd.Series,
+def remap_ids(
+    data: pd.DataFrame,
+    ticker_map: pd.Series | pd.DataFrame,
+    src_id_col: str,
+    dst_id_col: str,
+) -> pd.DataFrame:
+    # first, index the universe and data on the source ids
+    indexed_map = ticker_map.reset_index().set_index(src_id_col)
+    indexed_data = data.set_index(src_id_col)
+    return (
+        # then, join the universe and data
+        indexed_map.join(indexed_data)
+        # get just the destination ids and prediction columns
+        .reset_index()[[dst_id_col, *indexed_data.columns]]
+        # finally, sort by the destination ticker column
+        .sort_values(dst_id_col)
+    )
+
+
+def clean_submission(
+    live_ids: pd.Series | pd.DataFrame,
     predictions: pd.DataFrame,
+    ticker_col: str,
+    signal_col: str,
+    rename_as: Optional[str],
     id_col: str,
     rank_and_fill: bool,
-) -> pd.DataFrame:
+) -> pd.Series:
     """Prepare predictions for submission to Numerai.
     Filters out ids not in live data, drops duplicates, sets ids as index,
     then optionally ranks (keeping ties) and fills NaNs with 0.5.
@@ -182,28 +195,115 @@ def clean_predictions(
     Arguments:
         live_ids: pd.Series - the ids in the live data
         predictions: pd.DataFrame - the predictions to clean
+        ticker_col: str - the name of the ids column
+        signal_col: str - the name of the predictions column
+        rename_as: Optional[str] - the string to which the submission should be renamed
         id_col: str - the column name of the ids
         rank_and_fill: bool - whether to rank and fill NaNs with 0.5
-        left_join_ids: bool - whether to left join the predictions onto the ids
+
+    Returns:
+        pd.Series - the cleaned prediction series with ids as index
     """
     assert len(live_ids) > 0, "live_ids must not be empty"
-    assert live_ids.isna().sum() == 0, "live_ids must not contain NaNs"
+    if isinstance(live_ids, pd.DataFrame):
+        assert live_ids.isna().sum().sum() == 0, "live_ids must not contain NaNs"
+    else:
+        assert live_ids.isna().sum() == 0, "live_ids must not contain NaNs"
     assert len(predictions) > 0, "predictions must not be empty"
 
-    # drop null indices
-    predictions = predictions[~predictions[id_col].isna()]
-    predictions = (
-        predictions[
-            # filter out ids not in live data
-            predictions[id_col].isin(live_ids)
-        ]
-        # drop duplicate ids (keep first)
+    clean_preds = (
+        remap_ids(predictions, live_ids, ticker_col, id_col)
+        # drop NaNs and duplicates
+        .dropna(subset=[id_col])
         .drop_duplicates(subset=id_col, keep="first")
-        # set ids as index
+        # set ids as index and sort
         .set_index(id_col)
         .sort_index()
-    )
+        # rename to given name
+        .rename(columns={signal_col: rename_as})
+    )[rename_as]
     # rank and fill with 0.5
     if rank_and_fill:
-        predictions = tie_kept_rank(predictions).fillna(0.5)
-    return predictions
+        clean_preds = tie_kept_rank(clean_preds).fillna(0.5)
+    return clean_preds
+
+
+def validate_and_clean_submission_numerai(
+    universe: pd.Series,
+    submission: pd.DataFrame,
+    id_col: str = "id",
+    rename_as: Optional[str] = None,
+    rank_and_fill: bool = False,
+) -> pd.Series:
+    ticker_col, signal_col = validate_headers_numerai(submission)
+    filtered_sub, invalid_tickers = validate_ids_numerai(
+        universe, submission, ticker_col
+    )
+    validate_values(filtered_sub, signal_col)
+    return clean_submission(
+        live_ids=universe,
+        predictions=filtered_sub,
+        ticker_col=ticker_col,
+        signal_col=signal_col,
+        rename_as=rename_as,
+        id_col=id_col,
+        rank_and_fill=rank_and_fill,
+    )
+
+
+def validate_and_clean_submission_signals(
+    universe: pd.DataFrame,
+    submission: pd.DataFrame,
+    id_col: str,
+    rename_as: Optional[str] = None,
+    rank_and_fill: bool = True,
+) -> pd.Series:
+    # drop data_type and date columns if they exist
+    if "data_type" in submission.columns:
+        logger.warning(
+            "data_type column found in Signals submission. This is deprecated and support will be removed in the future. "
+            "Please remove the data_type column from your Signals submission."
+        )
+    date_col = [
+        date_col
+        for date_col in SIGNALS_ALLOWED_DATE_COLS
+        if date_col in list(submission.columns)
+    ]
+    submission = submission.drop(columns=["data_type", *date_col], errors="ignore")
+    ticker_col, signal_col = validate_headers_signals(submission)
+    filtered_sub, invalid_tickers = validate_ids_signals(
+        universe[ticker_col], submission, ticker_col
+    )
+    validate_values(filtered_sub, signal_col)
+    return clean_submission(
+        live_ids=universe,
+        predictions=filtered_sub,
+        ticker_col=ticker_col,
+        signal_col=signal_col,
+        rename_as=rename_as,
+        id_col=id_col,
+        rank_and_fill=rank_and_fill,
+    )
+
+
+def validate_and_clean_submission_crypto(
+    universe: pd.DataFrame,
+    submission: pd.DataFrame,
+    id_col: str = "symbol",
+    rename_as: Optional[str] = None,
+    rank_and_fill: bool = True,
+):
+    ticker_col, signal_col = validate_headers_crypto(submission)
+    filtered_sub, invalid_tickers = validate_ids_crypto(
+        universe[ticker_col], submission, ticker_col
+    )
+    validate_values(filtered_sub, signal_col)
+    return clean_submission(
+        live_ids=universe,
+        predictions=filtered_sub,
+        ticker_col=ticker_col,
+        signal_col=signal_col,
+        rename_as=rename_as,
+        id_col=id_col,
+        rank_and_fill=rank_and_fill,
+    )

{numerai_tools-0.5.0.dev2 → numerai_tools-0.5.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "numerai-tools"
-version = "0.5.0.dev2"
+version = "0.5.0.dev4"
 description = "A collection of open-source tools to help interact with Numerai, model data, and automate submissions."
 authors = [
     {name = "Numerai Engineering",email = "engineering@numer.ai"}
@@ -28,6 +28,11 @@ documentation = "https://docs.numer.ai/"
 packages = [
     {include = "numerai_tools", from = "."},
 ]
+include = [
+    { path = "LICENSE", format = ["sdist", "wheel"] },
+    { path = "README.md", format = ["sdist", "wheel"] },
+    { path = "numerai_tools/py.typed", format = ["sdist", "wheel"] }
+]
 
 [tool.poetry.dependencies]
 pandas = "^2.2.2"
@@ -39,6 +44,8 @@ scikit-learn = "^1.5.0"
 pytest = "^8.3.4"
 mypy = "^1.15.0"
 ruff = "^0.5.4"
+pandas-stubs = "^2.3.0.250703"
+scipy-stubs = "^1.16.1.0"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

numerai_tools-0.5.0.dev2/README.md

@@ -1,2 +0,0 @@
-# numerai-tools
-A collection of open-source tools to help interact with Numerai, model data, and automate submissions.