prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/deploy/constants.py

@@ -5,3 +5,9 @@ INVALID_OUTCOME_LOWERCASE_IDENTIFIER = "invalid"
 # Market-agnostic outcome identifiers
 YES_OUTCOME_LOWERCASE_IDENTIFIER = "yes"
 NO_OUTCOME_LOWERCASE_IDENTIFIER = "no"
+UP_OUTCOME_LOWERCASE_IDENTIFIER = "up"
+DOWN_OUTCOME_LOWERCASE_IDENTIFIER = "down"
+
+
+def is_invalid_outcome(outcome: str) -> bool:
+    return INVALID_OUTCOME_LOWERCASE_IDENTIFIER in outcome.lower()

prediction_market_agent_tooling/gtypes.py

@@ -1,6 +1,6 @@
 import typing as t
 from decimal import Decimal
-from typing import NewType
+from typing import Annotated, NewType, TypeAlias
 
 from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     Address,
@@ -8,6 +8,7 @@ from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy import
     HexAddress,
     HexStr,
 )
+from pydantic import BeforeValidator
 from pydantic.types import SecretStr
 from pydantic.v1.types import SecretStr as SecretStrV1
 from web3 import Web3
@@ -18,6 +19,7 @@ from web3.types import (  # noqa: F401  # Import for the sake of easy importing
 )
 from web3.types import Wei as Web3Wei
 
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
 from prediction_market_agent_tooling.tools._generic_value import _GenericValue
 from prediction_market_agent_tooling.tools.datetime_utc import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     DatetimeUTC,
@@ -26,6 +28,14 @@ from prediction_market_agent_tooling.tools.hexbytes_custom import (  # noqa: F40
     HexBytes,
 )
 
