numerai-tools 0.5.0.dev1__tar.gz → 0.5.0.dev3__tar.gz

numerai_tools-0.5.0.dev3/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.3
+Name: numerai-tools
+Version: 0.5.0.dev3
+Summary: A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
+License: MIT
+Author: Numerai Engineering
+Author-email: engineering@numer.ai
+Requires-Python: >=3.11
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: scikit-learn (>=1.5.0,<2.0.0)
+Requires-Dist: scipy (>=1.13.0,<2.0.0)
+Project-URL: Documentation, https://docs.numer.ai/
+Project-URL: Homepage, https://numer.ai
+Project-URL: Repository, https://github.com/numerai/numerai-tools
+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.dev3/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.dev1 → numerai_tools-0.5.0.dev3}/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.dev1 → numerai_tools-0.5.0.dev3}/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 (
+    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 = clean_submission_signals(
+        universe=universe,
+        submission=curr_sub,
+        submission_id=curr_signal_col,
+        index_col=curr_ticker_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 = clean_submission_signals(
             universe=universe,
-            submission=filtered_prev_sub,
-            signal_col=curr_signal_col,
+            submission=prev_sub,
+            submission_id=curr_signal_col,
+            index_col=curr_ticker_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.dev1 → numerai_tools-0.5.0.dev3}/numerai_tools/submissions.py

@@ -62,17 +62,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
     )
@@ -141,7 +130,7 @@ def _validate_ids(
     # 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?"
+    ), "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 +154,33 @@ 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,
+    name: str,
     id_col: str,
     rank_and_fill: bool,
-) -> pd.DataFrame:
+    tournament: int,
+) -> 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 +192,99 @@ def clean_predictions(
     Arguments:
         live_ids: pd.Series - the ids in the live data
         predictions: pd.DataFrame - the predictions to clean
+        name: str - the name of the submission (used for renaming)
         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
     """
     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)
+    header_fn = {
+        8: validate_headers_numerai,
+        11: validate_headers_signals,
+        12: validate_headers_crypto,
+    }
+    assert (
+        tournament in header_fn
+    ), f"Unsupported tournament {tournament} for cleaning predictions"
+    ticker_col, signal_col = header_fn[tournament](predictions)
+
+    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: name})
+    )[name]
     # 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 clean_submission_numerai(
+    live_ids: pd.Series, submission: pd.DataFrame, user_id: str
+) -> pd.Series:
+    return clean_submission(
+        live_ids=live_ids,
+        predictions=submission,
+        name=user_id,
+        id_col="id",
+        rank_and_fill=True,
+        tournament=8,
+    )
+
+
+def clean_submission_signals(
+    universe: pd.DataFrame,
+    submission: pd.DataFrame,
+    submission_id: str,
+    index_col: str,
+    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")
+    return clean_submission(
+        live_ids=universe,
+        predictions=submission,
+        name=submission_id,
+        id_col=index_col,
+        rank_and_fill=rank_and_fill,
+        tournament=11,
+    )
+
+
+def clean_submission_crypto(
+    universe: pd.DataFrame,
+    submission: pd.DataFrame,
+    submission_id: str,
+    index_col: str,
+    rank_and_fill: bool = True,
+):
+    return clean_submission(
+        live_ids=universe,
+        predictions=submission,
+        name=submission_id,
+        id_col=index_col,
+        rank_and_fill=rank_and_fill,
+        tournament=12,
+    )

numerai_tools-0.5.0.dev3/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "numerai-tools"
+version = "0.5.0.dev3"
+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"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+homepage = "https://numer.ai"
+repository = "https://github.com/numerai/numerai-tools"
+documentation = "https://docs.numer.ai/"
+
+[tool.poetry]
+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"
+numpy = "^2.0.0"
+scipy = "^1.13.0"
+scikit-learn = "^1.5.0"
+
+[tool.poetry.group.dev.dependencies]
+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"]
+build-backend = "poetry.core.masonry.api"

numerai_tools-0.5.0.dev1/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: numerai_tools
-Version: 0.5.0.dev1
-Summary: A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
-Home-page: https://github.com/numerai/numerai-tools
-Maintainer: Numerai
-Maintainer-email: support@numer.ai
-License: MIT License
-Platform: OS Independent
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# numerai-tools
-A collection of open-source tools to help interact with Numerai, model data, and automate submissions.

numerai_tools-0.5.0.dev1/README.md

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

numerai_tools-0.5.0.dev1/numerai_tools.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: numerai-tools
-Version: 0.5.0.dev1
-Summary: A collection of open-source tools to help interact with Numerai, model data, and automate submissions.
-Home-page: https://github.com/numerai/numerai-tools
-Maintainer: Numerai
-Maintainer-email: support@numer.ai
-License: MIT License
-Platform: OS Independent
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# numerai-tools
-A collection of open-source tools to help interact with Numerai, model data, and automate submissions.

numerai_tools-0.5.0.dev1/numerai_tools.egg-info/SOURCES.txt

@@ -1,16 +0,0 @@
-LICENSE
-README.md
-setup.py
-numerai_tools/__init__.py
-numerai_tools/py.typed
-numerai_tools/scoring.py
-numerai_tools/signals.py
-numerai_tools/submissions.py
-numerai_tools.egg-info/PKG-INFO
-numerai_tools.egg-info/SOURCES.txt
-numerai_tools.egg-info/dependency_links.txt
-numerai_tools.egg-info/requires.txt
-numerai_tools.egg-info/top_level.txt
-tests/test_scoring.py
-tests/test_signals.py
-tests/test_submissions.py

numerai_tools-0.5.0.dev1/numerai_tools.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

numerai_tools-0.5.0.dev1/numerai_tools.egg-info/requires.txt

@@ -1,4 +0,0 @@
-pandas<3.0.0,>=2.2.2
-numpy<3.0.0,>=2.0.0
-scipy<2.0.0,>=1.13.0
-scikit-learn<2.0.0,>=1.5.0

numerai_tools-0.5.0.dev1/numerai_tools.egg-info/top_level.txt

@@ -1 +0,0 @@
-numerai_tools