numerapi 2.22.0__tar.gz → 2.23.0__tar.gz

{numerapi-2.22.0 → numerapi-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numerapi
-Version: 2.22.0
+Version: 2.23.0
 Summary: Automatically download and upload data for the Numerai machine learning competition
 Home-page: https://github.com/uuazed/numerapi
 Maintainer: uuazed

{numerapi-2.22.0 → numerapi-2.23.0}/numerapi/base_api.py

@@ -3,6 +3,7 @@
 import datetime
 import logging
 import os
+import warnings
 from io import BytesIO
 from typing import Dict, List, Tuple, Union
 
@@ -383,6 +384,211 @@ class Api:
         }
         return mapping
 
+    def v3_stake_auth(
+        self,
+        submission_id: str,
+        staker: str,
+        amount: float | str | None = None,
+        max_amount: float | str | None = None,
+    ) -> Dict:
+        """Issue a staking v3 authorization for a selected submission.
+
+        Args:
+            submission_id (str): submission id for the selected submission
+            staker (str): staker wallet address
+            amount (float or str, optional): max stake amount for the
+                authorization. Retained as a backwards-compatible alias for
+                `max_amount`.
+            max_amount (float or str, optional): max stake amount for the
+                authorization.
+
+        Returns:
+            dict: authorization payload with the following fields:
+
+                * authorizationSigner (`str`)
+                * authorizationDigest (`str`)
+                * chainId (`str`)
+                * deadline (`str`)
+                * maxAmount (`str`)
+                * amount (`str`) alias for `maxAmount`
+                * modelId (`str`)
+                * nmrAddress (`str`)
+                * nonce (`str`)
+                * roundId (`str`)
+                * signature (`str`)
+                * staker (`str`)
+                * stakingAddress (`str`)
+                * submissionId (`str`)
+                * submissionHash (`str`)
+                * tournamentId (`str`)
+        """
+        if (amount is None) == (max_amount is None):
+            raise ValueError("Provide exactly one of amount or max_amount.")
+
+        max_amount = max_amount if max_amount is not None else amount
+        query = """
+          query($submissionId: ID!, $staker: String!, $maxAmount: String!) {
+            v3StakeAuth(
+              submissionId: $submissionId
+              staker: $staker
+              maxAmount: $maxAmount
+            ) {
+              authorizationSigner
+              authorizationDigest
+              chainId
+              deadline
+              maxAmount
+              modelId
+              nmrAddress
+              nonce
+              roundId
+              signature
+              staker
+              stakingAddress
+              submissionId
+              submissionHash
+              tournamentId
+            }
+          }
+        """
+        arguments = {
+            "submissionId": submission_id,
+            "staker": staker,
+            "maxAmount": str(max_amount),
+        }
+        authorization = self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeAuth"
+        ]
+        authorization["amount"] = authorization["maxAmount"]
+        return authorization
+
+    def v3_stake_config(self) -> Dict:
+        """Fetch staking v3 contract configuration.
+
+        Returns:
+            dict: staking v3 configuration with the following fields:
+
+                * address (`str`)
+                * authorizationSigner (`str`)
+                * nmrAddress (`str`)
+                * owner (`str`)
+                * paused (`bool`)
+                * pendingOwner (`str`)
+                * serviceWallet (`str`)
+        """
+        query = """
+          query {
+            v3StakeConfig {
+              address
+              authorizationSigner
+              nmrAddress
+              owner
+              paused
+              pendingOwner
+              serviceWallet
+            }
+          }
+        """
+        return self.raw_query(query, authorization=True)["data"]["v3StakeConfig"]
+
+    def v3_stake_round(self, round_id: int | str) -> Dict:
+        """Fetch staking v3 round status by round id.
+
+        Args:
+            round_id (int or str): round id
+
+        Returns:
+            dict: staking v3 round data with the following fields:
+
+                * closeTime (`str`)
+                * merkleRoot (`str`)
+                * openTime (`str`)
+                * payoutFactor (`str`)
+                * remainingBurn (`str`)
+                * remainingPayout (`str`)
+                * resolveTime (`str`)
+                * resolved (`bool`)
+                * roundId (`str`)
+                * stakeCap (`str`)
+                * stakeThreshold (`str`)
+                * state (`str`)
+                * totalPayout (`str`)
+                * totalStaked (`str`)
+                * tournamentId (`str`)
+        """
+        query = """
+          query($roundId: String!) {
+            v3StakeRound(roundId: $roundId) {
+              closeTime
+              merkleRoot
+              openTime
+              payoutFactor
+              remainingBurn
+              remainingPayout
+              resolveTime
+              resolved
+              roundId
+              stakeCap
+              stakeThreshold
+              state
+              totalPayout
+              totalStaked
+              tournamentId
+            }
+          }
+        """
+        arguments = {"roundId": str(round_id)}
+        return self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeRound"
+        ]
+
+    def v3_stake_claim(self, round_id: int | str, model_id: str, staker: str) -> Dict:
+        """Fetch a staking v3 claim proof for a model and staker.
+
+        Args:
+            round_id (int or str): round id
+            model_id (str): model id
+            staker (str): staker wallet address
+
+        Returns:
+            dict: claim payload with the following fields:
+
+                * apiModelId (`str`)
+                * burnAmountWei (`str`)
+                * merkleRoot (`str`)
+                * modelId (`str`)
+                * payoutAmountWei (`str`)
+                * proof (`list` of `str`)
+                * roundId (`str`)
+                * staker (`str`)
+                * submissionId (`str`)
+                * tournamentId (`str`)
+        """
+        query = """
+          query($roundId: String!, $modelId: ID!, $staker: String!) {
+            v3StakeClaim(roundId: $roundId, modelId: $modelId, staker: $staker) {
+              apiModelId
+              burnAmountWei
+              merkleRoot
+              modelId
+              payoutAmountWei
+              proof
+              roundId
+              staker
+              submissionId
+              tournamentId
+            }
+          }
+        """
+        arguments = {
+            "roundId": str(round_id),
+            "modelId": model_id,
+            "staker": staker,
+        }
+        return self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeClaim"
+        ]
+
     def get_current_round(self, tournament: int | None = None) -> int | None:
         """Get number of the current active round.
 
@@ -414,6 +620,79 @@ class Api:
         round_num = data["number"]
         return round_num
 
+    def list_rounds(
+        self,
+        number: int | None = None,
+        target: str | None = None,
+        status: str | None = None,
+        limit: int | None = None,
+    ) -> List[Dict]:
+        """List rounds with the filters supported by the round resolver.
+
+        Args:
+            number (int, optional): round number filter
+            target (str, optional): round target filter
+            status (str, optional): round status filter. One of `upcoming`,
+                `open`, `resolving`, or `resolved`
+            limit (int, optional): maximum number of rounds to return
+
+        Returns:
+            list of dicts: round entries matching the provided filters
+        """
+        query = """
+            query($tournament: Int
+                  $number: Int
+                  $target: String
+                  $status: RoundStatus
+                  $limit: Int) {
+              rounds(tournament: $tournament
+                     number: $number
+                     target: $target
+                     status: $status
+                     limit: $limit) {
+                id
+                tournament
+                number
+                target
+                closeTime
+                closeStakingTime
+                openTime
+                scoreTime
+                resolveTime
+                resolvedGeneral
+                resolvedStaking
+                payoutFactor
+                stakeThreshold
+                minCorrMultiplier
+                maxCorrMultiplier
+                defaultCorrMultiplier
+                minMmcMultiplier
+                maxMmcMultiplier
+                defaultMmcMultiplier
+                dataDatestamp
+              }
+            }
+        """
+        arguments = {
+            "tournament": self.tournament_id,
+            "number": number,
+            "target": target,
+            "status": None if status is None else status.upper(),
+            "limit": limit,
+        }
+        rounds = self.raw_query(query, arguments)["data"]["rounds"]
+        for round_info in rounds:
+            for field in [
+                "closeTime",
+                "closeStakingTime",
+                "openTime",
+                "scoreTime",
+                "resolveTime",
+            ]:
+                utils.replace(round_info, field, utils.parse_datetime_string)
+            utils.replace(round_info, "payoutFactor", utils.parse_float_string)
+        return rounds
+
     def set_bio(self, model_id: str, bio: str) -> bool:
         """Set bio field for a model id.
 