+VerifiedChecksumAddress: TypeAlias = Annotated[
+    ChecksumAddress, BeforeValidator(Web3.to_checksum_address)
+]
+VerifiedChecksumAddressOrNone: TypeAlias = Annotated[
+    ChecksumAddress | None,
+    BeforeValidator(lambda x: Web3.to_checksum_address(x) if x else None),
+]
+
 
 class CollateralToken(_GenericValue[int | float | str | Decimal, float], parser=float):
     """

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -9,7 +9,7 @@ from prediction_market_agent_tooling.deploy.betting_strategy import (
 from prediction_market_agent_tooling.gtypes import USD, Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
-    ProcessedTradedMarket,
+    ProcessedMarket,
 )
 from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_FALSE_OUTCOME,
@@ -64,7 +64,7 @@ class JobAgentMarket(AgentMarket, ABC):
     @abstractmethod
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         """Submit the completed result for this job."""
 
     def to_simple_job(self, max_bond: USD) -> SimpleJob:

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,13 +1,9 @@
 import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.deploy.betting_strategy import (
-    KellyBettingStrategy,
-    TradeType,
-)
 from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
-from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
 from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
     OmenAgentMarket,
@@ -72,7 +68,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         if not APIKeys().enable_ipfs_upload:
             raise RuntimeError(
                 f"ENABLE_IPFS_UPLOAD must be set to True to upload job results."
@@ -81,7 +77,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         trade = self.get_job_trade(max_bond, result)
         buy_id = self.buy_tokens(outcome=trade.outcome, amount=trade.amount)
 
-        processed_traded_market = ProcessedTradedMarket(
+        processed_traded_market = ProcessedMarket(
             answer=self.get_job_answer(result),
             trades=[PlacedTrade.from_trade(trade, id=buy_id)],
         )
@@ -92,20 +88,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return processed_traded_market
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
+        raise NotImplementedError("TODO: Refactor to avoid circular imports.")
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = KellyBettingStrategy(max_bet_amount=max_bond)
-        required_trades = strategy.calculate_trades(
-            existing_position=None,
-            answer=self.get_job_answer(result),
-            market=self,
-        )
-        assert (
-            len(required_trades) == 1
-        ), f"Shouldn't process same job twice: {required_trades}"
-        trade = required_trades[0]
-        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-        assert trade.outcome, "Should buy only YES on job markets."
-        return required_trades[0]
+        # strategy = FullBinaryKellyBettingStrategy(max_position_amount=max_bond)
+        # required_trades = strategy.calculate_trades(
+        #     existing_position=None,
+        #     answer=self.get_job_answer(result),
+        #     market=self,
+        # )
+        # assert (
+        #     len(required_trades) == 1
+        # ), f"Shouldn't process same job twice: {required_trades}"
+        # trade = required_trades[0]
+        # assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        # assert trade.outcome, "Should buy only YES on job markets."
+        # return required_trades[0]
 
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":
@@ -133,4 +130,6 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
             condition=market.condition,
             finalized_time=market.finalized_time,
             fees=market.fees,
+            upper_bound=market.upper_bound,
+            lower_bound=market.lower_bound,
         )

prediction_market_agent_tooling/loggers.py

@@ -10,6 +10,8 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 from pythonjsonlogger import jsonlogger
 from tenacity import RetryError
 
+UNPATCHED_PRINT_FN = builtins.print
+
 
 class LogFormat(str, Enum):
     DEFAULT = "default"
@@ -153,7 +155,13 @@ def print_using_logger_info(
     end: str = "\n",
     **kwargs: t.Any,
 ) -> None:
-    logger.info(sep.join(map(str, values)) + end)
+    # If `logger.exception` is used, loguru+traceback somehow uses `print` statement to format the error stack,
+    # if that happens, without this if condition, it errors out because of deadlock and/or recursion errors.
+    # This is hacky, but that's exactly how loguru is checking for it internally..
+    if any(getattr(handler._lock_acquired, "acquired", False) for handler in logger._core.handlers.values()):  # type: ignore # They use stubs and didn't type this.
+        UNPATCHED_PRINT_FN(*values, sep=sep, end=end, **kwargs)
+    else:
+        logger.info(sep.join(map(str, values)) + end)
 
 
 patch_logger()

prediction_market_agent_tooling/logprobs_parser.py

@@ -61,7 +61,8 @@ class LogprobsParser:
             (
                 i
                 for i in range(result_start_index, len(logprobs))
-                if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
+                if logprobs[i]["token"]
+                in {",", '"', ",\n", "\",\n'", '",\n', '"\n', "\n"}
             ),
             len(logprobs) - 1,
         )

prediction_market_agent_tooling/markets/agent_market.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 from enum import Enum
 from math import prod
 
@@ -10,17 +11,20 @@ from web3 import Web3
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.constants import (
-    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
+    DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
+    UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
+    is_invalid_outcome,
 )
 from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     OutcomeWei,
     Probability,
+    Wei,
+    xDai,
 )
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import (
     USD,
     Bet,
@@ -41,9 +45,6 @@ from prediction_market_agent_tooling.tools.utils import (
 
 class ProcessedMarket(BaseModel):
     answer: CategoricalProbabilisticAnswer
-
-
-class ProcessedTradedMarket(ProcessedMarket):
     trades: list[PlacedTrade]
 
 
@@ -61,6 +62,24 @@ class FilterBy(str, Enum):
     NONE = "none"
 
 
+class ParentMarket(BaseModel):
+    market: "AgentMarket"
+    parent_outcome: int
+
+
+class QuestionType(str, Enum):
+    ALL = "all"
+    CATEGORICAL = "categorical"
+    SCALAR = "scalar"
+    BINARY = "binary"
+
+
+class ConditionalFilterType(Enum):
+    ALL = 1
+    ONLY_CONDITIONAL = 2
+    ONLY_NOT_CONDITIONAL = 3
+
+
 class AgentMarket(BaseModel):
     """
     Common market class that can be created from vendor specific markets.
@@ -83,6 +102,11 @@ class AgentMarket(BaseModel):
     volume: CollateralToken | None
     fees: MarketFees
 
