prediction-market-agent-tooling 0.64.12.dev660__py3-none-any.whl → 0.65.0__py3-none-any.whl

prediction_market_agent_tooling/monitor/monitor_app.py

@@ -1,149 +0,0 @@
-import typing as t
-from datetime import datetime, timedelta
-
-import streamlit as st
-
-from prediction_market_agent_tooling.markets.agent_market import (
-    AgentMarket,
-    FilterBy,
-    SortBy,
-)
-from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.monitor.markets.manifold import (
-    DeployedManifoldAgent,
-)
-from prediction_market_agent_tooling.monitor.markets.metaculus import (
-    DeployedMetaculusAgent,
-)
-from prediction_market_agent_tooling.monitor.markets.omen import DeployedOmenAgent
-from prediction_market_agent_tooling.monitor.markets.polymarket import (
-    DeployedPolymarketAgent,
-)
-from prediction_market_agent_tooling.monitor.monitor import (
-    DeployedAgent,
-    monitor_agent,
-    monitor_market,
-)
-from prediction_market_agent_tooling.monitor.monitor_settings import MonitorSettings
-from prediction_market_agent_tooling.tools.utils import (
-    DatetimeUTC,
-    check_not_none,
-    utc_datetime,
-    utcnow,
-)
-
-MAX_MONITOR_MARKETS = 1000
-
-MARKET_TYPE_TO_DEPLOYED_AGENT: dict[MarketType, type[DeployedAgent]] = {
-    MarketType.MANIFOLD: DeployedManifoldAgent,
-    MarketType.OMEN: DeployedOmenAgent,
-    MarketType.POLYMARKET: DeployedPolymarketAgent,
-    MarketType.METACULUS: DeployedMetaculusAgent,
-}
-
-
-def get_deployed_agents(
-    market_type: MarketType,
-    settings: MonitorSettings,
-    start_time: DatetimeUTC | None,
-) -> list[DeployedAgent]:
-    cls = MARKET_TYPE_TO_DEPLOYED_AGENT.get(market_type)
-    if cls is None:
-        raise ValueError(f"Unknown market type: {market_type}")
-
-    agents: list[DeployedAgent] = []
-
-    if settings.LOAD_FROM_GCF:
-        agents.extend(cls.from_all_gcp_functions())
-
-    if settings.LOAD_FROM_GCK:
-        agents.extend(
-            cls.from_all_gcp_cronjobs(namespace=settings.LOAD_FROM_GCK_NAMESPACE)
-        )
-
-    match market_type:
-        case MarketType.MANIFOLD:
-            agents += settings.MANIFOLD_AGENTS
-        case MarketType.OMEN:
-            agents += settings.OMEN_AGENTS
-        case MarketType.POLYMARKET:
-            agents += settings.POLYMARKET_AGENTS
-        case _:
-            raise ValueError(f"Unknown market type: {market_type}")
-
-    return agents
-
-
-def get_open_and_resolved_markets(
-    start_time: DatetimeUTC,
-    market_type: MarketType,
-) -> tuple[t.Sequence[AgentMarket], t.Sequence[AgentMarket]]:
-    cls = market_type.market_class
-    open_markets = cls.get_binary_markets(
-        limit=MAX_MONITOR_MARKETS,
-        sort_by=SortBy.NEWEST,
-        created_after=start_time,
-        filter_by=FilterBy.OPEN,
-    )
-    resolved_markets = cls.get_binary_markets(
-        limit=MAX_MONITOR_MARKETS,
-        sort_by=SortBy.NEWEST,
-        created_after=start_time,
-        filter_by=FilterBy.RESOLVED,
-    )
-    resolved_markets = [m for m in resolved_markets if m.has_successful_resolution()]
-    return open_markets, resolved_markets
-
-
-def monitor_app(
-    enabled_market_types: list[MarketType],
-) -> None:
-    settings = MonitorSettings()
-    market_type: MarketType = check_not_none(
-        st.selectbox(label="Market type", options=enabled_market_types, index=0)
-    )
-    start_time: DatetimeUTC | None = (
-        DatetimeUTC.from_datetime(
-            datetime.combine(
-                st.date_input(
-                    "Start time",
-                    value=utcnow() - timedelta(weeks=settings.PAST_N_WEEKS),
-                ),
-                datetime.min.time(),
-            )
-        )
-        if settings.has_manual_agents
-        else None
-    )
-
-    with st.spinner("Loading agents"):
-        agents: list[DeployedAgent] = get_deployed_agents(
-            market_type=market_type,
-            settings=settings,
-            start_time=start_time,
-        )
-
-    oldest_start_time = (
-        min(agent.start_time for agent in agents)
-        if agents
-        else utc_datetime(2020, 1, 1)
-    )
-
-    st.header("Market Info")
-    if st.checkbox("Show Market Info"):
-        with st.spinner("Loading markets"):
-            open_markets, resolved_markets = get_open_and_resolved_markets(
-                start_time=oldest_start_time, market_type=market_type
-            )
-        (
-            monitor_market(open_markets=open_markets, resolved_markets=resolved_markets)
-            if open_markets and resolved_markets
-            else st.warning("No market data found.")
-        )
-
-    st.header("Agent Info")
-    if st.button("Export agents"):
-        st.text("[" + ",".join(a.model_dump_json() for a in agents) + "]")
-    for agent in agents:
-        with st.expander(f"Agent: '{agent.name}'"):
-            monitor_agent(agent)

