prediction-market-agent-tooling 0.54.0__py3-none-any.whl → 0.55.1__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -1,10 +1,10 @@
 import typing as t
 
-from gnosis.eth import EthereumClient
-from gnosis.safe import Safe
 from pydantic.types import SecretStr
 from pydantic.v1.types import SecretStr as SecretStrV1
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from safe_eth.eth import EthereumClient
+from safe_eth.safe.safe import SafeV141
 
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
@@ -200,6 +200,6 @@ class APIKeys(BaseSettings):
         if not self.SAFE_ADDRESS:
             raise ValueError("Cannot check ownership if safe_address is not defined.")
 
-        s = Safe(self.SAFE_ADDRESS, ethereum_client)  # type: ignore[abstract]
+        s = SafeV141(self.SAFE_ADDRESS, ethereum_client)
         public_key_from_signer = private_key_to_public_key(self.bet_from_private_key)
         return s.retrieve_is_owner(public_key_from_signer)

prediction_market_agent_tooling/deploy/agent.py

@@ -30,12 +30,17 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
+from prediction_market_agent_tooling.deploy.trade_interval import (
+    FixedInterval,
+    TradeInterval,
+)
 from prediction_market_agent_tooling.gtypes import xDai, xdai_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     ProcessedMarket,
+    ProcessedTradedMarket,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -165,9 +170,11 @@ class DeployableAgent:
         return f"{self.__class__.__name__} - {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}"
 
     def __init_subclass__(cls, **kwargs: t.Any) -> None:
-        if "DeployableAgent" not in str(
-            cls.__init__
-        ) and "DeployableTraderAgent" not in str(cls.__init__):
+        if (
+            "DeployableAgent" not in str(cls.__init__)
+            and "DeployableTraderAgent" not in str(cls.__init__)
+            and "DeployablePredictionAgent" not in str(cls.__init__)
+        ):
             raise TypeError(
                 "Cannot override __init__ method of deployable agent class, please override the `load` method to set up the agent."
             )
@@ -274,28 +281,22 @@ def {entrypoint_function_name}(request) -> str:
         return f"{self.__class__.__name__.lower()}-{market_type}-{utcnow().strftime('%Y-%m-%d--%H-%M-%S')}"
 
 
-class DeployableTraderAgent(DeployableAgent):
+class DeployablePredictionAgent(DeployableAgent):
     bet_on_n_markets_per_run: int = 1
+    n_markets_to_fetch: int = MAX_AVAILABLE_MARKETS
     min_balance_to_keep_in_native_currency: xDai | None = xdai_type(0.1)
     allow_invalid_questions: bool = False
-    same_market_bet_interval: timedelta = timedelta(hours=24)
+    same_market_trade_interval: TradeInterval = FixedInterval(timedelta(hours=24))
+    # Only Metaculus allows to post predictions without trading (buying/selling of outcome tokens).
+    supported_markets: t.Sequence[MarketType] = [MarketType.METACULUS]
 
     def __init__(
         self,
         enable_langfuse: bool = APIKeys().default_enable_langfuse,
-        place_bet: bool = True,
+        store_prediction: bool = True,
     ) -> None:
         super().__init__(enable_langfuse=enable_langfuse)
-        self.place_bet = place_bet
-
-    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
-        user_id = market.get_user_id(api_keys=APIKeys())
-
-        total_amount = market.get_tiny_bet_amount().amount
-        if existing_position := market.get_position(user_id=user_id):
-            total_amount += existing_position.total_amount.amount
-
-        return MaxAccuracyBettingStrategy(bet_amount=total_amount)
+        self.store_prediction = store_prediction
 
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
@@ -304,7 +305,6 @@ class DeployableTraderAgent(DeployableAgent):
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
-        self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -342,19 +342,6 @@ class DeployableTraderAgent(DeployableAgent):
                 f"{api_keys=} doesn't have enough operational balance."
             )
 
-    def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
-        api_keys = APIKeys()
-
-        # Get the strategy to know how much it will bet.
-        strategy = self.get_betting_strategy(market)
-        # Have a little bandwidth after the bet.
-        min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
-
-        if market.get_trade_balance(api_keys) < min_required_balance_to_trade:
-            raise OutOfFundsError(
-                f"Minimum required balance {min_required_balance_to_trade} for agent is not met."
-            )
-
     def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
         return have_bet_on_market_since(keys=APIKeys(), market=market, since=since)
 
