prediction-market-agent-tooling 0.56.3.dev135__py3-none-any.whl → 0.57.0__py3-none-any.whl

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/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 (
@@ -59,33 +58,16 @@ from prediction_market_agent_tooling.markets.omen.omen import (
 from prediction_market_agent_tooling.monitor.monitor_app import (
     MARKET_TYPE_TO_DEPLOYED_AGENT,
 )
+from prediction_market_agent_tooling.tools.custom_exceptions import (
+    CantPayForGasError,
+    OutOfFundsError,
+)
 from prediction_market_agent_tooling.tools.is_invalid import is_invalid
 from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, observe
 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:
@@ -103,23 +85,21 @@ def initialize_langfuse(enable_langfuse: bool) -> None:
         langfuse_context.configure(enabled=enable_langfuse)
 
 
-Decision = Annotated[bool, BeforeValidator(to_boolean_outcome)]
-
-
-class CantPayForGasError(ValueError):
-    pass
-
-
-class OutOfFundsError(ValueError):
-    pass
-
-
 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,
@@ -180,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,
@@ -209,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"
@@ -275,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:
@@ -282,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
@@ -301,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()
@@ -332,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
@@ -390,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(
@@ -403,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:
@@ -446,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)
@@ -489,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:
@@ -502,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,
@@ -512,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
@@ -541,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/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/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/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/markets/omen/omen.py

@@ -75,6 +75,7 @@ from prediction_market_agent_tooling.tools.contract import (
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
+from prediction_market_agent_tooling.tools.custom_exceptions import OutOfFundsError
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.utils import (
@@ -1339,7 +1340,7 @@ def withdraw_wxdai_to_xdai_to_keep_balance(
     )
 
     if current_balances.wxdai < need_to_withdraw:
-        raise ValueError(
+        raise OutOfFundsError(
             f"Current wxDai balance {current_balances.wxdai} is less than the required minimum wxDai to withdraw {need_to_withdraw}."
         )
 

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/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/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/tools/caches/db_cache.py

@@ -22,7 +22,6 @@ 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.datetime_utc import DatetimeUTC
-from prediction_market_agent_tooling.tools.pickle_utils import InitialiseNonPickable
 from prediction_market_agent_tooling.tools.utils import utcnow
 
 FunctionT = TypeVar("FunctionT", bound=Callable[..., Any])
@@ -91,17 +90,6 @@ def db_cache(
         return decorator
 
     api_keys = api_keys if api_keys is not None else APIKeys()
-    wrapped_engine = InitialiseNonPickable(
-        lambda: create_engine(
-            api_keys.sqlalchemy_db_url.get_secret_value(),
-            # Use custom json serializer and deserializer, because otherwise, for example `datetime` serialization would fail.
-            json_serializer=json_serializer,
-            json_deserializer=json_deserializer,
-        )
-    )
-
-    if api_keys.ENABLE_CACHE:
-        SQLModel.metadata.create_all(wrapped_engine.get_value())
 
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
@@ -109,7 +97,16 @@ def db_cache(
         if not api_keys.ENABLE_CACHE:
             return func(*args, **kwargs)
 
-        engine = wrapped_engine.get_value()
+        engine = create_engine(
+            api_keys.sqlalchemy_db_url.get_secret_value(),
+            # Use custom json serializer and deserializer, because otherwise, for example `datetime` serialization would fail.
+            json_serializer=json_serializer,
+            json_deserializer=json_deserializer,
+            pool_size=1,
+        )
+
+        # Create table if it doesn't exist
+        SQLModel.metadata.create_all(engine)
 
         # Convert *args and **kwargs to a single dictionary, where we have names for arguments passed as args as well.
         signature = inspect.signature(func)
@@ -213,6 +210,7 @@ def db_cache(
                 session.add(cache_entry)
                 session.commit()
 
+        engine.dispose()
         return computed_result
 
     return cast(FunctionT, wrapper)

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/tools/custom_exceptions.py

@@ -0,0 +1,6 @@
+class CantPayForGasError(ValueError):
+    pass
+
+
+class OutOfFundsError(ValueError):
+    pass

prediction_market_agent_tooling/tools/{google.py → 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/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/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/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/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/tools/relevant_news_analysis/relevant_news_cache.py

@@ -25,9 +25,12 @@ class RelevantNewsCacheModel(SQLModel, table=True):
 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()
+            (
+                sqlalchemy_db_url
+                if sqlalchemy_db_url
+                else APIKeys().sqlalchemy_db_url.get_secret_value()
+            ),
+            pool_size=1,
         )
         self._initialize_db()
 

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/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/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.dev135.dist-info → prediction_market_agent_tooling-0.57.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.56.3.dev135
+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.dev135.dist-info → prediction_market_agent_tooling-0.57.0.dist-info}/RECORD

@@ -16,8 +16,8 @@ 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=6iB8A4byexiemUajIw2SzRDQ8E8w0catyg7aH_mHpsY,6732
-prediction_market_agent_tooling/deploy/agent.py,sha256=dpc94DUo8Gq1LdRdw6k78vm_47OeJIfomG9CRVpgzk0,22757
+prediction_market_agent_tooling/config.py,sha256=13qhBE68CZTnHYVDUxGs4yj_d75WM8QqJVg0a-wAoWA,7559
+prediction_market_agent_tooling/deploy/agent.py,sha256=58Ms6wFcRM3yhpdDVT-ohryZhHJNinn1Z4MdrmCMXvM,23627
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
 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
@@ -33,10 +33,10 @@ prediction_market_agent_tooling/loggers.py,sha256=Am6HHXRNO545BO3l7Ue9Wb2TkYE1OK
 prediction_market_agent_tooling/markets/agent_market.py,sha256=W2ME57-CSAhrt8qm8-b5r7yLq-Sk7R_BZMaApvjhrUE,12901
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=IxDTwX4tej9j5olNkXcLIE0RCF1Nh2icZQUT2ERMmZo,1937
 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/data_models.py,sha256=VoEWm338qQMQIRvWpWpDgDjVk9D_3tCHrZPd0Gy0dAA,4033
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=Fd0HYnstvvHO6AZkp1xiRlvCwQUc8kLR8DAj6PAZu0s,7297
-prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=ylXIEHymx2RcCdOVUpKP4BcTqbzLu_Fd5gV1TGBntVk,6099
+prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=eiGS4rEkxseZNpEb2BICKnjF0qqgkQTMuUPbSe7_04I,6059
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=qemQIwuFg4yf6egGWFp9lWpz1lXr02QiBeZ2akcT6II,5026
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=cPPFWXm3vCYH1jy7_ctJZuQH9ZDaPL4_AgAYzGWkoow,513
 prediction_market_agent_tooling/markets/market_fees.py,sha256=Q64T9uaJx0Vllt0BkrPmpMEz53ra-hMVY8Czi7CEP7s,1227
@@ -45,18 +45,19 @@ prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42D
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=Suxa7xELdYuFNKqvGvFh8qyfVtAg79E-vaQ6dqNZOtA,3261
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=86TIx6cavEWc8Cv4KpZxSvwiSw9oFybXE3YB49pg-CA,4377
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=0eky-RO0TuJysUXHd52A6DSU2mx1ZWiJvvntS4xQsUc,27794
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=uOuV2DgQmxz6kzPcMovyGg0xYS0c6x12fEFNtLmN-uY,51260
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=RM5EigkxBArGRAyolgqqHsdIap-FT3FfbvtlWZJwo10,27711
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=6zo8iBBLdI9g9keJ1dw9PXs4rf4V4tCW8D4e08f3g0Q,51349
 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=cXgtBfc5uv7d8598SJ537LxFGVfF_mv-VoQoqI4_G84,36330
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=lG-2hCmmkjKHX1Ca-SipLBeETnTheXpjg5Qfed0tqFo,36506
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=UZ4_TG8ceb9Y-qgsOKs8Qiv8zDt957QkT8IX2c83yqo,4800
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=Fd5PI5y3mJM8VHExBhWFWEnuuIKxQmIAXgBuoPDvNjw,4341
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=VZhVccTApygSKMmy6Au2G02JCJOKJnR_oVeKlaesuSg,12548
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=NRoZK71PtH8kkangMqme7twcAXhRJSSabbmOir-UnAI,3418
-prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=m4JG6WULh5epCJt4XBMHg0ae5NoVhqlOvAl0A7DR9iM,2023
+prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=DImFxeMg8lTfsEDZ8FavndW38TfUsCkawcVGnucsuGo,2029
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=2f6DOXhGerYbTSk5vUvw_y87TcUxOtSfca8-Et7imtU,643
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=Jola8AxmNDljBCzl6Gvjb9qH75Y7D5dAwbdZl_jndN8,5478
+prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py,sha256=fEiD-upH7vm5FWSND86r_qW0oV5ZonhaJEBxLK0OZAs,2672
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=TS4ERwTfQnot8dhekNyVNhJYf5ysYsjF-9v5_kM3aVI,3334
 prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=LOnyWWBFdg10-cTWdb76nOsNjDloO8OfMT85GBzRCFI,1455
 prediction_market_agent_tooling/monitor/markets/omen.py,sha256=EqiJYTvDbSu7fBpbrBmCuf3fc6GHr4MxWrBGa69MIyc,3305
@@ -71,37 +72,37 @@ prediction_market_agent_tooling/tools/betting_strategies/market_moving.py,sha256
 prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py,sha256=-FUSuQQgjcWSSnoFxnlAyTeilY6raJABJVM2QKkFqAY,438
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
 prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=kpIb-ci67Vc1Yqqaa-_S4OUkbhWSIYog4_Iwp69HU_k,97
-prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=x3v-ZnMpnSzmdwnzubh9oQ7ebExONXjWSFqY48CYQwc,12847
+prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=yQ5sbccFf75jdj71zmlbJ8z5u2cfQzSRgY4haFG43I0,12712
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
-prediction_market_agent_tooling/tools/contract.py,sha256=s3yo8IbXTcvAJcPfLM0_NbgaEsWwLsPmyVnOgyjq_xI,20919
+prediction_market_agent_tooling/tools/contract.py,sha256=Um_nQlpYJRBy4MnNR1CPKESehVwx_w35LwYX6T6py_0,20837
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
+prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
 prediction_market_agent_tooling/tools/datetime_utc.py,sha256=2JSWF7AXQnv04_D_cu9Vmdkq0TWmGJ1QcK9AeqrA-U8,2765
-prediction_market_agent_tooling/tools/gnosis_rpc.py,sha256=ctBfB1os-MvZ1tm0Rwdyn9b3dvFnlM9naKvZmzywc3A,197
-prediction_market_agent_tooling/tools/google.py,sha256=jwXhu4lKfF0cuu02fMX-mGCRntRgiGQWkZ2CstaprK4,1828
+prediction_market_agent_tooling/tools/google_utils.py,sha256=t3_UEEvKX3L0biSIQ560GdRbllQ6eprhK_upE243A-0,3185
 prediction_market_agent_tooling/tools/hexbytes_custom.py,sha256=Bp94qgPjvjWf1Vb4lNzGFDXRdThw1rJ91vL6r2PWq5E,2096
 prediction_market_agent_tooling/tools/httpx_cached_client.py,sha256=0-N1r0zcGKlY9Rk-Ab8hbqwc54eMbsoa3jXL0_yCCiM,355
 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/image_gen/market_thumbnail_gen.py,sha256=jgOow4zw6g8dIJrog6Tp-3NQs4wjUJ3VgVKyMQv-0QM,1286
 prediction_market_agent_tooling/tools/ipfs/ipfs_handler.py,sha256=CTTMfTvs_8PH4kAtlQby2aeEKwgpmxtuGbd4oYIdJ2A,1201
-prediction_market_agent_tooling/tools/is_invalid.py,sha256=GSMwSWUZy-xviaFoIl0L34AVfLLTdh7zegjsTFE7_1M,5323
-prediction_market_agent_tooling/tools/is_predictable.py,sha256=VGkxSoJ8CSLknloOLzm5J4-us7XImYxVzvpsAzxbpCc,6730
+prediction_market_agent_tooling/tools/is_invalid.py,sha256=vuX0TKKhc_7iVnwAjXvfZeFwjr9nyYgREaYQDe-GYgA,5334
+prediction_market_agent_tooling/tools/is_predictable.py,sha256=dSuL8eLnGNKd_MQ3CaT1OuQkAykr3m5kn7f8HHKgDcM,6797
 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/langfuse_client_utils.py,sha256=_m5SFnJJy4E0ubvY8ohzEEjES4nMJ_2zfa3wp4x3gSA,5817
 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/pickle_utils.py,sha256=PUNRJGdURUnLlzbZoSCiOrikRbEC596hi--Z3q8Wt84,1144
 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=CddJem7tk15NAudJDwmuL8znTycbR-YI8kTNtd3LzG8,5474
-prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=2yxtBIDyMT_6CsTpZyuIv_2dy2B9WgEOaTT1fSloBu0,3223
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=Dcde74ZwoZuohhJ8gIO5GQkdAz1YrAKlvrM8CNgRqWw,3289
 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=5ldQs1pZe6uJ5eDAuP4OLpzmcqYShlIV67kttNFvGS0,342
 prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=Kw2mXNkMTYTEe1MBSTqhQmLoeXtgb6CkmHlcAJvhtqE,3809
-prediction_market_agent_tooling/tools/utils.py,sha256=1VvunbTmzGzpIlRukFhArreFNxJPbsg4lLtQNk0r2bY,7185
-prediction_market_agent_tooling/tools/web3_utils.py,sha256=44W8siSLNQxeib98bbwAe7V5C609NHNlUuxwuWIRDiY,11838
-prediction_market_agent_tooling-0.56.3.dev135.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.56.3.dev135.dist-info/METADATA,sha256=gjOGIMtO-vCZp9OV_wf43wWMkLN3fgmyT2zg3vElf8s,8113
-prediction_market_agent_tooling-0.56.3.dev135.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-prediction_market_agent_tooling-0.56.3.dev135.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.56.3.dev135.dist-info/RECORD,,
+prediction_market_agent_tooling/tools/transaction_cache.py,sha256=C96OHkNqPJr_yDiHesSRgekeXIbX62qFl9qldArleuo,1800
+prediction_market_agent_tooling/tools/utils.py,sha256=WvuUCHgMCiMq8_wMm5PHNwvLhcdDk2zGKaAM8OUC-qY,6438
+prediction_market_agent_tooling/tools/web3_utils.py,sha256=hWDa7D-jP-iW647t0ATPyiUgKbAq25iH97KUnha25SQ,11944
+prediction_market_agent_tooling-0.57.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.57.0.dist-info/METADATA,sha256=yK4VmpYuw1CWWmbpu7cLSWEltKzm-6BMi5vbtI2PTfM,8106
+prediction_market_agent_tooling-0.57.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.57.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.57.0.dist-info/RECORD,,

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")

prediction_market_agent_tooling/tools/pickle_utils.py

@@ -1,31 +0,0 @@
-import typing as t
-
-InitialisedValue = t.TypeVar("InitialisedValue")
-
-
-class InitialiseNonPickable(t.Generic[InitialisedValue]):
-    """
-    Use this class to wrap values that you want to be shared within a thread,
-    but they are re-initialised for a new processes.
-
-    Initialiser for the value still needs to be pickable.
-    """
-
-    def __init__(self, initialiser: t.Callable[[], InitialisedValue]) -> None:
-        self.value: InitialisedValue | None = None
-        self.initialiser = initialiser
-
-    def __getstate__(self) -> dict[str, t.Any]:
-        # During pickling, always return `value` as just None, which is pickable and this class will re-initialise it in `get_value` when called.
-        return {"value": None, "initialiser": self.initialiser}
-
-    def __setstate__(self, d: dict[str, t.Any]) -> None:
-        self.value = d["value"]
-        self.initialiser = d["initialiser"]
-
-    def get_value(self) -> InitialisedValue:
-        """Use this function to get the wrapped value, which will be initialised if necessary."""
-        if self.value is None:
-            self.value = self.initialiser()
-
-        return self.value