@@ -841,9 +1120,144 @@ class Api:
         utils.replace(results, "updatedAt", utils.parse_datetime_string)
         return results
 
+    def submission_scores(
+        self,
+        model_id: str,
+        display_name: str | None = None,
+        version: str | None = None,
+        day: int | None = None,
+        resolved: bool | None = None,
+        last_n_rounds: int | None = None,
+        distinct_on_round: bool | None = None,
+    ) -> List[Dict]:
+        """Fetch submission score history for a model.
+
+        Args:
+            model_id (str): target model UUID
+            display_name (str, optional): score metric name filter
+            version (str, optional): score version filter
+            day (int, optional): day filter
+            resolved (bool, optional): resolved-state filter
+            tournament (int, optional): tournament filter, defaults to the
+                API instance tournament
+            last_n_rounds (int, optional): limit by most recent rounds
+            distinct_on_round (bool, optional): keep only the latest score per
+                round after applying other filters
+
+        Returns:
+            list of dicts: list of submission score entries
+        """
+
+        query = """
+          query($modelId: ID!
+                $displayName: String
+                $version: String
+                $day: Int
+                $resolved: Boolean
+                $tournament: Int
+                $lastNRounds: Int
+                $distinctOnRound: Boolean) {
+            submissionScores(modelId: $modelId
+                             displayName: $displayName
+                             version: $version
+                             day: $day
+                             resolved: $resolved
+                             tournament: $tournament
+                             lastNRounds: $lastNRounds
+                             distinctOnRound: $distinctOnRound) {
+                roundId
+                submissionId
+                roundNumber
+                roundResolveTime
+                roundScoreTime
+                roundCloseStakingTime
+                value
+                percentile
+                displayName
+                version
+                date
+                day
+                resolveDate
+                resolved
+            }
+          }
+        """
+        arguments = {
+            "modelId": model_id,
+            "displayName": display_name,
+            "version": version,
+            "day": day,
+            "resolved": resolved,
+            "tournament": self.tournament_id,
+            "lastNRounds": last_n_rounds,
+            "distinctOnRound": distinct_on_round,
+        }
+        scores = self.raw_query(query, arguments)["data"]["submissionScores"]
+        for score in scores:
+            utils.replace(score, "roundResolveTime", utils.parse_datetime_string)
+            utils.replace(score, "roundScoreTime", utils.parse_datetime_string)
+            utils.replace(score, "roundCloseStakingTime", utils.parse_datetime_string)
+            utils.replace(score, "date", utils.parse_datetime_string)
+            utils.replace(score, "resolveDate", utils.parse_datetime_string)
+        return scores
+
+    def pending_model_payouts(self, tournament: int | None = None) -> Dict:
+        """Fetch actual and pending payouts for the authenticated user's models.
+
+        Args:
+            tournament (int, optional): tournament filter, defaults to the API
+                instance tournament
+
+        Returns:
+            dict: payout groups with `actual` and `pending` lists
+        """
+
+        query = """
+          query($tournament: Int!) {
+            pendingModelPayouts(tournament: $tournament) {
+                actual {
+                    roundId
+                    roundNumber
+                    roundResolveTime
+                    modelId
+                    modelName
+                    modelDisplayName
+                    payoutNmr
+                    payoutValue
+                    currencySymbol
+                }
+                pending {
+                    roundId
+                    roundNumber
+                    roundResolveTime
+                    modelId
+                    modelName
+                    modelDisplayName
+                    payoutNmr
+                    payoutValue
+                    currencySymbol
+                }
+            }
+          }
+        """
+        arguments = {
+            "tournament": self.tournament_id if tournament is None else tournament
+        }
+        payouts = self.raw_query(query, arguments, authorization=True)["data"][
+            "pendingModelPayouts"
+        ]
+        for payout_type in ["actual", "pending"]:
+            for payout in payouts[payout_type]:
+                utils.replace(payout, "roundResolveTime", utils.parse_datetime_string)
+                utils.replace(payout, "payoutNmr", utils.parse_float_string)
+                utils.replace(payout, "payoutValue", utils.parse_float_string)
+        return payouts
+
     def round_model_performances_v2(self, model_id: str):
         """Fetch round model performance of a user.
 
+        DEPRECATED - please use `submission_scores` instead when possible.
+
         Args:
             model_id (str)
 
@@ -871,6 +1285,13 @@ class Api:
                     * percentile (`float`)
                     * value (`float`): value of the metric
         """
