prediction-market-agent-tooling 0.69.5.dev1084__tar.gz → 0.69.6__tar.gz

{prediction_market_agent_tooling-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.69.5.dev1084
+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.dev1084 → prediction_market_agent_tooling-0.69.6}/README.md

@@ -33,7 +33,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.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084/prediction_market_agent_tooling/markets/markets.py → prediction_market_agent_tooling-0.69.6/prediction_market_agent_tooling/markets/market_type.py

@@ -1,14 +1,9 @@
-import typing as t
 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,
-    FilterBy,
-    QuestionType,
-    SortBy,
-)
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.manifold.manifold import (
     ManifoldAgentMarket,
 )
@@ -20,7 +15,8 @@ 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
+
+T = TypeVar("T", bound=AgentMarket)
 
 
 class MarketType(str, Enum):
@@ -76,24 +72,3 @@ AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
 JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
     MarketType.OMEN: OmenJobAgentMarket,
 }
-
-
-def get_binary_markets(
-    limit: int,
-    market_type: MarketType,
-    filter_by: FilterBy = FilterBy.OPEN,
-    sort_by: SortBy = SortBy.NONE,
-    excluded_questions: set[str] | None = None,
-    created_after: DatetimeUTC | None = None,
-    question_type: QuestionType = QuestionType.BINARY,
-) -> t.Sequence[AgentMarket]:
-    agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
-    markets = agent_market_class.get_markets(
-        limit=limit,
-        sort_by=sort_by,
-        filter_by=filter_by,
-        created_after=created_after,
-        excluded_questions=excluded_questions,
-        question_type=question_type,
-    )
-    return markets

prediction_market_agent_tooling-0.69.6/prediction_market_agent_tooling/markets/markets.py

@@ -0,0 +1,34 @@
+import typing as t
+
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    FilterBy,
+    QuestionType,
+    SortBy,
+)
+from prediction_market_agent_tooling.markets.market_type import (
+    MARKET_TYPE_TO_AGENT_MARKET,
+    MarketType,
+)
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+
+
+def get_binary_markets(
+    limit: int,
+    market_type: MarketType,
+    filter_by: FilterBy = FilterBy.OPEN,
+    sort_by: SortBy = SortBy.NONE,
+    excluded_questions: set[str] | None = None,
+    created_after: DatetimeUTC | None = None,
+    question_type: QuestionType = QuestionType.BINARY,
+) -> t.Sequence[AgentMarket]:
+    agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
+    markets = agent_market_class.get_markets(
+        limit=limit,
+        sort_by=sort_by,
+        filter_by=filter_by,
+        created_after=created_after,
+        excluded_questions=excluded_questions,
+        question_type=question_type,
+    )
+    return markets

{prediction_market_agent_tooling-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.6/prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -0,0 +1,91 @@
+from pydantic import BaseModel
+from subgrounds import FieldPath
+
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
+
+
+class ConditionSubgraphModel(BaseModel):
+    id: HexBytes
+    payoutDenominator: int | None = None
+    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):
+    POLYMARKET_CONDITIONS_SUBGRAPH = "https://gateway.thegraph.com/api/{graph_api_key}/subgraphs/id/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Load the subgraph
+        self.conditions_subgraph = self.sg.load_subgraph(
+            self.POLYMARKET_CONDITIONS_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+
+    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]:
+        where_stms = {"id_in": [i.to_0x_hex() for i in condition_ids]}
+        conditions = self.conditions_subgraph.Query.conditions(
+            first=len(condition_ids),
+            where=where_stms,
+        )
+
+        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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.5.dev1084 → prediction_market_agent_tooling-0.69.6}/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-0.69.6/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-0.69.6/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-0.69.6/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.dev1084 → prediction_market_agent_tooling-0.69.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.69.5.dev1084"
+version = "0.69.6"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"