prediction-market-agent-tooling 0.56.3__tar.gz → 0.57.0__tar.gz

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.56.3
+Version: 0.57.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/config.py

@@ -1,5 +1,6 @@
 import typing as t
 
+from pydantic import Field
 from pydantic.types import SecretStr
 from pydantic.v1.types import SecretStr as SecretStrV1
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -7,6 +8,7 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 
 from prediction_market_agent_tooling.gtypes import (
+    ChainID,
     ChecksumAddress,
     PrivateKey,
     secretstr_to_v1_secretstr,
@@ -203,3 +205,30 @@ class APIKeys(BaseSettings):
         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)
+
+
+class RPCConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env", env_file_encoding="utf-8", extra="ignore"
+    )
+
+    GNOSIS_RPC_URL: str = Field(default="https://rpc.gnosischain.com")
+    CHAIN_ID: ChainID = Field(default=ChainID(100))
+
+    @property
+    def gnosis_rpc_url(self) -> str:
+        return check_not_none(
+            self.GNOSIS_RPC_URL, "GNOSIS_RPC_URL missing in the environment."
+        )
+
+    @property
+    def chain_id(self) -> ChainID:
+        return check_not_none(self.CHAIN_ID, "CHAIN_ID missing in the environment.")
+
+
+class CloudCredentials(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env", env_file_encoding="utf-8", extra="ignore"
+    )
+
+    GOOGLE_APPLICATION_CREDENTIALS: t.Optional[str] = None

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -8,8 +8,7 @@ from datetime import timedelta
 from enum import Enum
 from functools import cached_property
 
-from pydantic import BeforeValidator, computed_field
-from typing_extensions import Annotated
+from pydantic import computed_field
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
@@ -69,27 +68,6 @@ from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, ob
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
 
 MAX_AVAILABLE_MARKETS = 20
-TRADER_TAG = "trader"
-
-
-def to_boolean_outcome(value: str | bool) -> bool:
-    if isinstance(value, bool):
-        return value
-
-    elif isinstance(value, str):
-        value = value.lower().strip()
-
-        if value in {"true", "yes", "y", "1"}:
-            return True
-
-        elif value in {"false", "no", "n", "0"}:
-            return False
-
-        else:
-            raise ValueError(f"Expected a boolean string, but got {value}")
-
-    else:
-        raise ValueError(f"Expected a boolean or a string, but got {value}")
 
 
 def initialize_langfuse(enable_langfuse: bool) -> None:
@@ -107,15 +85,21 @@ def initialize_langfuse(enable_langfuse: bool) -> None:
         langfuse_context.configure(enabled=enable_langfuse)
 
 
-Decision = Annotated[bool, BeforeValidator(to_boolean_outcome)]
-
-
 class AnsweredEnum(str, Enum):
     ANSWERED = "answered"
     NOT_ANSWERED = "not_answered"
 
 
+class AgentTagEnum(str, Enum):
+    PREDICTOR = "predictor"
+    TRADER = "trader"
+
+
 class DeployableAgent:
+    """
+    Subclass this class to create agent with standardized interface.
+    """
+
     def __init__(
         self,
         enable_langfuse: bool = APIKeys().default_enable_langfuse,
@@ -176,20 +160,25 @@ class DeployableAgent:
             )
 
     def load(self) -> None:
-        pass
+        """
+        Implement this method to load arbitrary instances needed across the whole run of the agent.
+
+        Do not customize __init__ method.
+        """
 
     def deploy_local(
         self,
         market_type: MarketType,
         sleep_time: float,
-        timeout: float,
+        run_time: float | None,
     ) -> None:
+        """
+        Run the agent in the forever cycle every `sleep_time` seconds, until the `run_time` is met.
+        """
         start_time = time.time()
-        while True:
+        while run_time is None or time.time() - start_time < run_time:
             self.run(market_type=market_type)
             time.sleep(sleep_time)
-            if time.time() - start_time > timeout:
-                break
 
     def deploy_gcp(
         self,
@@ -205,6 +194,9 @@ class DeployableAgent:
         start_time: DatetimeUTC | None = None,
         timeout: int = 180,
     ) -> None:
+        """
+        Deploy the agent as GCP Function.
+        """
         path_to_agent_file = os.path.relpath(inspect.getfile(self.__class__))
 
         entrypoint_function_name = "main"
@@ -271,6 +263,9 @@ def {entrypoint_function_name}(request) -> str:
             schedule_deployed_gcp_function(fname, cron_schedule=cron_schedule)
 
     def run(self, market_type: MarketType) -> None:
