prediction-market-agent-tooling 0.69.5__py3-none-any.whl → 0.69.6__py3-none-any.whl

prediction_market_agent_tooling/data_download/langfuse_data_downloader.py

@@ -16,7 +16,7 @@ from prediction_market_agent_tooling.gtypes import DatetimeUTC, OutcomeStr, Outc
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (

prediction_market_agent_tooling/deploy/agent.py

@@ -36,7 +36,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     ScalarProbabilisticAnswer,
     Trade,
 )
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.tools.custom_exceptions import (
     CantPayForGasError,
     OutOfFundsError,

prediction_market_agent_tooling/deploy/agent_example.py

@@ -6,7 +6,7 @@ from prediction_market_agent_tooling.markets.agent_market import AgentMarket, So
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
 )
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 
 
 class DeployableCoinFlipAgent(DeployableTraderAgent):

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -26,7 +26,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import (
     get_buy_outcome_token_amount,
 )

prediction_market_agent_tooling/markets/market_type.py

@@ -0,0 +1,74 @@
+from enum import Enum
+from typing import TypeVar
+
+from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.manifold.manifold import (
+    ManifoldAgentMarket,
+)
+from prediction_market_agent_tooling.markets.metaculus.metaculus import (
+    MetaculusAgentMarket,
+)
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.polymarket.polymarket import (
+    PolymarketAgentMarket,
+)
+from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
+
+T = TypeVar("T", bound=AgentMarket)
+
+
+class MarketType(str, Enum):
+    # Note: Always keep the omen market first, as it is the main market for us.
+    OMEN = "omen"
+    MANIFOLD = "manifold"
+    POLYMARKET = "polymarket"
+    METACULUS = "metaculus"
+    SEER = "seer"
+
+    @staticmethod
+    def from_market(market: AgentMarket) -> "MarketType":
+        return AGENT_MARKET_TO_MARKET_TYPE[type(market)]
+
+    @property
+    def market_class(self) -> type[AgentMarket]:
+        if self not in MARKET_TYPE_TO_AGENT_MARKET:
+            raise ValueError(f"Unknown market type: {self}")
+        return MARKET_TYPE_TO_AGENT_MARKET[self]
+
+    @property
+    def job_class(self) -> type[JobAgentMarket]:
+        if self not in JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET:
+            raise ValueError(f"Unknown market type: {self}")
+        return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
+
+    @property
+    def is_trading_market(self) -> bool:
+        return self in [
+            MarketType.OMEN,
+            MarketType.POLYMARKET,
+            MarketType.SEER,
+            MarketType.MANIFOLD,
+        ]
+
+    @property
+    def is_blockchain_market(self) -> bool:
+        return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
+
+
+MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
+    MarketType.MANIFOLD: ManifoldAgentMarket,
+    MarketType.OMEN: OmenAgentMarket,
+    MarketType.POLYMARKET: PolymarketAgentMarket,
+    MarketType.METACULUS: MetaculusAgentMarket,
+    MarketType.SEER: SeerAgentMarket,
+}
+
+AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
+    v: k for k, v in MARKET_TYPE_TO_AGENT_MARKET.items()
+}
+
+JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
+    MarketType.OMEN: OmenJobAgentMarket,
+}

prediction_market_agent_tooling/markets/markets.py

@@ -1,83 +1,18 @@
 import typing as t
-from enum import Enum
 
-from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
-from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     QuestionType,
     SortBy,
 )