@@ -363,7 +350,9 @@ class DeployableTraderAgent(DeployableAgent):
         Subclasses can implement their own logic instead of this one, or on top of this one.
         By default, it allows only markets where user didn't bet recently and it's a reasonable question.
         """
-        if self.have_bet_on_market_since(market, since=self.same_market_bet_interval):
+        if self.have_bet_on_market_since(
+            market, since=self.same_market_trade_interval.get(market=market)
+        ):
             return False
 
         # Manifold allows to bet only on markets with probability between 1 and 99.
@@ -388,37 +377,21 @@ class DeployableTraderAgent(DeployableAgent):
     def get_markets(
         self,
         market_type: MarketType,
-        limit: int = MAX_AVAILABLE_MARKETS,
         sort_by: SortBy = SortBy.CLOSING_SOONEST,
         filter_by: FilterBy = FilterBy.OPEN,
     ) -> t.Sequence[AgentMarket]:
         cls = market_type.market_class
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_binary_markets(
-            limit=limit, sort_by=sort_by, filter_by=filter_by
+            limit=self.n_markets_to_fetch, sort_by=sort_by, filter_by=filter_by
         )
         return available_markets
 
-    def build_trades(
-        self,
-        market: AgentMarket,
-        answer: ProbabilisticAnswer,
-        existing_position: Position | None,
-    ) -> list[Trade]:
-        strategy = self.get_betting_strategy(market=market)
-        trades = strategy.calculate_trades(existing_position, answer, market)
-        BettingStrategy.assert_trades_currency_match_markets(market, trades)
-        return trades
-
     def before_process_market(
         self, market_type: MarketType, market: AgentMarket
     ) -> None:
-        self.update_langfuse_trace_by_market(market_type, market)
-
         api_keys = APIKeys()
 
-        self.check_min_required_balance_to_trade(market)
-
         if market_type.is_blockchain_market:
             # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
             if self.min_balance_to_keep_in_native_currency is not None:
@@ -434,65 +407,39 @@ class DeployableTraderAgent(DeployableAgent):
         market: AgentMarket,
         verify_market: bool = True,
     ) -> ProcessedMarket | None:
+        self.update_langfuse_trace_by_market(market_type, market)
         logger.info(f"Processing market {market.question=} from {market.url=}.")
 
-        self.before_process_market(market_type, market)
-
+        answer: ProbabilisticAnswer | None
         if verify_market and not self.verify_market(market_type, market):
             logger.info(f"Market '{market.question}' doesn't meet the criteria.")
-            self.update_langfuse_trace_by_processed_market(market_type, None)
-            return None
-
-        answer = self.answer_binary_market(market)
-
-        if answer is None:
-            logger.info(f"No answer for market '{market.question}'.")
-            self.update_langfuse_trace_by_processed_market(market_type, None)
-            return None
+            answer = None
+        else:
+            answer = self.answer_binary_market(market)
 
-        existing_position = market.get_position(user_id=APIKeys().bet_from_address)
-        trades = self.build_trades(
-            market=market,
-            answer=answer,
-            existing_position=existing_position,
+        processed_market = (
+            ProcessedMarket(answer=answer) if answer is not None else None
         )
 
-        placed_trades = []
-        if self.place_bet:
-            for trade in trades:
-                logger.info(f"Executing trade {trade} on market {market.id}")
-
-                match trade.trade_type:
-                    case TradeType.BUY:
-                        id = market.buy_tokens(
-                            outcome=trade.outcome, amount=trade.amount
-                        )
-                    case TradeType.SELL:
-                        id = market.sell_tokens(
-                            outcome=trade.outcome, amount=trade.amount
-                        )
-                    case _:
-                        raise ValueError(f"Unexpected trade type {trade.trade_type}.")
-                placed_trades.append(PlacedTrade.from_trade(trade, id))
-
-        processed_market = ProcessedMarket(answer=answer, trades=placed_trades)
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
-
-        self.after_process_market(
-            market_type, market, processed_market=processed_market
+        logger.info(
+            f"Processed market {market.question=} from {market.url=} with {answer=}."
         )
-
-        logger.info(f"Processed market {market.question=} from {market.url=}.")
         return processed_market
 
     def after_process_market(
         self,
         market_type: MarketType,
         market: AgentMarket,
-        processed_market: ProcessedMarket,
+        processed_market: ProcessedMarket | None,
     ) -> None:
         keys = APIKeys()
-        market.store_prediction(processed_market=processed_market, keys=keys)
+        if self.store_prediction:
+            market.store_prediction(processed_market=processed_market, keys=keys)
+        else:
+            logger.info(
+                f"Prediction {processed_market} not stored because {self.store_prediction=}."
+            )
 
     def before_process_markets(self, market_type: MarketType) -> None:
         """
@@ -514,7 +461,9 @@ class DeployableTraderAgent(DeployableAgent):
         processed = 0
 
         for market in available_markets:
+            self.before_process_market(market_type, market)
             processed_market = self.process_market(market_type, market)
+            self.after_process_market(market_type, market, processed_market)
 
             if processed_market is not None:
                 processed += 1
@@ -528,6 +477,139 @@ class DeployableTraderAgent(DeployableAgent):
         "Executes actions that occur after bets are placed."
 
     def run(self, market_type: MarketType) -> None:
+        if market_type not in self.supported_markets:
+            raise ValueError(
+                f"Only {self.supported_markets} are supported by this agent."
+            )
         self.before_process_markets(market_type)
         self.process_markets(market_type)
         self.after_process_markets(market_type)