+        """
+        Run single iteration of the agent.
+        """
         raise NotImplementedError("This method must be implemented by the subclass.")
 
     def get_gcloud_fname(self, market_type: MarketType) -> str:
@@ -278,6 +273,14 @@ def {entrypoint_function_name}(request) -> str:
 
 
 class DeployablePredictionAgent(DeployableAgent):
+    """
+    Subclass this class to create your own prediction market agent.
+
+    The agent will process markets and make predictions.
+    """
+
+    AGENT_TAG: AgentTagEnum = AgentTagEnum.PREDICTOR
+
     bet_on_n_markets_per_run: int = 1
 
     # Agent behaviour when fetching markets
@@ -297,10 +300,10 @@ class DeployablePredictionAgent(DeployableAgent):
     def __init__(
         self,
         enable_langfuse: bool = APIKeys().default_enable_langfuse,
-        store_prediction: bool = True,
+        store_predictions: bool = True,
     ) -> None:
         super().__init__(enable_langfuse=enable_langfuse)
-        self.store_prediction = store_prediction
+        self.store_predictions = store_predictions
 
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
@@ -328,7 +331,7 @@ class DeployablePredictionAgent(DeployableAgent):
     ) -> None:
         self.langfuse_update_current_trace(
             tags=[
-                TRADER_TAG,
+                self.AGENT_TAG,
                 (
                     AnsweredEnum.ANSWERED
                     if processed_market is not None
@@ -386,6 +389,9 @@ class DeployablePredictionAgent(DeployableAgent):
         self,
         market_type: MarketType,
     ) -> t.Sequence[AgentMarket]:
+        """
+        Override this method to customize what markets will fetch for processing.
+        """
         cls = market_type.market_class
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_binary_markets(
@@ -399,6 +405,9 @@ class DeployablePredictionAgent(DeployableAgent):
     def before_process_market(
         self, market_type: MarketType, market: AgentMarket
     ) -> None:
+        """
+        Executed before processing of each market.
+        """
         api_keys = APIKeys()
 
         if market_type.is_blockchain_market:
@@ -442,19 +451,22 @@ class DeployablePredictionAgent(DeployableAgent):
         market: AgentMarket,
         processed_market: ProcessedMarket | None,
     ) -> None:
+        """
+        Executed after processing of each market.
+        """
         keys = APIKeys()
-        if self.store_prediction:
+        if self.store_predictions:
             market.store_prediction(
                 processed_market=processed_market, keys=keys, agent_name=self.agent_name
             )
         else:
             logger.info(
-                f"Prediction {processed_market} not stored because {self.store_prediction=}."
+                f"Prediction {processed_market} not stored because {self.store_predictions=}."
             )
 
     def before_process_markets(self, market_type: MarketType) -> None:
         """
-        Executes actions that occur before bets are placed.
+        Executed before market processing loop starts.
         """
         api_keys = APIKeys()
         self.check_min_required_balance_to_operate(market_type)
@@ -485,7 +497,9 @@ class DeployablePredictionAgent(DeployableAgent):
         logger.info("All markets processed.")
 
     def after_process_markets(self, market_type: MarketType) -> None:
-        "Executes actions that occur after bets are placed."
+        """
+        Executed after market processing loop ends.
+        """
 
     def run(self, market_type: MarketType) -> None:
         if market_type not in self.supported_markets:
@@ -498,6 +512,14 @@ class DeployablePredictionAgent(DeployableAgent):
 
 
 class DeployableTraderAgent(DeployablePredictionAgent):
+    """
+    Subclass this class to create your own prediction market trading agent.
+
+    The agent will process markets, make predictions and place trades (bets) based off these predictions.
+    """
+
+    AGENT_TAG: AgentTagEnum = AgentTagEnum.TRADER
+
     # These markets require place of bet, not just predictions.
     supported_markets: t.Sequence[MarketType] = [
         MarketType.OMEN,
@@ -508,12 +530,12 @@ class DeployableTraderAgent(DeployablePredictionAgent):
     def __init__(
         self,
         enable_langfuse: bool = APIKeys().default_enable_langfuse,
-        store_prediction: bool = True,
+        store_predictions: bool = True,
         store_trades: bool = True,
         place_trades: bool = True,
     ) -> None:
         super().__init__(
-            enable_langfuse=enable_langfuse, store_prediction=store_prediction
+            enable_langfuse=enable_langfuse, store_predictions=store_predictions
         )
         self.store_trades = store_trades
         self.place_trades = place_trades
@@ -537,6 +559,11 @@ class DeployableTraderAgent(DeployablePredictionAgent):
             )
 
     def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
+        """
+        Override this method to customize betting strategy of your agent.
+
+        Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
+        """
         user_id = market.get_user_id(api_keys=APIKeys())
 
         total_amount = market.get_tiny_bet_amount().amount

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/markets/data_models.py

@@ -140,3 +140,24 @@ class PlacedTrade(Trade):
             amount=trade.amount,
             id=id,
         )
+
+
+class SimulationDetail(BaseModel):
+    strategy: str
+    url: str
+    market_p_yes: float
+    agent_p_yes: float
+    agent_conf: float
+    org_bet: float
+    sim_bet: float
+    org_dir: bool
+    sim_dir: bool
+    org_profit: float
+    sim_profit: float
+    timestamp: DatetimeUTC
+
+
+class SharpeOutput(BaseModel):
+    annualized_volatility: float
+    mean_daily_return: float
+    annualized_sharpe_ratio: float

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -200,7 +200,6 @@ class ManifoldBet(BaseModel):
             if self.get_resolved_boolean_outcome() == market_outcome
             else -self.amount
         )