-from prediction_market_agent_tooling.markets.manifold.manifold import (
-    ManifoldAgentMarket,
+from prediction_market_agent_tooling.markets.market_type import (
+    MARKET_TYPE_TO_AGENT_MARKET,
+    MarketType,
 )
-from prediction_market_agent_tooling.markets.metaculus.metaculus import (
-    MetaculusAgentMarket,
-)
-from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
-from prediction_market_agent_tooling.markets.polymarket.polymarket import (
-    PolymarketAgentMarket,
-)
-from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
-class MarketType(str, Enum):
-    # Note: Always keep the omen market first, as it is the main market for us.
-    OMEN = "omen"
-    MANIFOLD = "manifold"
-    POLYMARKET = "polymarket"
-    METACULUS = "metaculus"
-    SEER = "seer"
-
-    @staticmethod
-    def from_market(market: AgentMarket) -> "MarketType":
-        return AGENT_MARKET_TO_MARKET_TYPE[type(market)]
-
-    @property
-    def market_class(self) -> type[AgentMarket]:
-        if self not in MARKET_TYPE_TO_AGENT_MARKET:
-            raise ValueError(f"Unknown market type: {self}")
-        return MARKET_TYPE_TO_AGENT_MARKET[self]
-
-    @property
-    def job_class(self) -> type[JobAgentMarket]:
-        if self not in JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET:
-            raise ValueError(f"Unknown market type: {self}")
-        return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
-
-    @property
-    def is_trading_market(self) -> bool:
-        return self in [
-            MarketType.OMEN,
-            MarketType.POLYMARKET,
-            MarketType.SEER,
-            MarketType.MANIFOLD,
-        ]
-
-    @property
-    def is_blockchain_market(self) -> bool:
-        return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
-
-
-MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
-    MarketType.MANIFOLD: ManifoldAgentMarket,
-    MarketType.OMEN: OmenAgentMarket,
-    MarketType.POLYMARKET: PolymarketAgentMarket,
-    MarketType.METACULUS: MetaculusAgentMarket,
-    MarketType.SEER: SeerAgentMarket,
-}
-
-AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
-    v: k for k, v in MARKET_TYPE_TO_AGENT_MARKET.items()
-}
-
-JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
-    MarketType.OMEN: OmenJobAgentMarket,
-}
-
-
 def get_binary_markets(
     limit: int,
     market_type: MarketType,

prediction_market_agent_tooling/markets/omen/omen.py

@@ -1114,7 +1114,7 @@ def get_conditional_tokens_balance_for_market(
 
     for index_set in market.condition.index_sets:
         collection_id = conditional_token_contract.getCollectionId(
-            parent_collection_id, market.condition.id, index_set, web3=web3
+            HexBytes(parent_collection_id), market.condition.id, index_set, web3=web3
         )
         # Note that collection_id is returned as bytes, which is accepted by the contract calls downstream.
         position_id: int = conditional_token_contract.getPositionId(

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -13,7 +13,7 @@ from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.manifold.api import (
     find_resolution_on_manifold,
 )
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.markets.omen.data_models import (
     OmenMarket,
     RealityQuestion,

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -46,6 +46,7 @@ from prediction_market_agent_tooling.markets.polymarket.data_models import (
     PolymarketGammaResponseDataItem,
 )
 from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    PolymarketConditionalTokenContract,
     USDCeContract,
 )
 from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_handler import (
@@ -266,9 +267,30 @@ class PolymarketAgentMarket(AgentMarket):
             )
 
     @staticmethod
-    def redeem_winnings(api_keys: APIKeys) -> None:
-        # ToDo - implement me - https://github.com/gnosis/prediction-market-agent-tooling/issues/824
-        pass
+    def redeem_winnings(api_keys: APIKeys, web3: Web3 | None = None) -> None:
+        web3 = web3 or RPCConfig().get_polygon_web3()
+        user_id = api_keys.bet_from_address
+        conditional_token_contract = PolymarketConditionalTokenContract()
+        positions = PolymarketSubgraphHandler().get_market_positions_from_user(user_id)
+        for pos in positions:
+            if (
+                pos.market.condition.resolutionTimestamp is None
+                or pos.market.condition.payoutNumerators is None
+            ):
+                continue
+
+            condition_id = pos.market.condition.id
+            index_sets = pos.market.condition.index_sets
+
+            redeem_event = conditional_token_contract.redeemPositions(
+                api_keys=api_keys,
+                collateral_token_address=USDCeContract().address,
+                condition_id=condition_id,
+                index_sets=index_sets,
+                web3=web3,
+            )
+
+            logger.info(f"Redeemed {redeem_event=} from condition_id {condition_id=}.")
 
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel
+from subgrounds import FieldPath
 
-from prediction_market_agent_tooling.gtypes import HexBytes
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.markets.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
@@ -12,6 +13,20 @@ class ConditionSubgraphModel(BaseModel):
     payoutNumerators: list[int] | None = None
     outcomeSlotCount: int
     resolutionTimestamp: int | None = None
+    questionId: HexBytes
+
+    @property
+    def index_sets(self) -> list[int]:
+        return [i + 1 for i in range(self.outcomeSlotCount)]
+
+
+class MarketPositionMarket(BaseModel):
+    condition: ConditionSubgraphModel
+
+
+class MarketPosition(BaseModel):
+    id: HexBytes
+    market: MarketPositionMarket
 
 
 class PolymarketSubgraphHandler(BaseSubgraphHandler):
@@ -27,6 +42,16 @@ class PolymarketSubgraphHandler(BaseSubgraphHandler):
             )
         )
 
+    def _get_fields_for_condition(self, field: FieldPath) -> list[FieldPath]:
+        return [
+            field.id,
+            field.questionId,
+            field.payoutNumerators,
+            field.payoutDenominator,
+            field.outcomeSlotCount,
+            field.resolutionTimestamp,
+        ]
+
     def get_conditions(
         self, condition_ids: list[HexBytes]
     ) -> list[ConditionSubgraphModel]:
@@ -36,15 +61,31 @@ class PolymarketSubgraphHandler(BaseSubgraphHandler):
             where=where_stms,
         )
 