+
+
+class DeployableTraderAgent(DeployablePredictionAgent):
+    # These markets require place of bet, not just predictions.
+    supported_markets: t.Sequence[MarketType] = [
+        MarketType.OMEN,
+        MarketType.MANIFOLD,
+        MarketType.POLYMARKET,
+    ]
+
+    def __init__(
+        self,
+        enable_langfuse: bool = APIKeys().default_enable_langfuse,
+        store_prediction: bool = True,
+        store_trades: bool = True,
+        place_trades: bool = True,
+    ) -> None:
+        super().__init__(
+            enable_langfuse=enable_langfuse, store_prediction=store_prediction
+        )
+        self.store_trades = store_trades
+        self.place_trades = place_trades
+
+    def initialize_langfuse(self) -> None:
+        super().initialize_langfuse()
+        # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
+        self.get_betting_strategy = observe()(self.get_betting_strategy)  # type: ignore[method-assign]
+        self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
+
+    def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
+        api_keys = APIKeys()
+
+        # Get the strategy to know how much it will bet.
+        strategy = self.get_betting_strategy(market)
+        # Have a little bandwidth after the bet.
+        min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
+
+        if market.get_trade_balance(api_keys) < min_required_balance_to_trade:
+            raise OutOfFundsError(
+                f"Minimum required balance {min_required_balance_to_trade} for agent is not met."
+            )
+
+    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
+        user_id = market.get_user_id(api_keys=APIKeys())
+
+        total_amount = market.get_tiny_bet_amount().amount
+        if existing_position := market.get_position(user_id=user_id):
+            total_amount += existing_position.total_amount.amount
+
+        return MaxAccuracyBettingStrategy(bet_amount=total_amount)
+
+    def build_trades(
+        self,
+        market: AgentMarket,
+        answer: ProbabilisticAnswer,
+        existing_position: Position | None,
+    ) -> list[Trade]:
+        strategy = self.get_betting_strategy(market=market)
+        trades = strategy.calculate_trades(existing_position, answer, market)
+        BettingStrategy.assert_trades_currency_match_markets(market, trades)
+        return trades
+
+    def before_process_market(
+        self, market_type: MarketType, market: AgentMarket
+    ) -> None:
+        super().before_process_market(market_type, market)
+        self.check_min_required_balance_to_trade(market)
+
+    def process_market(
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        verify_market: bool = True,
+    ) -> ProcessedTradedMarket | None:
+        processed_market = super().process_market(market_type, market, verify_market)
+        if processed_market is None:
+            return None
+
+        api_keys = APIKeys()
+        existing_position = market.get_position(
+            user_id=market.get_user_id(api_keys=api_keys)
+        )
+        trades = self.build_trades(
+            market=market,
+            answer=processed_market.answer,
+            existing_position=existing_position,
+        )
+
+        placed_trades = []
+        for trade in trades:
+            logger.info(f"Executing trade {trade} on market {market.id} ({market.url})")
+
+            if self.place_trades:
+                match trade.trade_type:
+                    case TradeType.BUY:
+                        id = market.buy_tokens(
+                            outcome=trade.outcome, amount=trade.amount
+                        )
+                    case TradeType.SELL:
+                        id = market.sell_tokens(
+                            outcome=trade.outcome, amount=trade.amount
+                        )
+                    case _:
+                        raise ValueError(f"Unexpected trade type {trade.trade_type}.")
+                placed_trades.append(PlacedTrade.from_trade(trade, id))
+            else:
+                logger.info(f"Trade execution skipped because {self.place_trades=}.")
+
+        traded_market = ProcessedTradedMarket(
+            answer=processed_market.answer, trades=placed_trades
+        )
+        logger.info(f"Traded market {market.question=} from {market.url=}.")
+        return traded_market
+
+    def after_process_market(
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        processed_market: ProcessedMarket | None,
+    ) -> None:
+        api_keys = APIKeys()
+        super().after_process_market(market_type, market, processed_market)
+        if isinstance(processed_market, ProcessedTradedMarket):
+            if self.store_trades:
+                market.store_trades(processed_market, api_keys)
+            else:
+                logger.info(
+                    f"Trades {processed_market.trades} not stored because {self.store_trades=}."
+                )

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -24,6 +24,10 @@ from prediction_market_agent_tooling.tools.betting_strategies.utils import Simpl
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
+class GuaranteedLossError(RuntimeError):
+    pass
+
+
 class BettingStrategy(ABC):
     @abstractmethod
     def calculate_trades(
@@ -63,7 +67,7 @@ class BettingStrategy(ABC):
                 )
 
                 if outcome_tokens_to_get.amount < trade.amount.amount:
-                    raise RuntimeError(
+                    raise GuaranteedLossError(
                         f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}."
                     )
 

prediction_market_agent_tooling/deploy/trade_interval.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from datetime import timedelta
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.tools.utils import check_not_none
+
+
+class TradeInterval(ABC):
+    @abstractmethod
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        raise NotImplementedError("Subclass should implement this.")
+
+
+class FixedInterval(TradeInterval):
+    """
+    For trades at a fixed interval.
+    """
+
+    def __init__(self, interval: timedelta):
+        self.interval = interval
+
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        return self.interval
+
+
+class MarketLifetimeProportionalInterval(TradeInterval):
+    """
+    For uniformly distributed trades over the market's lifetime.
+    """
+
+    def __init__(self, max_trades: int):
+        self.max_trades = max_trades
+
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        created_time = check_not_none(market.created_time)
+        close_time = check_not_none(market.close_time)
+        return (close_time - created_time) / self.max_trades

prediction_market_agent_tooling/markets/agent_market.py