+    upper_bound: Wei | None = None
+    lower_bound: Wei | None = None
+
+    parent: ParentMarket | None = None
+
     @field_validator("probabilities")
     def validate_probabilities(
         cls,
@@ -92,11 +116,6 @@ class AgentMarket(BaseModel):
         outcomes: t.Sequence[OutcomeStr] = check_not_none(info.data.get("outcomes"))
         if set(probs.keys()) != set(outcomes):
             raise ValueError("Keys of `probabilities` must match `outcomes` exactly.")
-        total = float(sum(probs.values()))
-        if not 0.999 <= total <= 1.001:
-            # We simply log a warning because for some use-cases (e.g. existing positions), the
-            # markets might be already closed hence no reliable outcome token prices exist anymore.
-            logger.warning(f"Probabilities for market {info.data=} do not sum to 1.")
         return probs
 
     @field_validator("outcome_token_pool")
@@ -115,6 +134,9 @@ class AgentMarket(BaseModel):
                 )
         return outcome_token_pool
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        raise NotImplementedError("Subclasses must implement this method")
+
     def get_outcome_token_pool_by_outcome(self, outcome: OutcomeStr) -> OutcomeToken:
         if self.outcome_token_pool is None or not self.outcome_token_pool:
             return OutcomeToken(0)
@@ -129,6 +151,23 @@ class AgentMarket(BaseModel):
         if "fees" not in data and "fee" in data:
             data["fees"] = MarketFees(absolute=0.0, bet_proportion=data["fee"])
             del data["fee"]
+        # Backward compatibility for older `AgentMarket` without `probabilities`.
+        if "probabilities" not in data and "current_p_yes" in data:
+            yes_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    YES_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            no_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    NO_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            data["probabilities"] = {
+                yes_outcome: data["current_p_yes"],
+                no_outcome: 1 - data["current_p_yes"],
+            }
+            del data["current_p_yes"]
         return data
 
     def market_outcome_for_probability_key(
@@ -149,6 +188,17 @@ class AgentMarket(BaseModel):
             f"Could not find probability for market outcome {market_outcome}"
         )
 
+    @property
+    def question_type(self) -> QuestionType:
+        if self.is_binary:
+            return QuestionType.BINARY
+
+        elif self.is_scalar:
+            return QuestionType.SCALAR
+
+        else:
+            return QuestionType.CATEGORICAL
+
     @property
     def is_binary(self) -> bool:
         # 3 outcomes can also be binary if 3rd outcome is invalid (Seer)
@@ -162,11 +212,39 @@ class AgentMarket(BaseModel):
 
         if len(lowercase_outcomes) == 3:
             invalid_outcome = lowercase_outcomes[-1]
-            has_invalid = INVALID_OUTCOME_LOWERCASE_IDENTIFIER in invalid_outcome
+            has_invalid = is_invalid_outcome(invalid_outcome)
             return has_yes and has_no and has_invalid
 
         return has_yes and has_no
 
+    @property
+    def is_scalar(self) -> bool:
+        # 3 outcomes can also be binary if 3rd outcome is invalid (Seer)
+        if len(self.outcomes) not in [2, 3]:
+            return False
+
+        lowercase_outcomes = [outcome.lower() for outcome in self.outcomes]
+
+        has_up = UP_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_outcomes
+        has_down = DOWN_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_outcomes
+
+        if len(lowercase_outcomes) == 3:
+            invalid_outcome = lowercase_outcomes[-1]
+            has_invalid = is_invalid_outcome(invalid_outcome)
+            return has_up and has_down and has_invalid
+
+        return has_up and has_down
+
+    @property
+    def p_up(self) -> Probability:
+        probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
+        return check_not_none(probs_lowercase.get(UP_OUTCOME_LOWERCASE_IDENTIFIER))
+
+    @property
+    def p_down(self) -> Probability:
+        probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
+        return check_not_none(probs_lowercase.get(DOWN_OUTCOME_LOWERCASE_IDENTIFIER))
+
     @property
     def p_yes(self) -> Probability:
         probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
@@ -337,7 +415,8 @@ class AgentMarket(BaseModel):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        fetch_categorical_markets: bool = False,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")
 
@@ -380,7 +459,7 @@ class AgentMarket(BaseModel):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
@@ -439,11 +518,20 @@ class AgentMarket(BaseModel):
             )
 
     def get_outcome_index(self, outcome: OutcomeStr) -> int:
-        outcomes_lowercase = [o.lower() for o in self.outcomes]
+        """Get the index of the given outcome in the market's outcomes."""
         try:
