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

{numerai_tools-0.5.0.dev1/numerai_tools.egg-info → numerai_tools-0.5.0.dev2}/PKG-INFO

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: numerai-tools
-Version: 0.5.0.dev1
+Version: 0.5.0.dev2
 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
+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
@@ -15,8 +14,15 @@ 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
-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.dev2/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "numerai-tools"
+version = "0.5.0.dev2"
+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 = "."},
+]
+
+[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"
+
+[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/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

numerai_tools-0.5.0.dev1/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

numerai_tools-0.5.0.dev1/setup.py

@@ -1,47 +0,0 @@
-from setuptools import setup
-from setuptools import find_packages
-
-VERSION = "0.5.0.dev1"
-
-
-def load(path):
-    return open(path, "r").read()
-
-
-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",
-]
-
-
-if __name__ == "__main__":
-    setup(
-        name="numerai_tools",
-        version=VERSION,
-        maintainer="Numerai",
-        maintainer_email="support@numer.ai",
-        description="A collection of open-source tools to help interact with Numerai, model data, and automate submissions.",
-        long_description=load("README.md"),
-        long_description_content_type="text/markdown",
-        url="https://github.com/numerai/numerai-tools",
-        platforms="OS Independent",
-        classifiers=classifiers,
-        license="MIT License",
-        package_data={
-            "numerai_tools": ["LICENSE", "README.md", "py.typed"],
-        },
-        packages=find_packages(exclude=["tests"]),
-        install_requires=[
-            # pandas 2.2.2 was the first version to support numpy 2
-            "pandas>=2.2.2,<3.0.0",
-            "numpy>=2.0.0,<3.0.0",
-            "scipy>=1.13.0,<2.0.0",
-            "scikit-learn>=1.5.0,<2.0.0",
-        ],
-    )

numerai_tools-0.5.0.dev1/tests/test_scoring.py

@@ -1,346 +0,0 @@
-import unittest
-
-import numpy as np
-import pandas as pd  # type: ignore
-
-from numerai_tools.scoring import (
-    correlation,
-    numerai_corr,
-    tie_broken_rank_correlation,
-    spearman_correlation,
-    pearson_correlation,
-    tie_broken_rank,
-    tie_kept_rank,
-    gaussian,
-    neutralize,
-    one_hot_encode,
-    power,
-    tie_kept_rank__gaussianize__pow_1_5,
-    variance_normalize,
-    orthogonalize,
-    stake_weight,
-    filter_sort_index,
-    filter_sort_index_many,
-    filter_sort_top_bottom,
-    filter_sort_top_bottom_concat,
-    alpha,
-    meta_portfolio_contribution,
-)
-
-
-class TestScoring(unittest.TestCase):
-    def setUp(self):
-        self.up = pd.Series(list(range(5))).rename("up")
-        self.down = pd.Series(list(reversed(range(5)))).rename("down")
-        self.up_down = pd.Series([1, 0, 1, 0, 1]).rename("up_down")
-        self.down_up = (1 - self.up_down).rename("down_up")
-        self.up_float = (self.up / self.up.max()).rename("up_float")
-        self.pos_neg = pd.Series([0, -0, 0.5, -0.5, 1.0, -1.0, 2.0, -2.0]).rename(
-            "pos_neg"
-        )
-
-    def test_filter_sort_index(self):
-        # Test with 2 simple ranges with different indices
-        s = pd.Series([1, 2, 3, 4, 5], index=[0, 1, 2, 3, 4])
-        t = pd.Series([1, 2, 3, 4, 5], index=[1, 2, 3, 4, 5])
-        new_s, new_t = filter_sort_index(s, t)
-        self.assertEqual(len(new_s), 4)
-        self.assertEqual(len(new_t), 4)
-        self.assertTrue(np.array_equal(new_s.index, [1, 2, 3, 4]))
-        self.assertTrue(np.array_equal(new_t.index, [1, 2, 3, 4]))
-        self.assertTrue(np.array_equal(new_s.values, [2, 3, 4, 5]))
-        self.assertTrue(np.array_equal(new_t.values, [1, 2, 3, 4]))
-
-    def test_filter_sort_index_invalid(self):
-        # Ensure assertion error when max filtered ratio is exceeded
-        s = pd.Series([1, 2, 3, 4, 5], index=[0, 1, 2, 3, 4])
-        t = pd.Series([1, 2, 3, 4, 5], index=[1, 2, 3, 4, 5])
-        with self.assertRaises(AssertionError):
-            filter_sort_index(s, t, max_filtered_ratio=0.1)
-
-    def test_filter_sort_index_many(self):
-        # Test with a DataFrame
-        s = pd.Series([1, 2, 3, 4, 5], index=[0, 1, 2, 3, 4])
-        t = pd.Series([1, 2, 3, 4, 5], index=[1, 2, 3, 4, 5])
-        new_s, new_t = filter_sort_index_many([s, t])
-        self.assertEqual(len(new_s), 4)
-        self.assertEqual(len(new_t), 4)
-        self.assertTrue(np.array_equal(new_s.index, [1, 2, 3, 4]))
-        self.assertTrue(np.array_equal(new_t.index, [1, 2, 3, 4]))
-        self.assertTrue(np.array_equal(new_s.values, [2, 3, 4, 5]))
-        self.assertTrue(np.array_equal(new_t.values, [1, 2, 3, 4]))
-
-    def test_filter_sort_index_many_invalid(self):
-        # Ensure assertion error when max filtered ratio is exceeded
-        s = pd.Series([1, 2, 3, 4, 5], index=[0, 1, 2, 3, 4])
-        t = pd.Series([1, 2, 3, 4, 5], index=[1, 2, 3, 4, 5])
-        with self.assertRaises(AssertionError):
-            filter_sort_index_many([s, t], max_filtered_ratio=0.1)
-
-    def test_correlation(self):
-        assert np.isclose(correlation(self.up, self.up), 1)
-        assert np.isclose(correlation(self.up, self.down), -1)
-        assert np.isclose(correlation(self.up, self.up_down), 0)
-        assert np.isclose(correlation(self.up, self.down_up), 0)
-
-    def test_tie_broken_rank_correlation(self):
-        assert np.isclose(tie_broken_rank_correlation(self.up, self.up), 1)
-        assert np.isclose(tie_broken_rank_correlation(self.up, self.down), -1)
-        # tie_broken_rank_correlation ranks the submission not the targets
-        assert np.isclose(tie_broken_rank_correlation(self.up, self.up_down), 0.5)
-        assert np.isclose(tie_broken_rank_correlation(self.up, self.down_up), 0.5)
-        assert np.isclose(tie_broken_rank_correlation(self.up_down, self.up), 0)
-        assert np.isclose(tie_broken_rank_correlation(self.down_up, self.up), 0)
-
-    def test_spearman_correlation(self):
-        assert np.isclose(spearman_correlation(self.up, self.up), 1)
-        assert np.isclose(spearman_correlation(self.up, self.down), -1)
-        assert np.isclose(spearman_correlation(self.up, self.up_down), 0)
-        assert np.isclose(spearman_correlation(self.up, self.down_up), 0)
-        assert np.isclose(spearman_correlation(self.up_down, self.up), 0)
-        assert np.isclose(spearman_correlation(self.down_up, self.up), 0)
-
-    def test_pearson_correlation(self):
-        assert np.isclose(pearson_correlation(self.up, self.up), 1)
-        assert np.isclose(pearson_correlation(self.up, self.down), -1)
-        assert np.isclose(pearson_correlation(self.up, self.up_down), 0)
-        assert np.isclose(pearson_correlation(self.up, self.down_up), 0)
-        assert np.isclose(pearson_correlation(self.up_down, self.up), 0)
-        assert np.isclose(pearson_correlation(self.down_up, self.up), 0)
-
-    def test_tie_broken_rank(self):
-        assert np.isclose(
-            tie_broken_rank(self.up.to_frame()).T, [0.1, 0.3, 0.5, 0.7, 0.9]
-        ).all()
-        assert np.isclose(
-            tie_broken_rank(self.up_down.to_frame()).T, [0.5, 0.1, 0.7, 0.3, 0.9]
-        ).all()
-
-    def test_tie_kept_rank(self):
-        assert np.isclose(
-            tie_kept_rank(self.up.to_frame()).T, [0.1, 0.3, 0.5, 0.7, 0.9]
-        ).all()
-        assert np.isclose(
-            tie_kept_rank(self.up_down.to_frame()).T, [0.7, 0.2, 0.7, 0.2, 0.7]
-        ).all()
-
-    def test_gaussian(self):
-        assert np.isclose(
-            gaussian(self.up_float).values.T,
-            [-np.inf, -0.6744897501960817, 0, 0.6744897501960817, np.inf],
-        ).all()
-
-    def test_variance_normalize(self):
-        assert np.isclose(
-            variance_normalize(self.up_float).values.T,
-            [
-                0.0,
-                0.7071067811865475,
-                1.414213562373095,
-                2.1213203435596424,
-                2.82842712474619,
-            ],
-        ).all()
-
-    def test_one_hot_encode(self):
-        assert np.isclose(
-            one_hot_encode(self.up.to_frame(), ["up"]).values.T,
-            [
-                [1.0, 0.0, 0.0, 0.0, 0.0],
-                [0.0, 1.0, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 1.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 1.0, 0.0],
-                [0.0, 0.0, 0.0, 0.0, 1.0],
-            ],
-        ).all()
-
-    def test_power(self):
-        assert np.isclose(
-            power(self.pos_neg.to_frame(), 1.5),
-            [
-                [0.0],
-                [0.0],
-                [0.3535533905932738],
-                [-0.3535533905932738],
-                [1.0000000000000000],
-                [-1.0000000000000000],
-                [2.8284271247461903],
-                [-2.8284271247461903],
-            ],
-        ).all()
-
-    def test_tie_kept_rank__gaussianize__pow_1_5(self):
-        assert np.isclose(
-            tie_kept_rank__gaussianize__pow_1_5(self.up_float.to_frame()),
-            [
-                [-1.4507885796854221],
-                [-0.3797472709071263],
-                [0.0000000000000000],
-                [0.3797472709071261],
-                [1.4507885796854221],
-            ],
-        ).all()
-
-    def test_orthoganalize(self):
-        assert np.isclose(
-            orthogonalize(self.up.to_frame().values, self.up.to_frame().values),
-            [0, 0, 0, 0, 0],
-        ).all()
-        assert np.isclose(
-            orthogonalize(self.up.to_frame().values, self.up_down.to_frame().values),
-            [[-2], [1], [0], [3], [2]],
-        ).all()
-        assert np.isclose(
-            orthogonalize(
-                self.down_up.to_frame().values, self.up_down.to_frame().values
-            ),
-            [[0], [1], [0], [1], [0]],
-        ).all()
-
-    def test_stake_weight(self):
-        assert np.isclose(
-            stake_weight(self.up.to_frame(), pd.Series([1], index=[self.up.name])),
-            self.up.values.T,
-        ).all()
-        assert np.isclose(
-            stake_weight(
-                pd.concat([self.up, self.down], axis=1),
-                pd.Series([1, 1], index=[self.up.name, self.down.name]),
-            ),
-            ((self.up + self.down) / 2).values.T,
-        ).all()
-
-    def test_neutralize_basic(self):
-        assert np.isclose(
-            neutralize(self.up.to_frame(), pd.DataFrame([0, 0, 0, 0, 0])).values.T,
-            self.up - self.up.mean(),
-        ).all()
-
-    def test_neutralize_multiple_subs(self):
-        assert np.isclose(
-            neutralize(self.up_down.to_frame(), self.down_up.to_frame()).values.T,
-            [0, 0, 0, 0, 0],
-        ).all()
-
-    def test_neutralize_multiple_subs_multiple_neutralizers(self):
-        # ensure it works for multiple submissions/neutralizers
-        assert np.isclose(
-            neutralize(
-                pd.concat([self.up_down, self.up_down], axis=1),
-                pd.concat([self.down_up, self.down_up], axis=1),
-            ).values.T,
-            [
-                [0, 0, 0, 0, 0],
-                [0, 0, 0, 0, 0],
-            ],
-        ).all()
-        assert np.isclose(
-            neutralize(
-                pd.concat([self.up, self.down], axis=1),
-                pd.concat(
-                    [pd.Series([0, 0, 0, 0, 0]), pd.Series([0, 0, 0, 0, 0])], axis=1
-                ),
-            ).values.T,
-            pd.concat(
-                [self.up - self.up.mean(), self.down - self.down.mean()], axis=1
-            ).values.T,
-        ).all()
-
-    def test_neutralize_proportion(self):
-        # Test with proportion less than 1
-        assert np.isclose(
-            neutralize(
-                self.up.to_frame(), pd.DataFrame([0, 0, 0, 0, 0]), proportion=0.5
-            ).values.T,
-            (self.up - self.up.mean() * 0.5),
-        ).all()
-
-        # Test with proportion equal to 0
-        assert np.isclose(
-            neutralize(
-                self.up.to_frame(), pd.DataFrame([0, 0, 0, 0, 0]), proportion=0
-            ).values.T,
-            self.up,
-        ).all()
-
-    def test_neutralize_with_nans(self):
-        # Test with NaNs in input data
-        up_with_nans = self.up.copy()
-        up_with_nans[2] = np.nan
-        self.assertRaisesRegex(
-            AssertionError,
-            "Data contains NaNs",
-            neutralize,
-            up_with_nans.to_frame(),
-            pd.DataFrame([0, 0, 0, 0, 0]),
-        )
-
-    def test_neutralize_large_data(self):
-        # Test with larger dataset
-        large_data = pd.DataFrame(np.random.randn(1000, 10))
-        neutralizers = pd.DataFrame(np.random.randn(1000, 5))
-        neutralized = neutralize(large_data, neutralizers)
-        assert neutralized.shape == large_data.shape
-        assert not np.isnan(neutralized).any().any()
-
-    def test_numerai_corr_doesnt_clobber_targets(self):
-        s = [x / 4 for x in range(5)]
-        df = pd.DataFrame({"target": s, "prediction": reversed(s)})
-        numerai_corr(df[["prediction"]], df["target"])
-        assert pd.Series(s).equals(df["target"]), f"{s} != {list(df['target'].values)}"
-
-    def test_filter_top_bottom(self):
-        self.assertRaises(
-            TypeError,
-            filter_sort_top_bottom,
-            self.up,
-            top_bottom=None,
-        )
-        np.testing.assert_allclose(
-            filter_sort_top_bottom_concat(self.up, top_bottom=2),
-            [0, 1, 3, 4],
-        )
-        top, bot = filter_sort_top_bottom(
-            self.up,
-            top_bottom=2,
-        )
-        np.testing.assert_allclose(top, [3, 4])
-        np.testing.assert_allclose(bot, [0, 1])
-
-    def test_alpha(self):
-        s = pd.DataFrame([[1, 2, 3, 4, 5]]).T
-        N = pd.DataFrame(
-            [
-                [1, 5],
-                [2, 4],
-                [3, 3],
-                [4, 2],
-                [5, 1],
-            ]
-        )
-        v = pd.Series([1, 0.5, 1, 0.5, 1]).T
-        t = pd.Series([1, 0, 1, 0, 1]).T
-        score = alpha(s, N, v, t)
-        np.testing.assert_allclose(score, 0.0, atol=1e-14, rtol=1e-14)
-
-    def test_meta_portfolio_contribution(self):
-        s = pd.DataFrame([[1, 2, 3, 4, 5], [1, 2, 1, 2, 1]]).T
-        st = pd.Series([0.6, 0.4])
-        N = pd.DataFrame(
-            [
-                [1, 5],
-                [2, 4],
-                [3, 3],
-                [4, 2],
-                [5, 1],
-            ]
-        )
-        v = pd.Series([3, 2, 1, 2, 3]).T
-        t = pd.Series([1.0, 2.0, 3.0, 2.0, 1.0]).T
-        score = meta_portfolio_contribution(s, st, N, v, t)
-        assert np.isclose(score[0], -0.04329786867021718)
-        assert np.isclose(score[1], 0.06494680300532589)
-
-
-if __name__ == "__main__":
-    unittest.main()

numerai_tools-0.5.0.dev1/tests/test_signals.py

@@ -1,139 +0,0 @@
-import unittest
-
-import numpy as np
-import pandas as pd  # type: ignore
-
-from numerai_tools.signals import (
-    churn,
-    turnover,
-    calculate_max_churn_and_turnover,
-)
-from .util import (
-    generate_fake_universe,
-    generate_new_submission,
-)
-
-
-class TestSignals(unittest.TestCase):
-    def setUp(self):
-        self.up = pd.Series(list(range(5))).rename("up")
-        self.down = pd.Series(list(reversed(range(5)))).rename("down")
-        self.up_down = pd.Series([0, 1, 2, 1, 0]).rename("up_down")
-        self.oscillate = pd.Series([1, 0, 1, 0, 1]).rename("oscillate")
-        self.constant = pd.Series([1, 1, 1, 1, 1]).rename("pos_neg")
-
-    def test_churn(self):
-        assert np.isclose(churn(self.up, self.up), 0)
-        assert np.isclose(churn(self.up, self.up_down), 1)
-        assert np.isclose(churn(self.up, self.oscillate), 1)
-        assert np.isclose(churn(self.up, self.down), 2)
-        self.assertRaisesRegex(
-            AssertionError,
-            "s2 must have non-zero standard deviation",
-            churn,
-            self.up,
-            self.constant,
-        )
-
-    def test_churn_tb(self):
-        tmp = churn(self.up, self.up, top_bottom=2)
-        assert np.isclose(tmp, 0), tmp
-        tmp = churn(self.up, self.up_down, top_bottom=2)
-        assert np.isclose(tmp, 0.5), tmp
-        tmp = churn(self.up, self.oscillate, top_bottom=2)
-        assert np.isclose(tmp, 0.5), tmp
-        tmp = churn(self.up, self.down, top_bottom=2)
-        assert np.isclose(tmp, 1), tmp
-        tmp = churn(self.up, self.constant, top_bottom=2)
-        assert np.isclose(tmp, 0), tmp
-
-    def test_turnover(self):
-        assert np.isclose(turnover(self.up, self.up), 0)
-        assert np.isclose(turnover(self.up, self.up_down), 3)
-        assert np.isclose(turnover(self.up, self.oscillate), 4.5)
-        assert np.isclose(turnover(self.up, self.down), 6)
-        assert np.isclose(turnover(self.up, self.constant), 3.5)
-
-    def test_churn_first_submission(self):
-        """
-        Test that the churn function works for the first submission
-        No exceptions should be raised, should return 1
-        """
-        fake_universe = generate_fake_universe("20130308")
-        fake_submission = generate_new_submission(fake_universe)
-        fake_neutralizers = pd.DataFrame(
-            {
-                "neutralizer_1": [0.1] * len(fake_universe),
-                "neutralizer_2": [0.2] * len(fake_universe),
-            },
-            index=fake_universe["numerai_ticker"],
-        )
-        fake_sample_weights = pd.Series(
-            [0.5] * len(fake_universe),
-            index=fake_universe["numerai_ticker"],
-            name="sample_weight",
-        )
-        churn, turnover = calculate_max_churn_and_turnover(
-            curr_sub=fake_submission,
-            curr_neutralizer=fake_neutralizers,
-            curr_weight=fake_sample_weights,
-            prev_week_subs=[],
-            prev_neutralizers={"20240208": fake_neutralizers},
-            prev_sample_weights={"20240208": fake_sample_weights},
-            universe=fake_universe.set_index("numerai_ticker").sort_index(),
-            curr_signal_col="signal",
-            curr_ticker_col="numerai_ticker",
-        )
-        assert np.isclose(churn, 1)
-        assert np.isclose(turnover, 1)
-
-    def test_churn_handles_different_id_columns(self):
-        """
-        Test that the churn function works when
-        previous submission has different id columns.
-        """
-        fake_universe = generate_fake_universe("20130308")
-        fake_submission = generate_new_submission(fake_universe, legacy_headers=True)
-        new_fake_universe = generate_fake_universe(
-            date_value="20130308", ticker_col="ticker"
-        )
-        fake_universe["ticker"] = new_fake_universe["ticker"]
-        prev_submission = fake_submission.copy()
-        fake_neutralizers = pd.DataFrame(
-            {
-                "neutralizer_1": [0.1] * len(fake_universe),
-                "neutralizer_2": [0.2] * len(fake_universe),
-            },
-            index=fake_universe["numerai_ticker"],
-        )
-        fake_sample_weights = pd.Series(
-            [0.5] * len(fake_universe),
-            index=fake_universe["numerai_ticker"],
-            name="sample_weight",
-        )
-        # switch out the numerai_ticke col in-place
-        prev_submission["numerai_ticker"] = new_fake_universe["ticker"]
-        prev_submission.rename(columns={"numerai_ticker": "ticker"}, inplace=True)
-        prev_neutralizers = fake_neutralizers.copy()
-        prev_neutralizers.index = new_fake_universe["ticker"]
-        prev_neutralizers.index.name = "ticker"
-        prev_sample_weights = fake_sample_weights.copy()
-        prev_sample_weights.index = new_fake_universe["ticker"]
-        prev_sample_weights.index.name = "ticker"
-        churn, turnover = calculate_max_churn_and_turnover(
-            curr_sub=fake_submission,
-            curr_neutralizer=fake_neutralizers,
-            curr_weight=fake_sample_weights,
-            prev_week_subs={"20240208": prev_submission},
-            prev_neutralizers={"20240208": prev_neutralizers},
-            prev_sample_weights={"20240208": prev_sample_weights},
-            universe=fake_universe.set_index("numerai_ticker").sort_index(),
-            curr_signal_col="signal",
-            curr_ticker_col="numerai_ticker",
-        )
-        assert np.isclose(churn, 0)
-        assert np.isclose(turnover, 0)
-
-
-if __name__ == "__main__":
-    unittest.main()

numerai_tools-0.5.0.dev1/tests/test_submissions.py

@@ -1,498 +0,0 @@
-import unittest
-import random
-import string
-from typing import List
-
-import numpy as np
-import pandas as pd  # type: ignore
-
-from numerai_tools.submissions import (
-    NUMERAI_ALLOWED_ID_COLS,
-    NUMERAI_ALLOWED_PRED_COLS,
-    SIGNALS_ALLOWED_ID_COLS,
-    SIGNALS_ALLOWED_PRED_COLS,
-    CRYPTO_ALLOWED_ID_COLS,
-    CRYPTO_ALLOWED_PRED_COLS,
-    _validate_headers,
-    validate_headers_numerai,
-    validate_headers_signals,
-    validate_headers_crypto,
-    validate_values,
-    _validate_ids,
-    validate_ids_numerai,
-    validate_ids_signals,
-    validate_ids_crypto,
-    clean_predictions,
-)
-
-
-class TestSubmissions(unittest.TestCase):
-    def setUp(self):
-        # use 9 digits for cusip handling checks
-        self.ids = generate_ids(9, 5)
-        self.classic_subs = [
-            generate_submission(self.ids, id_col, pred_col)
-            for id_col in NUMERAI_ALLOWED_ID_COLS
-            for pred_col in NUMERAI_ALLOWED_PRED_COLS
-        ]
-        self.signals_subs = [
-            generate_submission(self.ids, id_col, pred_col)
-            for id_col in SIGNALS_ALLOWED_ID_COLS
-            for pred_col in SIGNALS_ALLOWED_PRED_COLS
-        ]
-        self.crypto_subs = [
-            generate_submission(self.ids, id_col, pred_col)
-            for id_col in CRYPTO_ALLOWED_ID_COLS
-            for pred_col in CRYPTO_ALLOWED_PRED_COLS
-        ]
-
-    def test_validate_headers(self):
-        assert _validate_headers(
-            ["test1"], ["test2"], generate_submission(self.ids, "test1", "test2")
-        ) == ("test1", "test2")
-
-    def test_validate_headers_wrong_name(self):
-        self.assertRaisesRegex(
-            AssertionError,
-            "headers must be one of",
-            _validate_headers,
-            ["test1"],
-            ["test2"],
-            generate_submission(self.ids, "wrong", "test2"),
-        )
-        self.assertRaisesRegex(
-            AssertionError,
-            "headers must be one of",
-            _validate_headers,
-            ["test1"],
-            ["test2"],
-            generate_submission(self.ids, "test1", "wrong"),
-        )
-
-    def test_validate_headers_missing(self):
-        self.assertRaisesRegex(
-            AssertionError,
-            "headers must be one of",
-            _validate_headers,
-            ["test1"],
-            ["test2"],
-            generate_submission(self.ids, "test1", "test2")[["test1"]],
-        )
-        self.assertRaisesRegex(
-            AssertionError,
-            "headers must be one of",
-            _validate_headers,
-            ["test1"],
-            ["test2"],
-            generate_submission(self.ids, "test1", "test2")[["test2"]],
-        )
-
-    def test_validate_headers_numerai(self):
-        for sub in self.classic_subs:
-            assert validate_headers_numerai(sub) == tuple(sub.columns)
-
-    def test_validate_headers_numerai_wrong_name(self):
-        for sub in self.classic_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_numerai,
-                sub.rename(columns={sub.columns[0]: "wrong"}),
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_numerai,
-                sub.rename(columns={sub.columns[1]: "wrong"}),
-            )
-
-    def test_validate_headers_numerai_missing(self):
-        for sub in self.classic_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_numerai,
-                sub[[sub.columns[0]]],
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_numerai,
-                sub[[sub.columns[1]]],
-            )
-
-    def test_validate_headers_signals(self):
-        for sub in self.signals_subs:
-            assert validate_headers_signals(sub) == tuple(sub.columns)
-
-    def test_validate_headers_signals_wrong_name(self):
-        for sub in self.signals_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_signals,
-                sub.rename(columns={sub.columns[0]: "wrong"}),
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_signals,
-                sub.rename(columns={sub.columns[1]: "wrong"}),
-            )
-
-    def test_validate_headers_signals_missing(self):
-        for sub in self.signals_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_signals,
-                sub[[sub.columns[0]]],
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_signals,
-                sub[[sub.columns[1]]],
-            )
-
-    def test_validate_headers_signals_data_type_and_date_col(self):
-        fake_sub = generate_submission(self.ids, "ticker", "signal")
-        fake_sub["data_type"] = "signals"
-        fake_sub["friday_date"] = "2023-01-01"
-        with self.assertLogs(level="WARNING") as cm:
-            assert validate_headers_signals(fake_sub) == ("ticker", "signal")
-        self.assertIn(
-            "WARNING:numerai_tools.submissions: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.",
-            cm.output[0],
-        )
-
-    def test_validate_headers_crypto(self):
-        for sub in self.crypto_subs:
-            assert validate_headers_crypto(sub) == tuple(sub.columns)
-
-    def test_validate_headers_crypto_wrong_name(self):
-        for sub in self.crypto_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_crypto,
-                sub.rename(columns={sub.columns[0]: "wrong"}),
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_crypto,
-                sub.rename(columns={sub.columns[1]: "wrong"}),
-            )
-
-    def test_validate_headers_crypto_missing(self):
-        for sub in self.crypto_subs:
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_crypto,
-                sub[[sub.columns[0]]],
-            )
-            self.assertRaisesRegex(
-                AssertionError,
-                "headers must be one of",
-                validate_headers_crypto,
-                sub[[sub.columns[1]]],
-            )
-
-    def test_validate_values(self):
-        validate_values(generate_submission(self.ids, "id", "prediction"), "prediction")
-
-    def test_validate_values_nans(self):
-        nan_sub = generate_submission(self.ids, "id", "prediction")
-        nan_sub.loc[0, "prediction"] = np.nan
-        self.assertRaisesRegex(
-            AssertionError,
-            "must not contain NaNs",
-            validate_values,
-            nan_sub,
-            "prediction",
-        )
-
-    def test_validate_values_out_of_bounds(self):
-        out_of_bounds_sub = generate_submission(self.ids, "id", "prediction")
-        out_of_bounds_sub.loc[0, "prediction"] = -1
-        self.assertRaisesRegex(
-            AssertionError,
-            "values must be between 0 and 1 exclusive",
-            validate_values,
-            out_of_bounds_sub,
-            "prediction",
-        )
-        out_of_bounds_sub.loc[0, "prediction"] = 2
-        self.assertRaisesRegex(
-            AssertionError,
-            "values must be between 0 and 1 exclusive",
-            validate_values,
-            out_of_bounds_sub,
-            "prediction",
-        )
-
-    def test_validate_values_zero_std(self):
-        const_sub = generate_submission(self.ids, "id", "prediction")
-        const_sub["prediction"] = 0.5
-        self.assertRaisesRegex(
-            AssertionError,
-            "submission must have non-zero standard deviation",
-            validate_values,
-            const_sub,
-            "prediction",
-        )
-
-    def test_validate_ids(self):
-        sub = generate_submission(self.ids, "id", "prediction")
-        new_sub, invalid_ids = _validate_ids(self.ids, sub, "id", len(self.ids))
-        assert (new_sub == sub.sort_values("id")).all().all()
-        assert invalid_ids == []
-
-    def test_validate_ids_nans(self):
-        nan_sub = generate_submission(self.ids, "id", "prediction")
-        nan_sub.loc[0, "id"] = np.nan
-        self.assertRaisesRegex(
-            AssertionError,
-            "must not contain NaNs",
-            _validate_ids,
-            self.ids,
-            nan_sub,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_all_nan_ids(self):
-        nan_ids = pd.Series([np.nan, np.nan, np.nan])
-        submission = generate_submission(nan_ids, "id", "prediction")
-        self.assertRaisesRegex(
-            AssertionError,
-            "Submission must not contain NaNs",
-            _validate_ids,
-            self.ids,
-            submission,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_duplicates(self):
-        dup_sub = generate_submission(self.ids, "id", "prediction")
-        dup_sub.loc[0] = dup_sub.loc[1]
-        self.assertRaisesRegex(
-            AssertionError,
-            "Duplicates detected",
-            _validate_ids,
-            self.ids,
-            dup_sub,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_duplicate_ids(self):
-        submission = generate_submission(self.ids, "id", "prediction")
-        submission = pd.concat([submission, submission.iloc[:1]])
-        self.assertRaisesRegex(
-            AssertionError,
-            "Duplicates detected",
-            _validate_ids,
-            self.ids,
-            submission,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_missing(self):
-        missing_sub = generate_submission(self.ids, "id", "prediction")
-        missing_sub = missing_sub[missing_sub["id"] != self.ids[0]]
-        self.assertRaisesRegex(
-            AssertionError,
-            "Not enough stocks submitted",
-            _validate_ids,
-            self.ids,
-            missing_sub,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_empty_submission(self):
-        empty_submission = pd.DataFrame(columns=["id", "prediction"])
-        self.assertRaisesRegex(
-            AssertionError,
-            "Not enough stocks submitted.",
-            _validate_ids,
-            self.ids,
-            empty_submission,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_all_invalid_ids(self):
-        invalid_ids = pd.Series(["invalid1", "invalid2", "invalid3"])
-        submission = generate_submission(invalid_ids, "id", "prediction")
-        self.assertRaisesRegex(
-            AssertionError,
-            "Not enough stocks submitted.",
-            _validate_ids,
-            self.ids,
-            submission,
-            "id",
-            len(self.ids),
-        )
-
-    def test_validate_ids_mixed_valid_invalid_ids(self):
-        mixed_ids = self.ids.tolist() + ["invalid1", "invalid2"]
-        submission = generate_submission(mixed_ids, "id", "prediction")
-        new_sub, invalid_ids = _validate_ids(self.ids, submission, "id", len(self.ids))
-        assert (new_sub["id"] == self.ids.sort_values()).all()
-        assert set(invalid_ids) == {"invalid1", "invalid2"}
-
-    def test_validate_ids_numerai(self):
-        sub = generate_submission(self.ids, "id", "prediction")
-        new_sub, invalid_ids = validate_ids_numerai(self.ids, sub, "id")
-        assert (new_sub == sub.sort_values("id")).all().all()
-        assert invalid_ids == []
-
-    def test_validate_ids_signals(self):
-        ids = generate_ids(9, 100)
-        sub = generate_submission(ids, "ticker", "signal")
-        new_sub, invalid_ids = validate_ids_signals(ids, sub, "ticker")
-        assert (new_sub == sub.sort_values("ticker")).all().all()
-        assert invalid_ids == []
-
-    def test_validate_ids_crypto(self):
-        ids = generate_ids(9, 100)
-        sub = generate_submission(ids, "ticker", "signal")
-        new_sub, invalid_ids = validate_ids_crypto(ids, sub, "ticker")
-        assert (new_sub == sub.sort_values("ticker")).all().all()
-        assert invalid_ids == []
-
-    def test_clean_predictions(self):
-        int_sub = generate_submission(self.ids, "id", "prediction", random_vals=False)
-        assert (
-            (
-                clean_predictions(
-                    self.ids,
-                    int_sub,
-                    id_col="id",
-                    rank_and_fill=False,
-                ).reset_index()
-                == int_sub.set_index("id").sort_index().reset_index()
-            )
-            .all()
-            .all()
-        )
-
-    def test_clean_predictions_rank_and_fill(self):
-        int_sub = generate_submission(self.ids, "id", "prediction", random_vals=False)
-        assert np.isclose(
-            clean_predictions(
-                self.ids,
-                int_sub,
-                id_col="id",
-                rank_and_fill=True,
-            )
-            .sort_values("prediction")
-            .values.T,
-            [[0.1, 0.3, 0.5, 0.7, 0.9]],
-        ).all()
-
-    def test_clean_predictions_empty_predictions(self):
-        empty_predictions = pd.DataFrame(columns=["id", "prediction"])
-        self.assertRaisesRegex(
-            AssertionError,
-            "predictions must not be empty",
-            clean_predictions,
-            self.ids,
-            empty_predictions,
-            id_col="id",
-            rank_and_fill=False,
-        )
-
-    def test_clean_predictions_all_nan_predictions(self):
-        predictions = generate_submission(self.ids, "id", "prediction")
-        predictions["prediction"] = np.nan
-        cleaned_predictions = clean_predictions(
-            self.ids,
-            predictions,
-            id_col="id",
-            rank_and_fill=True,
-        )
-        assert (cleaned_predictions == 0.5).all().all()
-
-    def test_clean_predictions_mixed_valid_invalid_ids(self):
-        mixed_ids = self.ids.tolist() + ["invalid1", "invalid2"]
-        predictions = generate_submission(mixed_ids, "id", "prediction")
-        cleaned_predictions = clean_predictions(
-            self.ids,
-            predictions,
-            id_col="id",
-            rank_and_fill=False,
-        )
-        assert (cleaned_predictions.index == self.ids.sort_values()).all()
-
-    def test_clean_predictions_duplicate_ids(self):
-        predictions = generate_submission(self.ids, "id", "prediction")
-        predictions = pd.concat([predictions, predictions.iloc[:1]])
-        cleaned_predictions = clean_predictions(
-            self.ids,
-            predictions,
-            id_col="id",
-            rank_and_fill=False,
-        )
-        assert not cleaned_predictions.index.duplicated().any()
-
-
-def generate_ids(id_length: int, num_rows: int) -> pd.Series:
-    """Generates a given number of unique ascii-valued strings of a given length.
-
-    Arguments:
-        id_length -- integer length of the id
-        num_rows -- integer number of rows to generate
-
-    Return List[str]:
-        - list of unique ascii-valued strings of the given
-    """
-    values: set[str] = set()
-    while len(values) < num_rows:
-        new_value = "".join(random.choices(string.ascii_uppercase, k=id_length))
-        values.add(new_value)
-    return pd.Series(list(values))
-
-
-def generate_submission(
-    live_ids: List[str],
-    id_col: str,
-    pred_col: str,
-    random_vals: bool = True,
-    legacy_headers: dict = {},
-) -> pd.DataFrame:
-    """Generates a random vector with given columns and ids.
-
-    Arguments:
-        live_ids -- list of strings of ids
-        id_col -- string name of the id column
-        pred_col -- string name of the prediction column
-        random -- boolean whether to generate random values or sequential
-        legacy_headers -- dictionary of legacy headers to add to the submission
-
-    Return pd.DataFrame:
-        - submission DataFrame with the given columns and ids
-    """
-    rows = []
-    for i, ticker in enumerate(live_ids):
-        if random_vals:
-            val = random.random()
-        else:
-            val = i
-        row = {id_col: ticker, pred_col: val}
-        for col, value in legacy_headers.items():
-            row[col] = value
-        rows.append(row)
-    sub = pd.DataFrame(rows)
-    return sub
-
-
-if __name__ == "__main__":
-    unittest.main()