@@ -29,6 +29,9 @@ from prediction_market_agent_tooling.tools.utils import (
 
 class ProcessedMarket(BaseModel):
     answer: ProbabilisticAnswer
+
+
+class ProcessedTradedMarket(ProcessedMarket):
     trades: list[PlacedTrade]
 
 
@@ -228,13 +231,21 @@ class AgentMarket(BaseModel):
         raise NotImplementedError("Subclasses must implement this method")
 
     def store_prediction(
-        self, processed_market: ProcessedMarket, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys
     ) -> None:
         """
         If market allows to upload predictions somewhere, implement it in this method.
         """
         raise NotImplementedError("Subclasses must implement this method")
 
+    def store_trades(
+        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+    ) -> None:
+        """
+        If market allows to upload trades somewhere, implement it in this method.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
     @staticmethod
     def get_bets_made_since(
         better_address: ChecksumAddress, start_time: DatetimeUTC

prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -56,6 +56,9 @@ class Question(BaseModel):
     my_forecasts: MyAggregation
     type: QuestionType
     possibilities: dict[str, str] | None
+    description: str
+    fine_print: str
+    resolution_criteria: str
 
 
 class MetaculusQuestion(BaseModel):
@@ -64,7 +67,7 @@ class MetaculusQuestion(BaseModel):
     author_username: str
     title: str
     created_at: DatetimeUTC
-    published_at: DatetimeUTC
+    published_at: DatetimeUTC | None
     scheduled_close_time: DatetimeUTC
     scheduled_resolve_time: DatetimeUTC
     user_permission: str

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -1,11 +1,11 @@
 import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    ProcessedMarket,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.metaculus.api import (
@@ -17,7 +17,7 @@ from prediction_market_agent_tooling.markets.metaculus.api import (
 from prediction_market_agent_tooling.markets.metaculus.data_models import (
     MetaculusQuestion,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC, check_not_none
 
 
 class MetaculusAgentMarket(AgentMarket):
@@ -27,9 +27,9 @@ class MetaculusAgentMarket(AgentMarket):
 
     have_predicted: bool
     base_url: t.ClassVar[str] = METACULUS_API_BASE_URL
-    description: str | None = (
-        None  # Metaculus markets don't have a description, so just default to None.
-    )
+    description: str
+    fine_print: str
+    resolution_criteria: str
     fees: MarketFees = MarketFees.get_zero_fees()  # No fees on Metaculus.
 
     @staticmethod
@@ -46,6 +46,9 @@ class MetaculusAgentMarket(AgentMarket):
             volume=None,
             have_predicted=model.question.my_forecasts.latest is not None,
             outcome_token_pool=None,
+            description=model.question.description,
+            fine_print=model.question.fine_print,
+            resolution_criteria=model.question.resolution_criteria,
         )
 
     @staticmethod
@@ -103,10 +106,29 @@ class MetaculusAgentMarket(AgentMarket):
                 break
         return [MetaculusAgentMarket.from_data_model(q) for q in all_questions[:limit]]
 
-    def submit_prediction(self, p_yes: Probability, reasoning: str) -> None:
-        make_prediction(self.id, p_yes)
-        post_question_comment(self.id, reasoning)
+    def store_prediction(
+        self, processed_market: ProcessedMarket | None, keys: APIKeys
+    ) -> None:
+        if processed_market is not None:
+            make_prediction(self.id, processed_market.answer.p_yes)
+            post_question_comment(
+                self.id,
+                check_not_none(
+                    processed_market.answer.reasoning,
+                    "Reasoning must be provided for Metaculus.",
+                ),
+            )
 
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
         return str(api_keys.metaculus_user_id)
+
+    @staticmethod
+    def verify_operational_balance(api_keys: APIKeys) -> bool:
+        # No operational balance for Metaculus.
+        return True
+
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys) -> None:
+        # Nothing to redeem on Metaculus.
+        pass

prediction_market_agent_tooling/markets/omen/omen.py

@@ -25,6 +25,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     FilterBy,
     MarketFees,
     ProcessedMarket,
+    ProcessedTradedMarket,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -417,12 +418,19 @@ class OmenAgentMarket(AgentMarket):
         ) > xdai_type(0.001)
 
     def store_prediction(
-        self, processed_market: ProcessedMarket, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys
     ) -> None:
+        """On Omen, we have to store predictions along with trades, see `store_trades`."""
+
+    def store_trades(
+        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+    ) -> None:
+        if traded_market is None:
+            logger.warning(f"No prediction for market {self.id}, not storing anything.")
+            return
+
         reasoning = (
-            processed_market.answer.reasoning
-            if processed_market.answer.reasoning
-            else ""
+            traded_market.answer.reasoning if traded_market.answer.reasoning else ""
         )
 
         ipfs_hash_decoded = HexBytes(HASH_ZERO)
@@ -434,13 +442,13 @@ class OmenAgentMarket(AgentMarket):
             ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
         tx_hashes = [
-            HexBytes(HexStr(i.id)) for i in processed_market.trades if i.id is not None
+            HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
         ]
         prediction = ContractPrediction(
             publisher=keys.public_key,
             ipfs_hash=ipfs_hash_decoded,
             tx_hashes=tx_hashes,
-            estimated_probability_bps=int(processed_market.answer.p_yes * 10000),
+            estimated_probability_bps=int(traded_market.answer.p_yes * 10000),
         )
         tx_receipt = OmenAgentResultMappingContract().add_prediction(
             api_keys=keys,

prediction_market_agent_tooling/tools/is_invalid.py

@@ -24,7 +24,7 @@ QUESTION_IS_INVALID_PROMPT = """Main signs about an invalid question (sometimes
 - The violent event can be caused by a single conscious being.
 - The violent event is done illegally.
 - The market should not directly incentivize immoral violent (such as murder, rape or unjust imprisonment) actions which could likely be performed by any participant.
-- Invalid: Will Donald Trump be alive on the 01/12/2021? (Anyone could bet on “No” and kill him for a guaranteed profit. Anyone could bet on “Yes” to effectively put a bounty on his head).
+- Invalid: Will Donald Trump be alive on the 01/12/2021? (Anyone could bet on "No" and kill him for a guaranteed profit. Anyone could bet on "Yes" to effectively put a bounty on his head).
 - Invalid: Will Hera be a victim of swatting in 2020? (Anyone could falsely call the emergency services on him in order to win the bet)
 - This does not prevent markets:
   - Whose topics are violent events not caused by conscious beings.
@@ -35,9 +35,10 @@ QUESTION_IS_INVALID_PROMPT = """Main signs about an invalid question (sometimes
   - Valid: Will the US be engaged in a military conflict with a UN member state in 2021? (It’s unlikely for the US to declare war in order to win a bet on this market).
   - Valid: Will Derek Chauvin go to jail for the murder of George Flyod? (It’s unlikely that the jurors would collude to make a wrong verdict in order to win this market).
 - Questions with relative dates will resolve as invalid. Dates must be stated in absolute terms, not relative depending on the current time.
-- Invalid: Who will be the president of the United States in 6 months? (“in 6 months depends on the current time”).
+- Invalid: Who will be the president of the United States in 6 months? ("in 6 months depends on the current time").
+- Invalid: In the next 14 days, will Gnosis Chain gain another 1M users? ("in the next 14 days depends on the current time").
 - Questions about moral values and not facts will be resolved as invalid.
-- Invalid: “Is it ethical to eat meat?”.
+- Invalid: "Is it ethical to eat meat?".
 
 Follow a chain of thought to evaluate if the question is invalid:
 

prediction_market_agent_tooling/tools/relevant_news_analysis/data_models.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+
+from prediction_market_agent_tooling.tools.tavily.tavily_models import TavilyResult
+
+
+class RelevantNewsAnalysis(BaseModel):
+    reasoning: str = Field(
+        ...,
+        description="The reason why the news contains information relevant to the given question. Or if no news is relevant, why not.",
+    )
+    contains_relevant_news: bool = Field(
+        ...,
+        description="A boolean flag for whether the news contains information relevant to the given question.",
+    )
+
+
+class RelevantNews(BaseModel):
+    question: str
+    url: str
+    summary: str
+    relevance_reasoning: str
+    days_ago: int
+
+    @staticmethod
+    def from_tavily_result_and_analysis(
+        question: str,
+        days_ago: int,
+        tavily_result: TavilyResult,
+        relevant_news_analysis: RelevantNewsAnalysis,
+    ) -> "RelevantNews":
+        return RelevantNews(
+            question=question,
+            url=tavily_result.url,
+            summary=tavily_result.content,
+            relevance_reasoning=relevant_news_analysis.reasoning,
+            days_ago=days_ago,
+        )
+
+
+class NoRelevantNews(BaseModel):
+    """
+    A placeholder model for when no relevant news is found. Enables ability to
+    distinguish between 'a cache hit with no news' and 'a cache miss'.
+    """

prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_analysis.py

@@ -0,0 +1,162 @@
+from datetime import datetime, timedelta
+
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import ChatOpenAI
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+from prediction_market_agent_tooling.tools.relevant_news_analysis.data_models import (
+    NoRelevantNews,
+    RelevantNews,
+    RelevantNewsAnalysis,
+)
+from prediction_market_agent_tooling.tools.relevant_news_analysis.relevant_news_cache import (
+    RelevantNewsResponseCache,
+)
+from prediction_market_agent_tooling.tools.tavily.tavily_search import (
+    get_relevant_news_since,
+)
+from prediction_market_agent_tooling.tools.tavily.tavily_storage import TavilyStorage
+from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
+
+SUMMARISE_RELEVANT_NEWS_PROMPT_TEMPLATE = """
+You are an expert news analyst, tracking stories that may affect your prediction to the outcome of a particular QUESTION.
+
+Your role is to identify only the relevant information from a scraped news site (RAW_CONTENT), analyse it, and determine whether it contains developments or announcements occurring **after** the DATE_OF_INTEREST that could affect the outcome of the QUESTION.
+
+Note that the news article may be published after the DATE_OF_INTEREST, but reference information that is older than the DATE_OF_INTEREST.
+
+[QUESTION]
+{question}
+
+[DATE_OF_INTEREST]
+{date_of_interest}
+
+[RAW_CONTENT]
+{raw_content}
+
+For your analysis, you should:
+- Discard the 'noise' from the raw content (e.g. ads, irrelevant content)
+- Consider ONLY information that would have a notable impact on the outcome of the question.
+- Consider ONLY information relating to an announcement or development that occurred **after** the DATE_OF_INTEREST.
+- Present this information concisely in your reasoning.
+- In your reasoning, do not use the term 'DATE_OF_INTEREST' directly. Use the actual date you are referring to instead.
+- In your reasoning, do not use the term 'RAW_CONTENT' directly. Refer to it as 'the article', or quote the content you are referring to.
+
+{format_instructions}
+"""
+
+
+@observe()
+def analyse_news_relevance(
+    raw_content: str,
+    question: str,
+    date_of_interest: datetime,
+    model: str,
+    temperature: float,
+) -> RelevantNewsAnalysis:
+    """
+    Analyse whether the news contains new (relative to the given date)
+    information relevant to the given question.
+    """
+    parser = PydanticOutputParser(pydantic_object=RelevantNewsAnalysis)
+    prompt = PromptTemplate(
+        template=SUMMARISE_RELEVANT_NEWS_PROMPT_TEMPLATE,
+        input_variables=["question", "date_of_interest", "raw_content"],
+        partial_variables={"format_instructions": parser.get_format_instructions()},
+    )
+    llm = ChatOpenAI(
+        temperature=temperature,
+        model=model,
+        api_key=APIKeys().openai_api_key_secretstr_v1,
+    )
+    chain = prompt | llm | parser
+
+    relevant_news_analysis: RelevantNewsAnalysis = chain.invoke(
+        {
+            "raw_content": raw_content,
+            "question": question,
+            "date_of_interest": str(date_of_interest),
+        },
+        config=get_langfuse_langchain_config(),
+    )
+    return relevant_news_analysis
+
+
+@observe()
+def get_certified_relevant_news_since(
+    question: str,
+    days_ago: int,
+    tavily_storage: TavilyStorage | None = None,
+) -> RelevantNews | None:
+    """
+    Get relevant news since a given date for a given question. Retrieves
+    possibly relevant news from tavily, then checks that it is relevant via
+    an LLM call.
+    """
+    results = get_relevant_news_since(
+        question=question,
+        days_ago=days_ago,
+        score_threshold=0.0,  # Be conservative to avoid missing relevant information
+        max_results=3,  # A tradeoff between cost and quality. 3 seems to be a good balance.
+        tavily_storage=tavily_storage,
+    )
+
+    # Sort results by descending 'relevance score' to maximise the chance of
+    # finding relevant news early
+    results = sorted(
+        results,
+        key=lambda result: result.score,
+        reverse=True,
+    )
+
+    for result in results:
+        relevant_news_analysis = analyse_news_relevance(
+            raw_content=check_not_none(result.raw_content),
+            question=question,
+            date_of_interest=utcnow() - timedelta(days=days_ago),
+            model="gpt-4o",  # 4o-mini isn't good enough, 1o and 1o-mini are too expensive
+            temperature=0.0,
+        )
+
+        # Return first relevant news found
+        if relevant_news_analysis.contains_relevant_news:
+            return RelevantNews.from_tavily_result_and_analysis(
+                question=question,
+                days_ago=days_ago,
+                tavily_result=result,
+                relevant_news_analysis=relevant_news_analysis,
+            )
+
+    # No relevant news found
+    return None
+
+
+def get_certified_relevant_news_since_cached(
+    question: str,
+    days_ago: int,
+    cache: RelevantNewsResponseCache,
+    tavily_storage: TavilyStorage | None = None,
+) -> RelevantNews | None:
+    cached = cache.find(question=question, days_ago=days_ago)
+
+    if isinstance(cached, NoRelevantNews):
+        return None
+    elif cached is None:
+        relevant_news = get_certified_relevant_news_since(
+            question=question,
+            days_ago=days_ago,
+            tavily_storage=tavily_storage,
+        )
+        cache.save(
+            question=question,
+            days_ago=days_ago,
+            relevant_news=relevant_news,
+        )
+        return relevant_news
+    else:
+        return cached

prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py

@@ -0,0 +1,90 @@
+from datetime import datetime, timedelta
+
+from pydantic import ValidationError
+from sqlmodel import Field, Session, SQLModel, create_engine, desc, select
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.relevant_news_analysis.data_models import (
+    NoRelevantNews,
+    RelevantNews,
+)
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+
+class RelevantNewsCacheModel(SQLModel, table=True):
+    __tablename__ = "relevant_news_response_cache"
+    __table_args__ = {"extend_existing": True}
+    id: int | None = Field(default=None, primary_key=True)
+    question: str = Field(index=True)
+    datetime_: datetime = Field(index=True)
+    days_ago: int
+    json_dump: str | None
+
+
+class RelevantNewsResponseCache:
+    def __init__(self, sqlalchemy_db_url: str | None = None):
+        self.engine = create_engine(
+            sqlalchemy_db_url
+            if sqlalchemy_db_url
+            else APIKeys().sqlalchemy_db_url.get_secret_value()
+        )
+        self._initialize_db()
+
+    def _initialize_db(self) -> None:
+        """
+        Creates the tables if they don't exist
+        """
+        with self.engine.connect() as conn:
+            SQLModel.metadata.create_all(
+                conn,
+                tables=[SQLModel.metadata.tables[RelevantNewsCacheModel.__tablename__]],
+            )
+
+    def find(
+        self,
+        question: str,
+        days_ago: int,
+    ) -> RelevantNews | NoRelevantNews | None:
+        with Session(self.engine) as session:
+            query = (
+                select(RelevantNewsCacheModel)
+                .where(RelevantNewsCacheModel.question == question)
+                .where(RelevantNewsCacheModel.days_ago <= days_ago)
+                .where(
+                    RelevantNewsCacheModel.datetime_ >= utcnow() - timedelta(days=1)
+                )  # Cache entries expire after 1 day
+            )
+            item = session.exec(
+                query.order_by(desc(RelevantNewsCacheModel.datetime_))
+            ).first()
+
+            if item is None:
+                return None
+            else:
+                if item.json_dump is None:
+                    return NoRelevantNews()
+                else:
+                    try:
+                        return RelevantNews.model_validate_json(item.json_dump)
+                    except ValidationError as e:
+                        logger.error(
+                            f"Error deserializing RelevantNews from cache for {question=}, {days_ago=} and {item=}: {e}"
+                        )
+                        return None
+
+    def save(
+        self,
+        question: str,
+        days_ago: int,
+        relevant_news: RelevantNews | None,
+    ) -> None:
+        with Session(self.engine) as session:
+            cached = RelevantNewsCacheModel(
+                question=question,
+                days_ago=days_ago,
+                datetime_=utcnow(),  # Assumes that the cache is being updated at the time the news is found
+                json_dump=relevant_news.model_dump_json() if relevant_news else None,
+            )
+            session.add(cached)
+            session.commit()

prediction_market_agent_tooling/tools/safe.py

@@ -1,16 +1,16 @@
 from eth_account.signers.local import LocalAccount
 from eth_typing import ChecksumAddress
-from gnosis.eth import EthereumClient
-from gnosis.eth.constants import NULL_ADDRESS
-from gnosis.eth.contracts import get_safe_V1_4_1_contract
-from gnosis.safe.proxy_factory import ProxyFactoryV141
-from gnosis.safe.safe import Safe
 from safe_cli.safe_addresses import (
     get_default_fallback_handler_address,
     get_proxy_factory_address,
     get_safe_contract_address,
     get_safe_l2_contract_address,
 )
+from safe_eth.eth import EthereumClient
+from safe_eth.eth.constants import NULL_ADDRESS
+from safe_eth.eth.contracts import get_safe_V1_4_1_contract
+from safe_eth.safe.proxy_factory import ProxyFactoryV141
+from safe_eth.safe.safe import SafeV141
 from web3.types import Wei
 
 from prediction_market_agent_tooling.loggers import logger
@@ -87,7 +87,7 @@ def create_safe(
 
     # We ignore mypy below because using the proper class SafeV141 yields an error and mypy
     # doesn't understand that there is a hacky factory method (__new__) on this abstract class.
-    safe_version = Safe(safe_contract_address, ethereum_client).retrieve_version()  # type: ignore
+    safe_version = SafeV141(safe_contract_address, ethereum_client).retrieve_version()
     logger.info(
         f"Safe-master-copy={safe_contract_address} version={safe_version}\n"
         f"Fallback-handler={fallback_handler}\n"

prediction_market_agent_tooling/tools/tavily/tavily_search.py

@@ -33,6 +33,11 @@ def tavily_search(
 
     Argument default values are different from the original method, to return everything by default, because it can be handy in the future and it doesn't increase the costs.
     """
+    if topic == "news" and days is None:
+        raise ValueError("When topic is 'news', days must be an integer")
+    if topic == "general" and days is not None:
+        raise ValueError("When topic is 'general', days must be None")
+
     if tavily_storage and (
         response_parsed := tavily_storage.find(
             query=query,
@@ -103,11 +108,15 @@ def _tavily_search(
     tavily = TavilyClient(
         api_key=(api_keys or APIKeys()).tavily_api_key.get_secret_value()
     )
+
+    # Optional `days` arg can only be specified if not None, otherwise Tavily
+    # will throw an error
+    kwargs = {"days": days} if days else {}
+
     response: dict[str, t.Any] = tavily.search(
         query=query,
         search_depth=search_depth,
         topic=topic,
-        days=days,
         max_results=max_results,
         include_domains=include_domains,
         exclude_domains=exclude_domains,
@@ -115,11 +124,12 @@ def _tavily_search(
         include_raw_content=include_raw_content,
         include_images=include_images,
         use_cache=use_cache,
+        **kwargs,
     )
     return response
 
 
-def get_related_news_since(
+def get_relevant_news_since(
     question: str,
     days_ago: int,
     score_threshold: float = DEFAULT_SCORE_THRESHOLD,

prediction_market_agent_tooling/tools/web3_utils.py

@@ -5,9 +5,9 @@ import base58
 import tenacity
 from eth_account import Account
 from eth_typing import URI
-from gnosis.eth import EthereumClient
-from gnosis.safe.safe import Safe
 from pydantic.types import SecretStr
+from safe_eth.eth import EthereumClient
+from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
 from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt, Wei
@@ -200,7 +200,7 @@ def send_function_on_contract_tx(
     # Don't retry on `reverted` messages, as they would always fail again.
     retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
     wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
-    stop=tenacity.stop_after_attempt(9),
+    stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx_using_safe failed, {x.attempt_number=}."
     ),
@@ -219,7 +219,7 @@ def send_function_on_contract_tx_using_safe(
     if not web3.provider.endpoint_uri:  # type: ignore
         raise EnvironmentError("RPC_URL not available in web3 object.")
     ethereum_client = EthereumClient(ethereum_node_url=URI(web3.provider.endpoint_uri))  # type: ignore
-    s = Safe(safe_address, ethereum_client)  # type: ignore
+    s = SafeV141(safe_address, ethereum_client)
     safe_master_copy_address = s.retrieve_master_copy_address()
     eoa_public_key = private_key_to_public_key(from_private_key)
     # See https://ethereum.stackexchange.com/questions/123750/how-to-implement-eip-2930-access-list for details,

{prediction_market_agent_tooling-0.54.0.dist-info → prediction_market_agent_tooling-0.55.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.54.0
+Version: 0.55.1
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -38,13 +38,13 @@ Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: safe-cli (>=1.0.0,<2.0.0)
-Requires-Dist: safe-eth-py (>=6.0.0b14,<7.0.0)
+Requires-Dist: safe-eth-py (>=6.0.0b41,<7.0.0)
 Requires-Dist: scikit-learn (>=1.3.1,<2.0.0)
 Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)
 Requires-Dist: subgrounds (>=1.9.1,<2.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: tavily-python (>=0.3.9,<0.4.0)
+Requires-Dist: tavily-python (>=0.5.0,<0.6.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Requires-Dist: typer (>=0.9.0,<1.0.0)
 Requires-Dist: types-python-dateutil (>=2.9.0.20240906,<3.0.0.0)

{prediction_market_agent_tooling-0.54.0.dist-info → prediction_market_agent_tooling-0.55.1.dist-info}/RECORD

@@ -16,21 +16,22 @@ prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-
 prediction_market_agent_tooling/benchmark/agents.py,sha256=B1-uWdyeN4GGKMWGK_-CcAFJg1m9Y_XuaeIHPB29QR8,3971
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=MqTiaaJ3cYiOLUVR7OyImLWxcEya3Rl5JyFYW-K0lwM,17097
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
-prediction_market_agent_tooling/config.py,sha256=WC30Nr16RGueTafA9i67OIB-6KDHZRryhiLPzebg9_I,6740
-prediction_market_agent_tooling/deploy/agent.py,sha256=OAfD9B0rN6k3eISvRFJpHTS_dW4yMM2GlTvG8FMejd8,19232
+prediction_market_agent_tooling/config.py,sha256=114f3V9abaok27p5jX3UVr5b5gRUiSxBIYn8Snid34I,6731
+prediction_market_agent_tooling/deploy/agent.py,sha256=s3XVNeuJ9mtlfsRB1RWLWUR0q9fMoptZqu1u-I6oiws,22420
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=egarsbIiFDwCLQ0YtqzP3jdht2_PfhlT0yAmwYGJ10o,13009
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=kMrIE3wMv_IB6nJd_1DmDXDkEZhsXFOgyTd7JZ0gqHI,13068
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=OsPboCFGiZKsvGyntGZHwdqPlLTthITkNF5rJFvGgU8,2582
 prediction_market_agent_tooling/deploy/gcp/utils.py,sha256=oyW0jgrUT2Tr49c7GlpcMsYNQjoCSOcWis3q-MmVAhU,6089
+prediction_market_agent_tooling/deploy/trade_interval.py,sha256=Xk9j45alQ_vrasGvsNyuW70XHIQ7wfvjoxNR3F6HYCw,1155
 prediction_market_agent_tooling/gtypes.py,sha256=tqp03PyY0Yhievl4XELfwAn0xOoecaTvBZ1Co6b-A7o,2541
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/jobs/jobs.py,sha256=I07yh0GJ-xhlvQaOUQB8xlSnihhcbU2c7DZ4ZND14c0,1246
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=I5uBTHJ2S1Wi3H4jDxxU7nsswSIP9r3BevHmljLh5Pg,1370
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=I2_vGrEJj1reSI8M377ab5QCsYNp_l4l4QeYEmDBkFM,3989
 prediction_market_agent_tooling/loggers.py,sha256=Am6HHXRNO545BO3l7Ue9Wb2TkYE1OK8KKhGbI3XypVU,3751
-prediction_market_agent_tooling/markets/agent_market.py,sha256=A72Lf7bdFOTelLhUTSHmfLBOuTZ8b0Qd_IJIgdjzeB0,12470
+prediction_market_agent_tooling/markets/agent_market.py,sha256=OgB6bvDGfTAxbh6cDGD3XFO0iy0MAaOQvXEP6nw8xW8,12817
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
 prediction_market_agent_tooling/markets/data_models.py,sha256=jMqrSFO_w2z-5N3PFVgZqTHdVdkzSDhhzky2lHsGGKA,3621
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -41,11 +42,11 @@ prediction_market_agent_tooling/markets/manifold/utils.py,sha256=cPPFWXm3vCYH1jy
 prediction_market_agent_tooling/markets/market_fees.py,sha256=Q64T9uaJx0Vllt0BkrPmpMEz53ra-hMVY8Czi7CEP7s,1227
 prediction_market_agent_tooling/markets/markets.py,sha256=mwubc567OIlA32YKqlIdTloYV8FGJia9gPv0wE0xUEA,3368
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
-prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=2wDZ0BmK9O5Lud-q-FCzgW0tsK9GxMU0rUMlcPxSS04,3184
-prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=d5tHhekLfPGO6CfmWWJQWpJu5HyoAWBM2aGSR874Cms,3695
+prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=Suxa7xELdYuFNKqvGvFh8qyfVtAg79E-vaQ6dqNZOtA,3261
+prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=E_TUf5q73lWzdMp40Ne-3w4MjEd7AHcaif4pvFh9FMU,4360
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=nCjsc-ylIzQOCK_1BW-5NoYrS-NIXz2Hg9N1-IqhhC8,27516
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=-9u8Tb3ADGy7vd0E0peTV8OqQi9zMaXBa4b0gJXpQpc,50773
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=LqNZjngo6LoktKecfYmGmJJ9D5rj-s0Poy4x4_GZfp0,51116
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=Zq7SncCq-hvpgXKsVruGBGCn1OhKZTe7r1qLdCTrT2w,28297
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=iDWdjICGkt968exwCjY-6nsnQyrrNAg3YjnDdP430GQ,9415
 prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=zQH3iu0SVH1RmE-W3NMEpcKVMILXJYxMhL6w1wh5RUo,37348
@@ -79,22 +80,25 @@ prediction_market_agent_tooling/tools/httpx_cached_client.py,sha256=0-N1r0zcGKlY
 prediction_market_agent_tooling/tools/image_gen/image_gen.py,sha256=HzRwBx62hOXBOmrtpkXaP9Qq1Ku03uUGdREocyjLQ_k,1266
 prediction_market_agent_tooling/tools/image_gen/market_thumbnail_gen.py,sha256=8A3U2uxsCsOfLjru-6R_PPIAuiKY4qFkWp_GSBPV6-s,1280
 prediction_market_agent_tooling/tools/ipfs/ipfs_handler.py,sha256=CTTMfTvs_8PH4kAtlQby2aeEKwgpmxtuGbd4oYIdJ2A,1201
-prediction_market_agent_tooling/tools/is_invalid.py,sha256=Lc5fWB4fmx7tFvRakmUOzo0Oq5EizorddZ2xjesEopY,4984
+prediction_market_agent_tooling/tools/is_invalid.py,sha256=VjjOCrkt6S8ytOg_0s2gUL8IKX2muWq1QLIZX0MPMxY,5094
 prediction_market_agent_tooling/tools/is_predictable.py,sha256=NIoR2bTNMmADcyNY2aKNMWkiDw7Z_9kZMcFXEdyewy4,6771
 prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_AeDVhRzLMaQLxH3kxDu3L8,1153
 prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=B0PhAQyviFnVbtOCYMxYmcCn66cu9nbqAOIAZcdgiRI,5771
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
-prediction_market_agent_tooling/tools/safe.py,sha256=h0xOO0eNtitClf0fPkn-0oTc6A_bflDTee98V_aiV-A,5195
+prediction_market_agent_tooling/tools/relevant_news_analysis/data_models.py,sha256=95l84aztFaxcRLLcRQ46yKJbIlOEuDAbIGLouyliDzA,1316
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_analysis.py,sha256=OWLzwCbQS2b9hjwTRXTOjjplWXcGXFf3yjKEeK4kGbQ,5720
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=2yxtBIDyMT_6CsTpZyuIv_2dy2B9WgEOaTT1fSloBu0,3223
+prediction_market_agent_tooling/tools/safe.py,sha256=9vxGGLvSPnfy-sxUFDpBTe8omqpGXP7MzvGPp6bRxrU,5197
 prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0rnVhtQGzwoUdAgn_7u_GBM,729
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=Rz4tZzwCRzPaq49SFT33SCRQrqHXtqWdD9ajb2tGCWc,2723
-prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=MK_ozeQbJ014HGiKFPDScjFYq0OGcjY1KPgc9A6qO0M,4511
+prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=UPSp0S5Sql52X6UlU2Ki_iO-gmDJSMs5enn9AV_IZRM,4896
 prediction_market_agent_tooling/tools/tavily/tavily_storage.py,sha256=t-tZzbCzBBdFedRZDuVBn3A3mIDX8Z5wza6SxWswu_E,4093
 prediction_market_agent_tooling/tools/utils.py,sha256=W-9SqeCKd51BYMRhDjYPQ7lfNO_zE9EvYpmu2r5WXGA,7163
-prediction_market_agent_tooling/tools/web3_utils.py,sha256=dkcjG-LtuaWRh7WEMzRGmZ5B5rsxZTlliFOI6fj-EJ8,11842
-prediction_market_agent_tooling-0.54.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.54.0.dist-info/METADATA,sha256=iAGimZ2Kjtbx94FpzKsdYXKvhFO9e3Bd6xaAG5eQVg4,8056
-prediction_market_agent_tooling-0.54.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-prediction_market_agent_tooling-0.54.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.54.0.dist-info/RECORD,,
+prediction_market_agent_tooling/tools/web3_utils.py,sha256=44W8siSLNQxeib98bbwAe7V5C609NHNlUuxwuWIRDiY,11838
+prediction_market_agent_tooling-0.55.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.55.1.dist-info/METADATA,sha256=chzNuISP7K3sgt_Mj0fFX6bQu9JFkOXTvYgmqaLFcMU,8056
+prediction_market_agent_tooling-0.55.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.55.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.55.1.dist-info/RECORD,,