-            return outcomes_lowercase.index(outcome.lower())
-        except ValueError:
-            raise ValueError(f"Outcome `{outcome}` not found in `{self.outcomes}`.")
+            return [o.lower() for o in self.outcomes].index(outcome.lower())
+        except ValueError as e:
+            raise ValueError(
+                f"Outcome '{outcome}' not found in market outcomes: {self.outcomes}"
+            ) from e
+
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+    ) -> None:
+        raise NotImplementedError("Subclass must implement this method")
 
     def get_token_balance(self, user_id: str, outcome: OutcomeStr) -> OutcomeToken:
         raise NotImplementedError("Subclasses must implement this method")
@@ -492,7 +580,7 @@ class AgentMarket(BaseModel):
 
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
-        raise NotImplementedError("Subclasses must implement this method")
+        return api_keys.bet_from_address
 
     def get_most_recent_trade_datetime(self, user_id: str) -> DatetimeUTC | None:
         raise NotImplementedError("Subclasses must implement this method")

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -1,28 +1,34 @@
+from typing import Sequence
+
 from web3 import Web3
 from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import HexBytes, HexStr
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    OutcomeStr,
+)
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
 from prediction_market_agent_tooling.markets.omen.data_models import (
     ContractPrediction,
     IPFSAgentResult,
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
-    OmenAgentResultMappingContract,
+    _AgentResultMappingContract,
 )
 from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.utils import BPS_CONSTANT
 from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
 
-# max uint16 for easy prediction identification (if market does not have YES outcome)
-UINT16_MAX = 2**16 - 1  # = 65535
-
 
 def store_trades(
-    market_id: str,
-    traded_market: ProcessedTradedMarket | None,
+    contract: _AgentResultMappingContract,
+    market_id: ChecksumAddress,
+    outcomes: Sequence[OutcomeStr],
+    traded_market: ProcessedMarket | None,
     keys: APIKeys,
     agent_name: str,
     web3: Web3 | None = None,
@@ -31,10 +37,18 @@ def store_trades(
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
         return None
 
-    yes_probability = traded_market.answer.get_yes_probability()
-    if not yes_probability:
-        logger.info("Skipping this since no yes_probability available.")
+    logger.info(
+        f"Storing trades for market {market_id}, with outcomes {outcomes}, {traded_market=}."
+    )
+
+    probabilities = traded_market.answer.probabilities
+    if not probabilities:
+        logger.info("Skipping this since no probabilities available.")
         return None
+
+    if all(outcome not in probabilities for outcome in outcomes):
+        raise ValueError("No of the market's outcomes is in the probabilities.")
+
     reasoning = traded_market.answer.reasoning if traded_market.answer.reasoning else ""
 
     ipfs_hash_decoded = HexBytes(HASH_ZERO)
@@ -46,24 +60,28 @@ def store_trades(
         ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
     # tx_hashes must be list of bytes32 (see Solidity contract).
-    tx_hashes = [
-        HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
-    ]
+    tx_hashes = [HexBytes(HexStr(i.id)) for i in traded_market.trades]
 
-    estimated_probability_bps = int(yes_probability * BPS_CONSTANT)
+    # Dune dashboard expects the probs to be in the same order as on the market.
+    probabilities_converted = [
+        (outcome, int(probabilities.get(outcome, 0) * BPS_CONSTANT))
+        for outcome in outcomes
+    ]
 
     prediction = ContractPrediction(
+        market=market_id,
         publisher=keys.bet_from_address,
         ipfs_hash=ipfs_hash_decoded,
         tx_hashes=tx_hashes,
-        estimated_probability_bps=estimated_probability_bps,
+        outcomes=[x[0] for x in probabilities_converted],
+        estimated_probabilities_bps=[x[1] for x in probabilities_converted],
     )
-    tx_receipt = OmenAgentResultMappingContract().add_prediction(
+    tx_receipt = contract.add_prediction(
         api_keys=keys,
-        market_address=Web3.to_checksum_address(market_id),
+        market_address=market_id,
         prediction=prediction,
         web3=web3,
     )
     logger.info(
-        f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."
+        f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].to_0x_hex()}."
     )