-        condition_fields = [
-            conditions.id,
-            conditions.payoutNumerators,
-            conditions.payoutDenominator,
-            conditions.outcomeSlotCount,
-            conditions.resolutionTimestamp,
-        ]
+        condition_fields = self._get_fields_for_condition(conditions)
 
         conditions_models = self.do_query(
             fields=condition_fields, pydantic_model=ConditionSubgraphModel
         )
         return conditions_models
+
+    def get_market_positions_from_user(
+        self,
+        user: ChecksumAddress,
+        first: int = 1000,
+        block_number: int | None = None,
+    ) -> list[MarketPosition]:
+        # Not possible to filter using `market_.condition` on a subgraph level, bad indexers error.
+        positions = self.conditions_subgraph.Query.marketPositions(
+            first=first,
+            where={"user": user.lower()},
+            block={"number": block_number} if block_number else None,
+        )
+
+        condition_fields = self._get_fields_for_condition(
+            positions.market.condition
+        ) + [positions.id]
+
+        positions_models = self.do_query(
+            fields=condition_fields, pydantic_model=MarketPosition
+        )
+        return positions_models

prediction_market_agent_tooling/markets/polymarket/utils.py

@@ -1,4 +1,4 @@
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.tools.google_utils import search_google_gcp
 
 

prediction_market_agent_tooling/tools/_generic_value.py

@@ -239,7 +239,7 @@ class _GenericValue(
         cls, source_type: t.Any, handler: GetCoreSchemaHandler
     ) -> CoreSchema:
         # Support for Pydantic usage.