-        profit -= self.fees.get_total()
         return ProfitAmount(
             amount=profit,
             currency=Currency.Mana,

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/markets/omen/data_models.py

@@ -531,7 +531,6 @@ class OmenBet(BaseModel):
             if self.boolean_outcome == self.fpmm.boolean_outcome
             else -bet_amount_xdai
         )
-        profit -= wei_to_xdai(self.feeAmount)
         return ProfitAmount(
             amount=profit,
             currency=Currency.xDai,
@@ -539,9 +538,8 @@ class OmenBet(BaseModel):
 
     def to_bet(self) -> Bet:
         return Bet(
-            id=str(
-                self.transactionHash
-            ),  # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
+            id=str(self.transactionHash),
+            # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
@@ -556,9 +554,8 @@ class OmenBet(BaseModel):
             )
 
         return ResolvedBet(
-            id=str(
-                self.transactionHash
-            ),  # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
+            id=self.transactionHash.hex(),
+            # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -435,10 +435,14 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         omen_markets = self.do_query(fields=fields, pydantic_model=OmenMarket)
         return omen_markets
 
-    def get_omen_market_by_market_id(self, market_id: HexAddress) -> OmenMarket:
-        markets = self.trades_subgraph.Query.fixedProductMarketMaker(
-            id=market_id.lower()
-        )
+    def get_omen_market_by_market_id(
+        self, market_id: HexAddress, block_number: int | None = None
+    ) -> OmenMarket:
+        query_filters: dict[str, t.Any] = {"id": market_id.lower()}
+        if block_number:
+            query_filters["block"] = {"number": block_number}
+
+        markets = self.trades_subgraph.Query.fixedProductMarketMaker(**query_filters)
 
         fields = self._get_fields_for_markets(markets)
         omen_markets = self.do_query(fields=fields, pydantic_model=OmenMarket)

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/markets/polymarket/utils.py

@@ -3,7 +3,7 @@ from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
     PolymarketFullMarket,
 )
-from prediction_market_agent_tooling.tools.google import search_google
+from prediction_market_agent_tooling.tools.google_utils import search_google
 
 
 def find_resolution_on_polymarket(question: str) -> Resolution | None:

prediction_market_agent_tooling-0.57.0/prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py

@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+
+from prediction_market_agent_tooling.markets.data_models import (
+    SharpeOutput,
+    SimulationDetail,
+)
+
+
+class SharpeRatioCalculator:
+    def __init__(
+        self, details: list[SimulationDetail], risk_free_rate: float = 0.0
+    ) -> None:
+        self.details = details
+        self.df = pd.DataFrame([d.model_dump() for d in self.details])
+        self.risk_free_rate = risk_free_rate
+
+    def __has_df_valid_columns_else_exception(
+        self, required_columns: list[str]
+    ) -> None:
+        if not set(required_columns).issubset(self.df.columns):
+            raise ValueError("Dataframe doesn't contain all the required columns.")
+
+    def prepare_wallet_daily_balance_df(
+        self, timestamp_col_name: str, profit_col_name: str
+    ) -> pd.DataFrame:
+        self.__has_df_valid_columns_else_exception(
+            [timestamp_col_name, profit_col_name]
+        )
+        df = self.df.copy()
+        df[timestamp_col_name] = pd.to_datetime(df[timestamp_col_name])
+        df.sort_values(timestamp_col_name, ascending=True, inplace=True)
+
+        df["profit_cumsum"] = df[profit_col_name].cumsum()
+        df["profit_cumsum"] = df["profit_cumsum"] + 50
+
+        df = df.drop_duplicates(subset=timestamp_col_name, keep="last")
+        df.set_index(timestamp_col_name, inplace=True)
+        # We generate a new Dataframe with daily wallet balances, derived by the final wallet balance
+        # from the previous day.
+        wallet_balance_daily_df = df[["profit_cumsum"]].resample("D").ffill()
+        wallet_balance_daily_df.dropna(inplace=True)
+        wallet_balance_daily_df["returns"] = wallet_balance_daily_df[
+            "profit_cumsum"
+        ].pct_change()
+        return wallet_balance_daily_df
+
+    def calculate_annual_sharpe_ratio(
+        self, timestamp_col_name: str = "timestamp", profit_col_name: str = "sim_profit"
+    ) -> SharpeOutput:
+        wallet_daily_balance_df = self.prepare_wallet_daily_balance_df(
+            timestamp_col_name=timestamp_col_name, profit_col_name=profit_col_name
+        )
+
+        daily_volatility = wallet_daily_balance_df["returns"].std()
+        annualized_volatility = daily_volatility * np.sqrt(365)
+        mean_daily_return = wallet_daily_balance_df["returns"].mean()
+        daily_sharpe_ratio = (
+            mean_daily_return - self.risk_free_rate
+        ) / daily_volatility
+        annualized_sharpe_ratio = daily_sharpe_ratio * np.sqrt(365)
+        return SharpeOutput(
+            annualized_volatility=annualized_volatility,
+            mean_daily_return=mean_daily_return,
+            annualized_sharpe_ratio=annualized_sharpe_ratio,
+        )

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/contract.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, field_validator
 from web3 import Web3
 from web3.contract.contract import Contract as Web3Contract
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, RPCConfig
 from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChainID,
@@ -18,10 +18,6 @@ from prediction_market_agent_tooling.gtypes import (
     TxReceipt,
     Wei,
 )
-from prediction_market_agent_tooling.tools.gnosis_rpc import (
-    GNOSIS_NETWORK_ID,
-    GNOSIS_RPC_URL,
-)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, should_not_happen
 from prediction_market_agent_tooling.tools.web3_utils import (
     call_function_on_contract,
@@ -391,8 +387,8 @@ class ContractOnGnosisChain(ContractBaseClass):
     Contract base class with Gnosis Chain configuration.
     """
 
-    CHAIN_ID = GNOSIS_NETWORK_ID
-    CHAIN_RPC_URL = GNOSIS_RPC_URL
+    CHAIN_ID = RPCConfig().chain_id
+    CHAIN_RPC_URL = RPCConfig().gnosis_rpc_url
 
 
 class ContractProxyOnGnosisChain(ContractProxyBaseClass, ContractOnGnosisChain):

prediction_market_agent_tooling-0.56.3/prediction_market_agent_tooling/tools/google.py → prediction_market_agent_tooling-0.57.0/prediction_market_agent_tooling/tools/google_utils.py

@@ -1,10 +1,14 @@
+import json
 import typing as t
 from datetime import timedelta
 
 import tenacity
+from google.cloud import secretmanager
 from googleapiclient.discovery import build
+from pydantic import SecretStr
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, CloudCredentials
+from prediction_market_agent_tooling.gtypes import PrivateKey
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.caches.db_cache import db_cache
 
@@ -51,3 +55,26 @@ def search_google(
         )
     except KeyError as e:
         raise ValueError(f"Can not parse results: {search}") from e
+
+
+def get_private_key_from_gcp_secret(
+    secret_id: str,
+    project_id: str = "582587111398",  # Gnosis AI default project_id
+    version_id: str = "latest",
+) -> PrivateKey:
+    # If credentials filename specified, use that, else read using default credentials path.
+    google_application_credentials_filename = (
+        CloudCredentials().GOOGLE_APPLICATION_CREDENTIALS
+    )
+    if google_application_credentials_filename is not None:
+        # mypy interprets incorrectly that from_service_account_json requires further args.
+        client = secretmanager.SecretManagerServiceClient.from_service_account_json(filename=google_application_credentials_filename)  # type: ignore [call-arg]
+    else:
+        client = secretmanager.SecretManagerServiceClient()
+    name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}"
+    response = client.access_secret_version(request={"name": name})
+    secret_payload = response.payload.data.decode("UTF-8")
+    secret_json = json.loads(secret_payload)
+    if "private_key" not in secret_json:
+        raise ValueError(f"Private key not found in gcp secret {secret_id}")
+    return PrivateKey(SecretStr(secret_json["private_key"]))

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/image_gen/market_thumbnail_gen.py

@@ -17,7 +17,7 @@ def rewrite_question_into_image_generation_prompt(question: str) -> str:
             "openai not installed, please install extras `langchain` to use this function."
         )
     llm = ChatOpenAI(
-        model="gpt-4-turbo",
+        model="gpt-4o-2024-08-06",
         temperature=0.0,
         api_key=APIKeys().openai_api_key_secretstr_v1,
     )

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/is_invalid.py

@@ -60,7 +60,7 @@ Finally, write your final decision, write `decision: ` followed by either "yes i
 @db_cache
 def is_invalid(
     question: str,
-    engine: str = "gpt-4o",
+    engine: str = "gpt-4o-2024-08-06",
     temperature: float = LLM_SUPER_LOW_TEMPERATURE,
     seed: int = LLM_SEED,
     prompt_template: str = QUESTION_IS_INVALID_PROMPT,

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/is_predictable.py

@@ -7,7 +7,10 @@ from prediction_market_agent_tooling.tools.langfuse_ import (
     get_langfuse_langchain_config,
     observe,
 )
-from prediction_market_agent_tooling.tools.utils import LLM_SUPER_LOW_TEMPERATURE
+from prediction_market_agent_tooling.tools.utils import (
+    LLM_SEED,
+    LLM_SUPER_LOW_TEMPERATURE,
+)
 
 # I tried to make it return a JSON, but it didn't work well in combo with asking it to do chain of thought.
 QUESTION_IS_PREDICTABLE_BINARY_PROMPT = """Main signs about a fully qualified question (sometimes referred to as a "market"):
@@ -81,7 +84,7 @@ Finally, write your final decision, write `decision: ` followed by either "yes i
 @db_cache
 def is_predictable_binary(
     question: str,
-    engine: str = "gpt-4-1106-preview",
+    engine: str = "gpt-4o-2024-08-06",
     prompt_template: str = QUESTION_IS_PREDICTABLE_BINARY_PROMPT,
     max_tokens: int = 1024,
 ) -> bool:
@@ -98,6 +101,7 @@ def is_predictable_binary(
     llm = ChatOpenAI(
         model=engine,
         temperature=LLM_SUPER_LOW_TEMPERATURE,
+        seed=LLM_SEED,
         api_key=APIKeys().openai_api_key_secretstr_v1,
     )
 
@@ -118,7 +122,7 @@ def is_predictable_binary(
 def is_predictable_without_description(
     question: str,
     description: str,
-    engine: str = "gpt-4-1106-preview",
+    engine: str = "gpt-4o-2024-08-06",
     prompt_template: str = QUESTION_IS_PREDICTABLE_WITHOUT_DESCRIPTION_PROMPT,
     max_tokens: int = 1024,
 ) -> bool:
@@ -137,6 +141,7 @@ def is_predictable_without_description(
     llm = ChatOpenAI(
         model=engine,
         temperature=LLM_SUPER_LOW_TEMPERATURE,
+        seed=LLM_SEED,
         api_key=APIKeys().openai_api_key_secretstr_v1,
     )
 

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -70,6 +70,7 @@ def get_traces_for_agent(
     page = 1  # index starts from 1
     all_agent_traces = []
     while True:
+        logger.debug(f"fetching page {page}")
         traces = client.fetch_traces(
             name=trace_name,
             limit=100,

prediction_market_agent_tooling-0.57.0/prediction_market_agent_tooling/tools/transaction_cache.py

@@ -0,0 +1,48 @@
+import diskcache as dc
+import tenacity
+from eth_typing import HexStr
+from tenacity import wait_exponential
+from web3 import Web3
+
+from prediction_market_agent_tooling.loggers import logger
+
+
+class TransactionBlockCache:
+    def __init__(self, web3: Web3):
+        self.block_number_cache = dc.Cache("block_cache_dir")
+        self.block_timestamp_cache = dc.Cache("timestamp_cache_dir")
+        self.web3 = web3
+
+    @tenacity.retry(
+        wait=wait_exponential(multiplier=1, min=1, max=4),
+        stop=tenacity.stop_after_attempt(7),
+        after=lambda x: logger.debug(f"fetch tx failed, {x.attempt_number=}."),
+    )
+    def fetch_block_number(self, transaction_hash: str) -> int:
+        tx = self.web3.eth.get_transaction(HexStr(transaction_hash))
+        return tx["blockNumber"]
+
+    @tenacity.retry(
+        wait=wait_exponential(multiplier=1, min=1, max=4),
+        stop=tenacity.stop_after_attempt(7),
+        after=lambda x: logger.debug(f"fetch tx failed, {x.attempt_number=}."),
+    )
+    def fetch_block_timestamp(self, block_number: int) -> int:
+        block = self.web3.eth.get_block(block_number)
+        return block["timestamp"]
+
+    def get_block_number(self, tx_hash: str) -> int:
+        if tx_hash in self.block_number_cache:
+            return int(self.block_number_cache[tx_hash])
+
+        block_number = self.fetch_block_number(tx_hash)
+        self.block_number_cache[tx_hash] = block_number
+        return block_number
+
+    def get_block_timestamp(self, block_number: int) -> int:
+        if block_number in self.block_timestamp_cache:
+            return int(self.block_timestamp_cache[block_number])
+
+        block_timestamp = self.fetch_block_timestamp(block_number)
+        self.block_timestamp_cache[block_number] = block_timestamp
+        return block_timestamp

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/utils.py

@@ -1,4 +1,3 @@
-import json
 import os
 import subprocess
 from datetime import datetime
@@ -6,17 +5,11 @@ from typing import Any, NoReturn, Optional, Type, TypeVar
 
 import pytz
 import requests
-from google.cloud import secretmanager
 from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
 
-from prediction_market_agent_tooling.gtypes import (
-    DatetimeUTC,
-    PrivateKey,
-    Probability,
-    SecretStr,
-)
+from prediction_market_agent_tooling.gtypes import DatetimeUTC, Probability, SecretStr
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 
@@ -214,18 +207,3 @@ def calculate_sell_amount_in_collateral(
 
     amount_to_sell = newton(f, 0)
     return float(amount_to_sell) * 0.999999  # Avoid rounding errors
-
-
-def get_private_key_from_gcp_secret(
-    secret_id: str,
-    project_id: str = "582587111398",  # Gnosis AI default project_id
-    version_id: str = "latest",
-) -> PrivateKey:
-    client = secretmanager.SecretManagerServiceClient()
-    name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}"
-    response = client.access_secret_version(request={"name": name})
-    secret_payload = response.payload.data.decode("UTF-8")
-    secret_json = json.loads(secret_payload)
-    if "private_key" not in secret_json:
-        raise ValueError(f"Private key not found in gcp secret {secret_id}")
-    return PrivateKey(SecretStr(secret_json["private_key"]))

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/prediction_market_agent_tooling/tools/web3_utils.py

@@ -263,7 +263,11 @@ def send_function_on_contract_tx_using_safe(
     )
     safe_tx.sign(from_private_key.get_secret_value())
     safe_tx.call()  # simulate call
-    tx_hash, tx = safe_tx.execute(from_private_key.get_secret_value())
+    eoa_nonce = web3.eth.get_transaction_count(eoa_public_key)
+    tx_hash, tx = safe_tx.execute(
+        from_private_key.get_secret_value(),
+        tx_nonce=eoa_nonce,
+    )
     receipt_tx = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)
     check_tx_receipt(receipt_tx)
     return receipt_tx

{prediction_market_agent_tooling-0.56.3 → prediction_market_agent_tooling-0.57.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.56.3"
+version = "0.57.0"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"
@@ -65,6 +65,7 @@ mypy = "^1.11.1"
 black = "^23.12.1"
 ape-foundry = "^0.8.2"
 eth-ape = "^0.8.10,<0.8.17"  # 0.8.17 doesn't work with the current configuration and needs a fix, see https://github.com/gnosis/prediction-market-agent-tooling/issues/518.
+diskcache = "^5.6.3"
 
 [build-system]
 requires = ["poetry-core"]

prediction_market_agent_tooling-0.56.3/prediction_market_agent_tooling/tools/gnosis_rpc.py

@@ -1,6 +0,0 @@
-import os
-
-from prediction_market_agent_tooling.gtypes import ChainID
-
-GNOSIS_NETWORK_ID = ChainID(100)  # xDai network.
-GNOSIS_RPC_URL = os.getenv("GNOSIS_RPC_URL", "https://rpc.gnosischain.com")