+        warnings.warn(
+            "`round_model_performances_v2` is deprecated because it relies on "
+            "`v2RoundModelPerformances`. Use `submission_scores` instead when "
+            "possible.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
         query = """
           query($modelId: String!
@@ -1200,7 +1621,7 @@ class Api:
             return False
         if raw is None:
             return False
-        open_time = utils.parse_datetime_string(raw['openTime'])
+        open_time = utils.parse_datetime_string(raw["openTime"])
         now = datetime.datetime.now(tz=pytz.utc)
         is_new_round = open_time > now - datetime.timedelta(hours=hours)
         return is_new_round

{numerapi-2.22.0 → numerapi-2.23.0}/numerapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numerapi
-Version: 2.22.0
+Version: 2.23.0
 Summary: Automatically download and upload data for the Numerai machine learning competition
 Home-page: https://github.com/uuazed/numerapi
 Maintainer: uuazed

{numerapi-2.22.0 → numerapi-2.23.0}/numerapi.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ numerapi.egg-info/requires.txt
 numerapi.egg-info/top_level.txt
 tests/test_base_api.py
 tests/test_cli.py
+tests/test_cryptoapi.py
 tests/test_numerapi.py
 tests/test_signalsapi.py
 tests/test_utils.py

{numerapi-2.22.0 → numerapi-2.23.0}/setup.py

@@ -5,7 +5,7 @@ def load(path):
     return open(path, "r").read()
 
 
-numerapi_version = "2.22.0"
+numerapi_version = "2.23.0"
 
 
 classifiers = [

numerapi-2.23.0/tests/test_base_api.py

@@ -0,0 +1,484 @@
+import datetime
+import decimal
+import json
+import os
+import pytest
+import responses
+
+from numerapi import base_api
+
+
+@pytest.fixture(scope='function', name="api")
+def api_fixture():
+    api = base_api.Api(verbosity='DEBUG')
+    return api
+
+
+def test_NumerAPI():
+    # invalid log level should raise
+    with pytest.raises(AttributeError):
+        base_api.Api(verbosity="FOO")
+
+
+def test__login(api):
+    # passing only one of public_id and secret_key is not enough
+    api._login(public_id="foo", secret_key=None)
+    assert api.token is None
+    api._login(public_id=None, secret_key="bar")
+    assert api.token is None
+    # passing both works
+    api._login(public_id="foo", secret_key="bar")
+    assert api.token == ("foo", "bar")
+
+    # using env variables
+    os.environ["NUMERAI_SECRET_KEY"] = "key"
+    os.environ["NUMERAI_PUBLIC_ID"] = "id"
+    api._login()
+    assert api.token == ("id", "key")
+
+
+@responses.activate
+def test_raw_query(api):
+    query = "query {latestNmrPrice {priceUsd}}"
+    responses.add(
+        responses.POST,
+        base_api.API_TOURNAMENT_URL,
+        json={"data": {"latestNmrPrice": {"priceUsd": "42.00"}}},
+    )
+    result = api.raw_query(query)
+    assert isinstance(result, dict)
+    assert "data" in result
+
+
+@responses.activate
+def test_get_account(api):
+    api.token = ("", "")
+    account = {'apiTokens': [{'name': 'uploads',
+                              'public_id': 'AAA',
+                              'scopes': ['upload_submission']},
+                             {'name': '_internal_default',
+                              'public_id': 'BBB',
+                              'scopes': ['upload_submission',
+                                         'read_submission_info',
+                                         'read_user_info']},
+                             {'name': 'all',
+                              'public_id': 'CCC',
+                              'scopes': ['upload_submission',
+                                         'stake',
+                                         'read_submission_info',
+                                         'read_user_info']}],
+               'availableNmr': '1.010000000000000000',
+               'email': 'no-reply@eu83t4nncmxv3g2.xyz',
+               'id': '0c10a70a-a851-478f-a289-7a05fe397008',
+               'insertedAt': "2018-01-01 11:11:11",
+               'mfaEnabled': False,
+               'models': [{'id': '881778ad-2ee9-4fb0-82b4-7b7c0f7ce17d',
+                           'name': 'model1',
+                           'submissions':
+                            [{'filename': 'predictions-pPbLKSHGiR.csv',
+                              'id': 'f2369b69-8c43-47aa-b4de-de3a9de5f52c'}],
+                           'v2Stake': {'status': None, 'txHash': None}},
+                          {'id': '881778ad-2ee9-4fb0-82b4-7b7c0f7ce17d',
+                           'name': 'model2',
+                           'submissions':
+                           [{'filename': 'predictions-pPbPOWQNGiR.csv',
+                             'id': '46a62500-87c7-4d7c-98ad-b743037e8cfd'}],
+                           'v2Stake': {'status': None, 'txHash': None}}],
+               'status': 'VERIFIED',
+               'username': 'username1',
+               'walletAddress': '0x0000000000000000000000000000'}
+
+    data = {'data': {'account': account}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+    res = api.get_account()
+    assert isinstance(res, dict)
+    assert len(res.get('models')) == 2
+
+
+@responses.activate
+def test_get_models(api):
+    api.token = ("", "")
+    models_list = [
+        {"name": "model_x", "id": "95b0d9e2-c901-4f2b-9c98-24138b0bd706",
+         "tournament": 0},
+        {"name": "model_y", "id": "2c6d63a4-013f-42d1-bbaf-bf35725d29f7",
+         "tournament": 0}]
+    data = {'data': {'account': {'models': models_list}}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+    models = api.get_models()
+    assert sorted(models.keys()) == ['model_x', 'model_y']
+    assert sorted(models.values()) == ['2c6d63a4-013f-42d1-bbaf-bf35725d29f7',
+                                       '95b0d9e2-c901-4f2b-9c98-24138b0bd706']
+
+
+@responses.activate
+def test_set_submission_webhook(api):
+    api.token = ("", "")
+    data = {
+      "data": {
+        "setSubmissionWebhook": "true"
+      }
+    }
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+    res = api.set_submission_webhook(
+        '2c6d63a4-013f-42d1-bbaf-bf35725d29f7',
+        'https://triggerurl'
+    )
+    assert res
+
+
+@responses.activate
+def test_submission_scores(api):
+    api.tournament_id = 11
+    data = {
+        "data": {
+            "submissionScores": [
+                {
+                    "roundId": "round-1",
+                    "submissionId": "submission-1",
+                    "roundNumber": 123,
+                    "roundResolveTime": "2026-04-01T00:00:00Z",
+                    "roundScoreTime": "2026-03-29T00:00:00Z",
+                    "roundCloseStakingTime": "2026-03-28T00:00:00Z",
+                    "value": 0.12,
+                    "percentile": 0.95,
+                    "displayName": "CORR20",
+                    "version": "v5",
+                    "date": "2026-03-30T00:00:00Z",
+                    "day": 2,
+                    "resolveDate": "2026-04-01T00:00:00Z",
+                    "resolved": True,
+                }
+            ]
+        }
+    }
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    res = api.submission_scores(
+        "model-1",
+        display_name="CORR20",
+        version="v5",
+        day=2,
+        resolved=True,
+        last_n_rounds=5,
+        distinct_on_round=True,
+    )
+
+    assert len(res) == 1
+    assert res[0]["displayName"] == "CORR20"
+    assert isinstance(res[0]["roundResolveTime"], datetime.datetime)
+    assert isinstance(res[0]["roundScoreTime"], datetime.datetime)
+    assert isinstance(res[0]["roundCloseStakingTime"], datetime.datetime)
+    assert isinstance(res[0]["date"], datetime.datetime)
+    assert isinstance(res[0]["resolveDate"], datetime.datetime)
+
+    request_body = json.loads(responses.calls[0].request.body)
+    assert request_body["variables"]["tournament"] == 11
+    assert request_body["variables"]["lastNRounds"] == 5
+    assert request_body["variables"]["distinctOnRound"] is True
+
+
+@responses.activate
+def test_list_rounds(api):
+    api.tournament_id = 11
+    data = {
+        "data": {
+            "rounds": [
+                {
+                    "id": "round-1",
+                    "tournament": 11,
+                    "number": 123,
+                    "target": "main",
+                    "closeTime": "2026-03-27T00:00:00Z",
+                    "closeStakingTime": "2026-03-26T12:00:00Z",
+                    "openTime": "2026-03-20T00:00:00Z",
+                    "scoreTime": "2026-03-29T00:00:00Z",
+                    "resolveTime": "2026-04-01T00:00:00Z",
+                    "resolvedGeneral": False,
+                    "resolvedStaking": False,
+                    "payoutFactor": "0.8",
+                    "stakeThreshold": 0.1,
+                    "minCorrMultiplier": 0.0,
+                    "maxCorrMultiplier": 1.0,
+                    "defaultCorrMultiplier": 0.5,
+                    "minMmcMultiplier": 0.0,
+                    "maxMmcMultiplier": 1.0,
+                    "defaultMmcMultiplier": 0.5,
+                    "dataDatestamp": 20260320,
+                }
+            ]
+        }
+    }
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    res = api.list_rounds(number=123, target="main", status="open", limit=5)
+
+    assert len(res) == 1
+    assert isinstance(res[0]["closeTime"], datetime.datetime)
+    assert isinstance(res[0]["closeStakingTime"], datetime.datetime)
+    assert isinstance(res[0]["openTime"], datetime.datetime)
+    assert isinstance(res[0]["scoreTime"], datetime.datetime)
+    assert isinstance(res[0]["resolveTime"], datetime.datetime)
+    assert isinstance(res[0]["payoutFactor"], decimal.Decimal)
+
+    request_body = json.loads(responses.calls[0].request.body)
+    assert request_body["variables"]["tournament"] == 11
+    assert request_body["variables"]["number"] == 123
+    assert request_body["variables"]["target"] == "main"
+    assert request_body["variables"]["status"] == "OPEN"
+    assert request_body["variables"]["limit"] == 5
+
+
+@responses.activate
+def test_list_rounds_uses_api_tournament_id_by_default(api):
+    api.tournament_id = 11
+    data = {"data": {"rounds": []}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    api.list_rounds()
+
+    request_body = json.loads(responses.calls[0].request.body)
+    assert request_body["variables"]["tournament"] == 11
+
+
+@responses.activate
+def test_pending_model_payouts(api):
+    api.token = ("", "")
+    api.tournament_id = 12
+    data = {
+        "data": {
+            "pendingModelPayouts": {
+                "actual": [
+                    {
+                        "roundId": "round-a",
+                        "roundNumber": 12,
+                        "roundResolveTime": "2026-04-02T00:00:00Z",
+                        "modelId": "model-a",
+                        "modelName": "alpha",
+                        "modelDisplayName": "Alpha",
+                        "payoutNmr": "2.5000",
+                        "payoutValue": "31.20",
+                        "currencySymbol": "$",
+                    }
+                ],
+                "pending": [
+                    {
+                        "roundId": "round-b",
+                        "roundNumber": 13,
+                        "roundResolveTime": "2026-04-09T00:00:00Z",
+                        "modelId": "model-b",
+                        "modelName": "beta",
+                        "modelDisplayName": "Beta",
+                        "payoutNmr": "1.1000",
+                        "payoutValue": "13.73",
+                        "currencySymbol": "$",
+                    }
+                ],
+            }
+        }
+    }
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    res = api.pending_model_payouts()
+
+    assert len(res["actual"]) == 1
+    assert len(res["pending"]) == 1
+    assert res["actual"][0]["payoutNmr"] == decimal.Decimal("2.5000")
+    assert res["pending"][0]["payoutValue"] == decimal.Decimal("13.73")
+    assert isinstance(res["actual"][0]["roundResolveTime"], datetime.datetime)
+    assert isinstance(res["pending"][0]["roundResolveTime"], datetime.datetime)
+
+    request_body = json.loads(responses.calls[0].request.body)
+    assert request_body["variables"]["tournament"] == 12
+
+
+@responses.activate
+def test_round_model_performances_v2_warns(api):
+    api.tournament_id = 8
+    data = {
+        "data": {
+            "v2RoundModelPerformances": [
+                {
+                    "atRisk": "10.5",
+                    "corrMultiplier": 1.0,
+                    "mmcMultiplier": 0.5,
+                    "roundPayoutFactor": "0.8",
+                    "roundNumber": 456,
+                    "roundOpenTime": "2026-03-01T00:00:00Z",
+                    "roundResolveTime": "2026-03-29T00:00:00Z",
+                    "roundResolved": True,
+                    "roundTarget": "main",
+                    "submissionScores": [
+                        {
+                            "date": "2026-03-28T00:00:00Z",
+                            "day": 20,
+                            "displayName": "CORR20",
+                            "payoutPending": "0.8",
+                            "payoutSettled": "0.7",
+                            "percentile": 0.9,
+                            "value": 0.12,
+                        }
+                    ],
+                }
+            ]
+        }
+    }
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    with pytest.warns(DeprecationWarning, match="round_model_performances_v2"):
+        res = api.round_model_performances_v2("model-1")
+
+    assert len(res) == 1
+    assert res[0]["atRisk"] == decimal.Decimal("10.5")
+    assert isinstance(res[0]["roundOpenTime"], datetime.datetime)
+    assert isinstance(res[0]["roundResolveTime"], datetime.datetime)
+    assert res[0]["submissionScores"][0]["payoutPending"] == decimal.Decimal("0.8")
+
+
+@responses.activate
+def test_v3_stake_auth(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeAuth": {
+        "authorizationSigner": "0xsigner",
+        "authorizationDigest": "0xdigest",
+        "chainId": "11155111",
+        "deadline": "1770000000",
+        "maxAmount": "25",
+        "modelId": "0xmodel",
+        "nmrAddress": "0xnmr",
+        "nonce": "0",
+        "roundId": "4321",
+        "signature": "0x1234",
+        "staker": "0xstaker",
+        "stakingAddress": "0xstaking",
+        "submissionId": "submission-id",
+        "submissionHash": "0xhash",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_auth("submission-id", "0xstaker", amount=25)
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "mutation" not in body["query"]
+    assert "query(" in body["query"]
+    assert "v3StakeAuth" in body["query"]
+    assert body["variables"]["submissionId"] == "submission-id"
+    assert body["variables"]["maxAmount"] == "25"
+    assert "maxAmount" in body["query"]
+    assert result["maxAmount"] == "25"
+    assert result["amount"] == "25"
+    assert result["authorizationDigest"] == "0xdigest"
+
+
+@responses.activate
+def test_v3_stake_auth_accepts_max_amount(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeAuth": {
+        "authorizationSigner": "0xsigner",
+        "authorizationDigest": "0xdigest",
+        "chainId": "11155111",
+        "deadline": "1770000000",
+        "maxAmount": "30",
+        "modelId": "0xmodel",
+        "nmrAddress": "0xnmr",
+        "nonce": "0",
+        "roundId": "4321",
+        "signature": "0x1234",
+        "staker": "0xstaker",
+        "stakingAddress": "0xstaking",
+        "submissionId": "submission-id",
+        "submissionHash": "0xhash",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_auth(
+        "submission-id",
+        "0xstaker",
+        max_amount="30",
+    )
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "mutation" not in body["query"]
+    assert "query(" in body["query"]
+    assert body["variables"]["maxAmount"] == "30"
+    assert result["maxAmount"] == "30"
+    assert result["amount"] == "30"
+
+
+@responses.activate
+def test_v3_stake_config(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeConfig": {
+        "address": "0xstaking",
+        "authorizationSigner": "0xsigner",
+        "nmrAddress": "0xnmr",
+        "owner": "0xowner",
+        "paused": False,
+        "pendingOwner": "0xpending",
+        "serviceWallet": "0xservice",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_config()
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeConfig" in body["query"]
+    assert result["authorizationSigner"] == "0xsigner"
+
+
+@responses.activate
+def test_v3_stake_round(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeRound": {
+        "closeTime": "1",
+        "merkleRoot": "0xroot",
+        "openTime": "0",
+        "payoutFactor": "0.5",
+        "remainingBurn": "0",
+        "remainingPayout": "2",
+        "resolveTime": "2",
+        "resolved": False,
+        "roundId": "4321",
+        "stakeCap": "100",
+        "stakeThreshold": "10",
+        "state": "open",
+        "totalPayout": "2",
+        "totalStaked": "50",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_round(4321)
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeRound" in body["query"]
+    assert body["variables"]["roundId"] == "4321"
+    assert result["roundId"] == "4321"
+
+
+@responses.activate
+def test_v3_stake_claim(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeClaim": {
+        "apiModelId": "api-model-id",
+        "burnAmountWei": "0",
+        "merkleRoot": "0xroot",
+        "modelId": "0xmodel",
+        "payoutAmountWei": "2000000000000000000",
+        "proof": ["0xproof"],
+        "roundId": "4321",
+        "staker": "0xstaker",
+        "submissionId": "submission-id",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_claim(4321, "api-model-id", "0xstaker")
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeClaim" in body["query"]
+    assert body["variables"]["roundId"] == "4321"
+    assert body["variables"]["modelId"] == "api-model-id"
+    assert result["proof"] == ["0xproof"]

numerapi-2.23.0/tests/test_cryptoapi.py

@@ -0,0 +1,43 @@
+import decimal
+from unittest.mock import patch
+
+import pytest
+
+import numerapi
+
+
+@pytest.fixture(scope="function", name="api")
+def api_fixture():
+    api = numerapi.CryptoAPI(verbosity="DEBUG")
+    return api
+
+
+@patch("numerapi.cryptoapi.CryptoAPI.raw_query")
+def test_get_leaderboard(mocked, api):
+    mocked.return_value = {
+        "data": {
+            "cryptosignalsLeaderboard": [
+                {
+                    "nmrStaked": "13.0",
+                    "rank": 1,
+                    "username": "crypto_user",
+                    "corrRep": 0.1,
+                    "mmcRep": 0.2,
+                    "return_1_day": 0.03,
+                    "return_52_weeks": 0.4,
+                    "return_13_weeks": 0.15,
+                }
+            ]
+        }
+    }
+
+    lb = api.get_leaderboard(1)
+
+    assert len(lb) == 1
+    assert lb[0]["username"] == "crypto_user"
+    assert lb[0]["nmrStaked"] == decimal.Decimal("13.0")
+    mocked.assert_called_once()
+    args, kwargs = mocked.call_args
+    assert "cryptosignalsLeaderboard" in args[0]
+    assert args[1] == {"limit": 1, "offset": 0}
+    assert kwargs == {}

{numerapi-2.22.0 → numerapi-2.23.0}/tests/test_numerapi.py

@@ -1,5 +1,6 @@
 import pytest
 import datetime
+import json
 import pytz
 import responses
 
@@ -15,17 +16,20 @@ def api_fixture():
     return api
 
 
+@pytest.mark.live_api
 def test_get_competitions(api):
     res = api.get_competitions(tournament=1)
     assert isinstance(res, list)
     assert len(res) > 80
 
 
+@pytest.mark.live_api
 def test_get_current_round(api):
     current_round = api.get_current_round()
     assert current_round >= 82
 
 
+@pytest.mark.live_api
 @pytest.mark.parametrize("fun", ["get_account", "wallet_transactions"])
 def test_unauthorized_requests(api, fun):
     with pytest.raises(ValueError) as err:
@@ -37,6 +41,7 @@ def test_unauthorized_requests(api, fun):
            "Your session is invalid or has expired." in str(err.value)
 
 
+@pytest.mark.live_api
 def test_error_handling(api):
     # String instead of Int
     with pytest.raises(ValueError):
@@ -99,3 +104,4 @@ def test_check_new_round(api):
     assert api.check_new_round()
     # second
     assert not api.check_new_round()
+

{numerapi-2.22.0 → numerapi-2.23.0}/tests/test_signalsapi.py

@@ -13,6 +13,7 @@ def api_fixture():
     return api
 
 
+@pytest.mark.live_api
 def test_get_leaderboard(api):
     lb = api.get_leaderboard(1)
     assert len(lb) == 1

numerapi-2.22.0/tests/test_base_api.py

@@ -1,118 +0,0 @@
-import os
-import pytest
-import responses
-
-from numerapi import base_api
-
-
-@pytest.fixture(scope='function', name="api")
-def api_fixture():
-    api = base_api.Api(verbosity='DEBUG')
-    return api
-
-
-def test_NumerAPI():
-    # invalid log level should raise
-    with pytest.raises(AttributeError):
-        base_api.Api(verbosity="FOO")
-
-
-def test__login(api):
-    # passing only one of public_id and secret_key is not enough
-    api._login(public_id="foo", secret_key=None)
-    assert api.token is None
-    api._login(public_id=None, secret_key="bar")
-    assert api.token is None
-    # passing both works
-    api._login(public_id="foo", secret_key="bar")
-    assert api.token == ("foo", "bar")
-
-    # using env variables
-    os.environ["NUMERAI_SECRET_KEY"] = "key"
-    os.environ["NUMERAI_PUBLIC_ID"] = "id"
-    api._login()
-    assert api.token == ("id", "key")
-
-
-def test_raw_query(api):
-    query = "query {latestNmrPrice {priceUsd}}"
-    result = api.raw_query(query)
-    assert isinstance(result, dict)
-    assert "data" in result
-
-
-@responses.activate
-def test_get_account(api):
-    api.token = ("", "")
-    account = {'apiTokens': [{'name': 'uploads',
-                              'public_id': 'AAA',
-                              'scopes': ['upload_submission']},
-                             {'name': '_internal_default',
-                              'public_id': 'BBB',
-                              'scopes': ['upload_submission',
-                                         'read_submission_info',
-                                         'read_user_info']},
-                             {'name': 'all',
-                              'public_id': 'CCC',
-                              'scopes': ['upload_submission',
-                                         'stake',
-                                         'read_submission_info',
-                                         'read_user_info']}],
-               'availableNmr': '1.010000000000000000',
-               'email': 'no-reply@eu83t4nncmxv3g2.xyz',
-               'id': '0c10a70a-a851-478f-a289-7a05fe397008',
-               'insertedAt': "2018-01-01 11:11:11",
-               'mfaEnabled': False,
-               'models': [{'id': '881778ad-2ee9-4fb0-82b4-7b7c0f7ce17d',
-                           'name': 'model1',
-                           'submissions':
-                            [{'filename': 'predictions-pPbLKSHGiR.csv',
-                              'id': 'f2369b69-8c43-47aa-b4de-de3a9de5f52c'}],
-                           'v2Stake': {'status': None, 'txHash': None}},
-                          {'id': '881778ad-2ee9-4fb0-82b4-7b7c0f7ce17d',
-                           'name': 'model2',
-                           'submissions':
-                           [{'filename': 'predictions-pPbPOWQNGiR.csv',
-                             'id': '46a62500-87c7-4d7c-98ad-b743037e8cfd'}],
-                           'v2Stake': {'status': None, 'txHash': None}}],
-               'status': 'VERIFIED',
-               'username': 'username1',
-               'walletAddress': '0x0000000000000000000000000000'}
-
-    data = {'data': {'account': account}}
-    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
-    res = api.get_account()
-    assert isinstance(res, dict)
-    assert len(res.get('models')) == 2
-
-
-@responses.activate
-def test_get_models(api):
-    api.token = ("", "")
-    models_list = [
-        {"name": "model_x", "id": "95b0d9e2-c901-4f2b-9c98-24138b0bd706",
-         "tournament": 0},
-        {"name": "model_y", "id": "2c6d63a4-013f-42d1-bbaf-bf35725d29f7",
-         "tournament": 0}]
-    data = {'data': {'account': {'models': models_list}}}
-    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
-    models = api.get_models()
-    assert sorted(models.keys()) == ['model_x', 'model_y']
-    assert sorted(models.values()) == ['2c6d63a4-013f-42d1-bbaf-bf35725d29f7',
-                                       '95b0d9e2-c901-4f2b-9c98-24138b0bd706']
-
-
-@responses.activate
-def test_set_submission_webhook(api):
-    api.token = ("", "")
-    data = {
-      "data": {
-        "setSubmissionWebhook": "true"
-      }
-    }
-    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
-    res = api.set_submission_webhook(
-        '2c6d63a4-013f-42d1-bbaf-bf35725d29f7',
-        'https://triggerurl'
-    )
-    assert res