-        dt_schema = handler(str | int | float | dict)
+        dt_schema = handler(cls.parser | str | dict)
         return core_schema.no_info_after_validator_function(
             lambda x: cls(x["value"] if isinstance(x, dict) else x),
             dt_schema,

prediction_market_agent_tooling/tools/contract.py

@@ -665,7 +665,7 @@ class ConditionalTokenContract(ContractBaseClass):
 
     def getCollectionId(
         self,
-        parent_collection_id: HexStr,
+        parent_collection_id: HexBytes,
         condition_id: HexBytes,
         index_set: int,
         web3: Web3 | None = None,
@@ -773,6 +773,34 @@ class ConditionalTokenContract(ContractBaseClass):
         )
         return payoutForCondition
 
+    def splitPosition(
+        self,
+        api_keys: APIKeys,
+        collateral_token: ChecksumAddress,
+        condition_id: HexBytes,
+        outcome_slot_count: int,
+        amount_wei: Wei,
+        parent_collateral_id: HexBytes = HexBytes(HASH_ZERO),
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        # We always split the full set of outcome tokens (for simplicity)
+        # partitions are given in bitmasks, i.e. outcomes are 1,2,4,8,etc.
+        partition = [2**i for i in range(outcome_slot_count)]
+        return self.send(
+            api_keys=api_keys,
+            function_name="splitPosition",
+            function_params=[
+                collateral_token,
+                parent_collateral_id,
+                condition_id,
+                partition,
+                amount_wei,
+            ],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
     def setApprovalForAll(
         self,
         api_keys: APIKeys,

prediction_market_agent_tooling/tools/contract_utils.py

@@ -0,0 +1,61 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import RPCConfig
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.tools.contract import contract_implements_function
+
+
+def is_erc20_contract(address: ChecksumAddress, web3: Web3 | None = None) -> bool:
+    """
+    Checks if the given address is an ERC20-compatible contract.
+
+    It estimates it by looking if it implements symbol, name, decimals, totalSupply, balanceOf.
+    """
+    web3 = web3 or RPCConfig().get_web3()
+    return (
+        contract_implements_function(address, "symbol", web3)
+        and contract_implements_function(address, "name", web3)
+        and contract_implements_function(address, "totalSupply", web3)
+        and contract_implements_function(
+            address, "balanceOf", web3, function_arg_types=["address"]
+        )
+    )
+
+
+def is_nft_contract(address: ChecksumAddress, web3: Web3 | None = None) -> bool:
+    """
+    Checks if the given address is an NFT-compatible contract (ERC721 or ERC1155).
+
+    For ERC721, checks for: ownerOf, balanceOf, transferFrom.
+    For ERC1155, checks for: balanceOf, safeTransferFrom.
+
+    Returns True if either ERC721 or ERC1155 interface is detected.
+    """
+    web3 = web3 or RPCConfig().get_web3()
+    is_erc721 = (
+        contract_implements_function(
+            address, "ownerOf", web3, function_arg_types=["uint256"]
+        )
+        and contract_implements_function(
+            address, "balanceOf", web3, function_arg_types=["address"]
+        )
+        and contract_implements_function(
+            address,
+            "transferFrom",
+            web3,
+            function_arg_types=["address", "address", "uint256"],
+        )
+    )
+    if is_erc721:
+        return True
+    is_erc1155 = contract_implements_function(
+        address, "balanceOf", web3, function_arg_types=["address", "uint256"]
+    ) and contract_implements_function(
+        address,
+        "safeTransferFrom",
+        web3,
+        function_arg_types=["address", "address", "uint256", "uint256", "bytes"],
+    )
+    if is_erc1155:
+        return True
+    return False

prediction_market_agent_tooling/tools/openai_utils.py

@@ -0,0 +1,31 @@
+from langfuse.openai import AsyncOpenAI
+from openai import DEFAULT_TIMEOUT, DefaultAsyncHttpxClient
+from pydantic import SecretStr
+from pydantic_ai.models.openai import OpenAIModel  # noqa: F401 # Just for convenience.
+from pydantic_ai.providers.openai import OpenAIProvider
+
+OPENAI_BASE_URL = "https://api.openai.com/v1"
+
+
+def get_openai_provider(
+    api_key: SecretStr,
+    base_url: str = OPENAI_BASE_URL,
+) -> OpenAIProvider:
+    """
+    For some reason, when OpenAIProvider/AsyncOpenAI is initialised without the http_client directly provided, and it's used with Langfuse observer decorator,
+    we are getting false error messages.
+
+    Unfortunatelly, Langfuse doesn't seem eager to fix this, so this is a workaround. See https://github.com/langfuse/langfuse/issues/5622.
+
+    Use this function as a helper function to create bug-free OpenAIProvider.
+    """
+    return OpenAIProvider(
+        openai_client=AsyncOpenAI(
+            api_key=api_key.get_secret_value(),
+            base_url=base_url,
+            http_client=DefaultAsyncHttpxClient(
+                timeout=DEFAULT_TIMEOUT,
+                base_url=base_url,
+            ),
+        )
+    )

prediction_market_agent_tooling/tools/streamlit_utils.py

@@ -0,0 +1,188 @@
+import asyncio
+import os
+import typing as t
+
+import streamlit
+import streamlit as st
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.caches.db_cache import DB_CACHE_LOG_PREFIX
+
+if t.TYPE_CHECKING:
+    from loguru import Message
+
+STREAMLIT_SINK_EXPLICIT_FLAG = "streamlit"
+
+
+def streamlit_asyncio_event_loop_hack() -> None:
+    """
+    This function is a hack to make Streamlit work with asyncio event loop.
+    See https://github.com/streamlit/streamlit/issues/744
+    """
+
+    def get_or_create_eventloop() -> asyncio.AbstractEventLoop:
+        try:
+            return asyncio.get_event_loop()
+        except RuntimeError as ex:
+            if "There is no current event loop in thread" in str(ex):
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                return asyncio.get_event_loop()
+            else:
+                raise ex
+
+    loop = get_or_create_eventloop()
+    asyncio.set_event_loop(loop)
+
+
+def check_required_api_keys(keys: APIKeys, required_keys: list[str]) -> None:
+    has_missing_keys = False
+    for key in required_keys:
+        if not getattr(keys, key):
+            st.error(f"Environment variable for key {key} has not been set.")
+            has_missing_keys = True
+    if has_missing_keys:
+        st.stop()
+
+
+def get_loguru_streamlit_sink(
+    explicit: bool,
+    expander_if_longer_than: int | None,
+    include_in_expander: int = 50,
+) -> t.Callable[["Message"], None]:
+    def loguru_streamlit_sink(log: "Message") -> None:
+        record = log.record
+        level = record["level"].name
+
+        message = streamlit_escape(record["message"])
+
+        # Ignore certain messages that aren't interesting for Streamlit user, but are in the production logs.
+        if any(x in message for x in [DB_CACHE_LOG_PREFIX]):
+            return
+
+        if explicit and not record["extra"].get(STREAMLIT_SINK_EXPLICIT_FLAG, False):
+            return
+
+        if level == "ERROR":
+            st_func = st.error
+            st_icon = "❌"
+
+        elif level == "WARNING":
+            st_func = st.warning
+            st_icon = "⚠️"
+
+        elif level == "SUCCESS":
+            st_func = st.success
+            st_icon = "✅"
+
+        elif level == "DEBUG":
+            st_func = None
+            st_icon = None
+
+        else:
+            st_func = st.info
+            st_icon = "ℹ️"
+
+        if st_func is None:
+            pass
+
+        elif (
+            expander_if_longer_than is not None
+            and len(message) > expander_if_longer_than
+        ):
+            with st.expander(
+                f"[Expand to see more] {message[:include_in_expander]}..."
+            ):
+                st_func(message, icon=st_icon)
+
+        else:
+            st_func(message, icon=st_icon)
+
+    return loguru_streamlit_sink
+
+
+@st.cache_resource
+def add_sink_to_logger(
+    explicit: bool = False, expander_if_longer_than: int | None = 500
+) -> None:
+    """
+    Adds streamlit as a sink to the loguru, so any loguru logs will be shown in the streamlit app.
+
+    Needs to be behind a cache decorator, so it only runs once per streamlit session (otherwise we would see duplicated messages).
+
+    If `explicit` is set to True, only logged messages with extra attribute `streamlit` will be shown in the streamlit app.
+    """
+    logger.add(
+        get_loguru_streamlit_sink(
+            explicit=explicit, expander_if_longer_than=expander_if_longer_than
+        )
+    )
+
+
+def streamlit_escape(message: str) -> str:
+    """
+    Escapes the string for streamlit writes.
+    """
+    # Replace escaped newlines with actual newlines.
+    message = message.replace("\\n", "\n")
+    # Fix malformed dollar signs in the messages.
+    message = message.replace("$", "\$")
+
+    return message
+
+
+def dict_to_point_list(d: dict[str, t.Any], indent: int = 0) -> str:
+    """
+    Helper method to convert nested dicts to a bullet point list.
+    """
+    lines = []
+    prefix = "  " * indent
+    for k, v in d.items():
+        if isinstance(v, dict):
+            lines.append(f"{prefix}- {k}:")
+            lines.append(dict_to_point_list(v, indent + 1))
+        elif isinstance(v, list):
+            lines.append(f"{prefix}- {k}:")
+            for idx, item in enumerate(v):
+                if isinstance(item, dict):
+                    lines.append(f"{prefix}  - item {idx}:")
+                    lines.append(dict_to_point_list(item, indent + 2))
+                else:
+                    lines.append(f"{prefix}  - item {idx}: {item}")
+        else:
+            lines.append(f"{prefix}- {k}: {v}")
+    return "\n".join(lines)
+
+
+def customize_index_html(head_content: str) -> None:
+    """
+    Unfortunatelly, Streamlit doesn't allow to update HTML content of the main index.html file, any component that allows passing of HTML will render it in iframe.
+    That's unusable for analytics tools like Posthog.
+
+    This is workaround that patches their index.html file directly in their package, found in https://stackoverflow.com/questions/70520191/how-to-add-the-google-analytics-tag-to-website-developed-with-streamlit/78992559#78992559.
+
+    There is also an issue that tracks this feature (open since 2023): https://github.com/streamlit/streamlit/issues/6140
+    """
+    streamlit_package_dir = os.path.dirname(streamlit.__file__)
+    index_path = os.path.join(streamlit_package_dir, "static", "index.html")
+
+    with open(index_path, "r") as f:
+        index_html = f.read()
+
+    if head_content not in index_html:
+        # Add the custom content to the head
+        index_html = index_html.replace("</head>", f"{head_content}</head>")
+
+        # Replace the <title> tag
+        index_html = index_html.replace(
+            "<title>Streamlit</title>", "<title>Savantly is cool</title>"
+        )
+
+        with open(index_path, "w") as f:
+            f.write(index_html)
+
+        logger.info("index.html injected with custom code.")
+
+    else:
+        logger.info("index.html injection skipped because it's already present.")

{prediction_market_agent_tooling-0.69.5.dist-info → prediction_market_agent_tooling-0.69.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.69.5
+Version: 0.69.6
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -101,7 +101,8 @@ For example:
 ```python
 import prediction_market_agent_tooling.benchmark.benchmark as bm
 from prediction_market_agent_tooling.benchmark.agents import RandomAgent
-from prediction_market_agent_tooling.markets.markets import MarketType, get_binary_markets
+from prediction_market_agent_tooling.markets.market_type import MarketType
+from prediction_market_agent_tooling.markets.markets import get_binary_markets
 
 benchmarker = bm.Benchmarker(
     markets=get_binary_markets(limit=10, market_type=MarketType.MANIFOLD),

{prediction_market_agent_tooling-0.69.5.dist-info → prediction_market_agent_tooling-0.69.6.dist-info}/RECORD

@@ -26,10 +26,10 @@ prediction_market_agent_tooling/benchmark/benchmark.py,sha256=hpIpjjePDFTLhK841s
 prediction_market_agent_tooling/benchmark/utils.py,sha256=vmVTQLER8I7MM_bHFiavrNM9aQe28PL6WihM6J-E65k,3327
 prediction_market_agent_tooling/chains.py,sha256=MF600uUR_I0Mf7-Pz5InS6RWMkdrZI2sohP6Vfh0YRw,148
 prediction_market_agent_tooling/config.py,sha256=h9rsVMCDhDLMmH657CKEDZ4ZCWvC9RmX5p5kPI5rP58,13464
-prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=VY23h324VKIVkevj1B1O-zL1eEp9AElmcfn6SwYDUSc,14246
-prediction_market_agent_tooling/deploy/agent.py,sha256=xoET-LGMLW5zdZN86zcdrisi8pDXNjxK5ckH1d_xrX0,30897
-prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=yqKvNVINuqDl_xwjklZcFfeEdKP9P9E2TlgAkO1DtRw,29518
+prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=pPiZMp35CJ4YLv7KU4OMmkEJvzGQ_QobZmUONFOBAxs,14250
+prediction_market_agent_tooling/deploy/agent.py,sha256=PKccRZPt9CTMLjbRjzI_XMx15843Bt4rXWSRtuovC9A,30901
+prediction_market_agent_tooling/deploy/agent_example.py,sha256=B4bpv1JjOCJeHAWPCdyVY-BfEhRt6MfkVbYrhr0GZp4,1381
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=wMooHQ0C3Z4Pos5UhoS8QZNU4mygJDGdyAF5SUzMytw,29522
 prediction_market_agent_tooling/deploy/constants.py,sha256=NzH0xk1D0PPSq67qlqpqeTHqwKYUvAn9_eBMhI-LNHc,446
 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
@@ -52,26 +52,27 @@ prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=3z1gFbPME
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=hHloNKYQRyd4OWTCUh5kCk-Kx1m77rOIg8d8bGJ6jvk,5454
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=DCigEbpGWkXR-RZT_oJrvJhilmxKFAxcWMjUFi0nBBI,530
 prediction_market_agent_tooling/markets/market_fees.py,sha256=YeK3ynjYIguB0xf6sO5iyg9lOdW_HD4C6nbJfiGyRCU,1351
-prediction_market_agent_tooling/markets/markets.py,sha256=GmloYxwLJC51v65-ooQ5DqMtKpSCZ955TZWkf0uxhLI,3256
+prediction_market_agent_tooling/markets/market_type.py,sha256=oIv6YQuiRsI7vCeNPiF-76dGePJb_ucCYjWurEq317w,2521
+prediction_market_agent_tooling/markets/markets.py,sha256=xncpIFPbbrL-_Ae4luDadvbK3_KmafHIpaSQCALrt8Y,994
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=WjPt0MKeJNtoY-8oLQTLC8vQYYQ-dBj8UZoPq-UBYsQ,3288
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=kM0U0k90YfLE82ra53JAoCR9uIc9wm4B8l32hLw5imU,5312
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/cow_contracts.py,sha256=sFaW82u_haL4nze8fjTmnQsOuV0OecunQlAhh1OAw0w,1091
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=UcvwAMMlQSDkEoWQd73Rn0aAKswb9szWfNZVFaxpagM,31331
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=1Plw_eJcCvATEdHot-ANbLYAdSgdx8o-S6oVFzkz2eY,52773
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=yiJiVoGG_U3V8NsQzwAUiwA-yvbSXyzUcqJ8MYZYKj0,52783
 prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=XtRk4vpxwUYkTndfjlcmghA-NOIneV8zdHFdyI7tHhM,487
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=0tzaL9P9T7whcTdgK1q_XsEKK3kzCAHs-eZEh-nTZEY,24105
-prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=vVYdrL-9txufByYf3E7ApkrbVZlAGD-70STrqnhQWhg,11047
+prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=_vrnNhHT63-k0crE71OkjGaaYZ6fBX69q4nzcF0qv5k,11051
 prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=he3_xRLKaJQeEdP-VXuotAPM7rHRIJ4OE2mVWaixl7U,40134
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=62PtOJyiXywRCvW4vnj5aq8XgQXqGP04GBW7o6XNQ8Y,5755
 prediction_market_agent_tooling/markets/polymarket/clob_manager.py,sha256=sCCQw5GePrfike0A4EgQRtxaqp91RDjGaVWNx_5QzH4,5367
 prediction_market_agent_tooling/markets/polymarket/constants.py,sha256=-sEFwEsMSJEgLAIaeJnWFoTBsnjSW_m5iKFiFkfw2NE,457
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=a0PJVhW3b9IoUXunCIwxHm7W4KURkaNwwQU2y9nZtuU,5836
-prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=-zAx64Mccuwp3E7oBLfdIlf9aRHNFF01GESlbDK2M4A,15746
+prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=QKbmSflcK1lxDWyQ92VJxpKwSGJvoHvpRKepepMLeog,16669
 prediction_market_agent_tooling/markets/polymarket/polymarket_contracts.py,sha256=x8yvAUPl55nbJALsQAAHJtstahhpH8WcEOj8or_QloQ,1165
-prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py,sha256=2b1hVAp3tCPkmp_FFAZwy6baW7CrPhpUSGk7TlrvgtU,1631
-prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=A_diygWKYyp4WHbxAlAVAuC0S0ZqbEKE80wxL6mxHKQ,1275
+prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py,sha256=6_dJbp9YBz0TZW6PxWGIB1L9VE-1JAIzvf8qTBrEyYs,2905
+prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=i1KjkQWABUoQyfX-XBuhACm6-POFMTXWifgP1V2sz-Y,1279
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=nnuclpajQCkb_s52cCf_rwGWdgjMutaIPyfUq7CqX4M,7626
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
 prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=Sz8NkbDd5CYruKe6KZ9GU--Jf8FDSkniE-PVrbqGiPM,9952
@@ -82,7 +83,7 @@ prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=nme
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=96v41jdNNxBqTCp5g8SLMSrIgeeITVx5IsBjVgm-qdo,2920
 prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=k_sCEJZLroVDjOVkZ084VKJGNODLGjBGezhsWEZvlH4,3528
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/tools/_generic_value.py,sha256=pD_PI13lpPp1gFoljHwa_Lzlp-u2pu0m-Z7LcxwDM2U,10618
+prediction_market_agent_tooling/tools/_generic_value.py,sha256=L9SH_-JwD6RQeKoeTxvNWbkY6CxWIz-VjZEURXoZleg,10617
 prediction_market_agent_tooling/tools/balances.py,sha256=Osab21btfJDw2Y-jT_TV-KHGrseCRxcsYeW6WcOMB8E,1050
 prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=o5ba633gKiDqV4t_C2d9FWwH-HkRAOZd8FcZTYvbj6g,14451
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
@@ -90,7 +91,8 @@ prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=MpS3FOM
 prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=rZIGhgijquwwPtp_qncSAPR1SDF2XxIVZL1ir0fgzWw,12127
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjqeAebu5T7ftRnlkxiL02IC-MxCfDB80x7w,1506
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
-prediction_market_agent_tooling/tools/contract.py,sha256=ZuypmdAB82LYpVZE_qvlax13ikwg7D6OV-YafiQYxoE,32870
+prediction_market_agent_tooling/tools/contract.py,sha256=Agd3eNsr9PW6t2jtGUzcQlmudNKpjvQkSfGEcq28i8k,33813
+prediction_market_agent_tooling/tools/contract_utils.py,sha256=9X9raICUZkPDShilt02aYzS_ILZ62u0vG5081uWLdqk,2152
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
 prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=kdvhWVTb31oHVspQFowDNEIoDtx8hwGTlKsWYGRh3oQ,14050
 prediction_market_agent_tooling/tools/cow/models.py,sha256=2hTW-Ye6SamBBAO32nVo4f3vjAOOySw8ehECReRcA3o,756
@@ -110,6 +112,7 @@ prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_A
 prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=8d33dcYx5ElyE0pL_VTJTcJIXvt3PPkDaadQgxGGyp0,7132
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/omen/sell_positions.py,sha256=Q4oI7_QI3AkyxlH10VvxDahYVrphQa1Wnox2Ce_cf_k,2452
+prediction_market_agent_tooling/tools/openai_utils.py,sha256=0KqHp8QdJH8C5b-Sk62OYmB0f47AzmT4LkENs9m5Y8g,1164
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
 prediction_market_agent_tooling/tools/perplexity/perplexity_client.py,sha256=Oi5a_uaCAPtpTAEEVwD0SXWTsKkhCXOQjCBfa1eAuC0,3215
 prediction_market_agent_tooling/tools/perplexity/perplexity_models.py,sha256=SfeR5FGQ2PqaxG4f4ij50LEnS9f2aeLplVwD7IZQh1s,820
@@ -121,6 +124,7 @@ prediction_market_agent_tooling/tools/rephrase.py,sha256=tqNqusaf5JeEC8ov11uL0Yz
 prediction_market_agent_tooling/tools/safe.py,sha256=o477HGPQv7X_eDoOeYoELCHryiq1_102y_JVhGEPDXw,5165
 prediction_market_agent_tooling/tools/singleton.py,sha256=CHpUJuu89Hwup2fH9CIChUwavc52TG6tCoi_wA_qZps,990
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
+prediction_market_agent_tooling/tools/streamlit_utils.py,sha256=CAHMsuHLUSE0ECLU1nnwvxPLyxGKBY4WqL2vjCvPzgw,6110
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=5ldQs1pZe6uJ5eDAuP4OLpzmcqYShlIV67kttNFvGS0,342
 prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=pPs0qZNfJ7G-1ajfz0iaWOBQyiC0TbcShfrW8T39jtg,3859
 prediction_market_agent_tooling/tools/tokens/auto_deposit.py,sha256=E4jq6HvwOQCt6hb6yEFps7G78Ri5Z0JOfh3UqrwLPEM,9186
@@ -132,8 +136,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=DPO-4HBTy1-TZHKL_9CnH
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=ruq6P5TFs8CBHxeBLj1Plpx7kuNFPpDgMsJGQgDiRNs,8785
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=CDbaidlLeQ4VHzSg150L7QNfHfGveljSePGuDVFEYqc,13963
-prediction_market_agent_tooling-0.69.5.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.69.5.dist-info/METADATA,sha256=Uaa9YSg_wOcxC5vKVW3qxMF6rRj5NJTDXC6buuKqJuU,8805
-prediction_market_agent_tooling-0.69.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.69.5.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.69.5.dist-info/RECORD,,
+prediction_market_agent_tooling-0.69.6.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.69.6.dist-info/METADATA,sha256=YjLLuu8iU7HRDPHXtapKQeOpI8z4HWPS8Yb4640-TDE,8868
+prediction_market_agent_tooling-0.69.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.69.6.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.69.6.dist-info/RECORD,,