prediction_market_agent_tooling/monitor/monitor_settings.py

@@ -1,27 +0,0 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from prediction_market_agent_tooling.monitor.markets.manifold import (
-    DeployedManifoldAgent,
-)
-from prediction_market_agent_tooling.monitor.markets.omen import DeployedOmenAgent
-from prediction_market_agent_tooling.monitor.markets.polymarket import (
-    DeployedPolymarketAgent,
-)
-
-
-class MonitorSettings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=".env.monitor", env_file_encoding="utf-8", extra="ignore"
-    )
-
-    LOAD_FROM_GCF: bool = False
-    LOAD_FROM_GCK: bool = False
-    LOAD_FROM_GCK_NAMESPACE: str = "agents"
-    MANIFOLD_AGENTS: list[DeployedManifoldAgent] = []
-    OMEN_AGENTS: list[DeployedOmenAgent] = []
-    POLYMARKET_AGENTS: list[DeployedPolymarketAgent] = []
-    PAST_N_WEEKS: int = 1
-
-    @property
-    def has_manual_agents(self) -> bool:
-        return bool(self.MANIFOLD_AGENTS or self.OMEN_AGENTS or self.POLYMARKET_AGENTS)

prediction_market_agent_tooling/tools/betting_strategies/market_moving.py

@@ -1,146 +0,0 @@
-from functools import reduce
-
-import numpy as np
-
-from prediction_market_agent_tooling.gtypes import (
-    CollateralToken,
-    OutcomeToken,
-    Probability,
-)
-from prediction_market_agent_tooling.markets.omen.omen import (
-    MarketFees,
-    OmenAgentMarket,
-)
-from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
-from prediction_market_agent_tooling.tools.utils import check_not_none
-
-
-def get_market_moving_bet(
-    yes_outcome_pool_size: OutcomeToken,
-    no_outcome_pool_size: OutcomeToken,
-    market_p_yes: float,
-    target_p_yes: float,
-    fees: MarketFees,
-    max_iters: int = 100,
-) -> SimpleBet:
-    """
-    Implements a binary search to determine the bet that will move the market's
-    `p_yes` to that of the target.
-
-    Consider a binary fixed-product market containing `x` and `y` tokens.
-    A trader wishes to acquire `x` tokens by betting an amount `d0`.
-
-    The calculation to determine the number of `x` tokens he acquires, denoted
-    by `dx`, is:
-
-    a_x * a_y = fixed_product
-    na_x = a_x + d0
-    na_y = a_y + d0
-    na_x * na_y = new_product
-    (na_x - dx) * na_y = fixed_product
-    (na_x * na_y) - (dx * na_y) = fixed_product
-    new_product - fixed_product = dx * na_y
-    dx = (new_product - fixed_product) / na_y
-    """
-    fixed_product = yes_outcome_pool_size * no_outcome_pool_size
-    bet_direction: bool = target_p_yes > market_p_yes
-
-    min_bet_amount = CollateralToken(0.0)
-    max_bet_amount = (
-        yes_outcome_pool_size + no_outcome_pool_size
-    ).as_token * 100  # TODO set a better upper bound
-
-    # Binary search for the optimal bet amount
-    for _ in range(max_iters):
-        bet_amount = (min_bet_amount + max_bet_amount) / 2
-        amounts_diff = fees.get_after_fees(bet_amount)
-        amounts_diff_as_ot = OutcomeToken.from_token(amounts_diff)
-
-        # Initial new amounts are old amounts + equal new amounts for each outcome
-        yes_outcome_new_pool_size = yes_outcome_pool_size + amounts_diff_as_ot
-        no_outcome_new_pool_size = no_outcome_pool_size + amounts_diff_as_ot
-        new_amounts: dict[bool, OutcomeToken] = {
-            True: yes_outcome_new_pool_size,
-            False: no_outcome_new_pool_size,
-        }
-
-        # Now give away tokens at `bet_outcome_index` to restore invariant
-        new_product = yes_outcome_new_pool_size * no_outcome_new_pool_size
-        dx = (new_product - fixed_product) / new_amounts[not bet_direction]
-        new_amounts[bet_direction] -= OutcomeToken(dx)
-
-        # Check that the invariant is restored
-        assert np.isclose(
-            reduce(lambda x, y: x * y.value, list(new_amounts.values()), 1.0),
-            float(fixed_product),
-        )
-
-        new_p_yes = Probability(
-            (
-                new_amounts[False]
-                / sum(list(new_amounts.values()), start=OutcomeToken(0))
-            )
-        )
-        if abs(target_p_yes - new_p_yes) < 1e-6:
-            break
-        elif new_p_yes > target_p_yes:
-            if bet_direction:
-                max_bet_amount = bet_amount
-            else:
-                min_bet_amount = bet_amount
-        else:
-            if bet_direction:
-                min_bet_amount = bet_amount
-            else:
-                max_bet_amount = bet_amount
-
-    return SimpleBet(direction=bet_direction, size=bet_amount)
-
-
-def _sanity_check_omen_market_moving_bet(
-    bet_to_check: SimpleBet, market: OmenAgentMarket, target_p_yes: float
-) -> None:
-    """
-    A util function for checking that a bet moves the market to the target_p_yes
-    by calling the market's calcBuyAmount method from the smart contract, and
-    using the adjusted outcome pool sizes to calculate the new p_yes.
-    """
-    buy_amount_ = market.get_contract().calcBuyAmount(
-        investment_amount=bet_to_check.size.as_wei,
-        outcome_index=market.get_outcome_index(
-            market.get_outcome_str_from_bool(bet_to_check.direction)
-        ),
-    )
-    buy_amount = buy_amount_.as_outcome_token
-
-    outcome_token_pool = check_not_none(market.outcome_token_pool)
-    yes_outcome_pool_size = outcome_token_pool[market.get_outcome_str_from_bool(True)]
-    no_outcome_pool_size = outcome_token_pool[market.get_outcome_str_from_bool(False)]
-    market_const = yes_outcome_pool_size.value * no_outcome_pool_size.value
-
-    bet_to_check_size_after_fees = market.fees.get_after_fees(bet_to_check.size).value
-
-    # When you buy 'yes' tokens, you add your bet size to the both pools, then
-    # subtract `buy_amount` from the 'yes' pool. And vice versa for 'no' tokens.
-    new_yes_outcome_pool_size = (
-        yes_outcome_pool_size.value
-        + bet_to_check_size_after_fees
-        - float(bet_to_check.direction) * buy_amount.value
-    )
-    new_no_outcome_pool_size = (
-        no_outcome_pool_size.value
-        + bet_to_check_size_after_fees
-        - float(not bet_to_check.direction) * buy_amount.value
-    )
-    new_market_const = new_yes_outcome_pool_size * new_no_outcome_pool_size
-    # Check the invariant is restored
-    assert np.isclose(new_market_const, market_const)
-
-    # Now check that the market's new p_yes is equal to the target_p_yes
-    new_p_yes = new_no_outcome_pool_size / (
-        new_yes_outcome_pool_size + new_no_outcome_pool_size
-    )
-    if not np.isclose(new_p_yes, target_p_yes, atol=0.01):
-        raise ValueError(
-            f"Bet does not move market to target_p_yes {target_p_yes=}. Got {new_p_yes=}"
-        )

prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py

@@ -1,12 +0,0 @@
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
-
-
-def minimum_bet_to_win(
-    answer: bool, amount_to_win: float, market: AgentMarket
-) -> float:
-    """
-    Estimates the minimum bet amount to win the given amount based on the current market price.
-    """
-    share_price = market.current_p_yes if answer else market.current_p_no
-    bet_amount = amount_to_win / (1 / share_price - 1)
-    return bet_amount