prediction-market-agent-tooling 0.47.0__tar.gz → 0.48.0__tar.gz

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.47.0
+Version: 0.48.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -11,9 +11,9 @@ Provides-Extra: google
 Provides-Extra: langchain
 Provides-Extra: openai
 Requires-Dist: autoflake (>=2.2.1,<3.0.0)
-Requires-Dist: base58 (>=2.1.1,<3.0.0)
+Requires-Dist: base58 (>=1.0.2,<2.0)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
-Requires-Dist: eth-account (>=0.8.0,<0.9.0)
+Requires-Dist: eth-account (>=0.11.2,<0.12.0)
 Requires-Dist: eth-typing (>=3.0.0,<4.0.0)
 Requires-Dist: functions-framework (>=3.5.0,<4.0.0)
 Requires-Dist: google-api-python-client (==2.95.0) ; extra == "google"
@@ -29,14 +29,17 @@ Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: openai (>=1.0.0,<2.0.0) ; extra == "openai"
 Requires-Dist: prompt-toolkit (>=3.0.43,<4.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
 Requires-Dist: pydantic (>=2.6.1,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
 Requires-Dist: safe-cli (>=1.0.0,<2.0.0)
 Requires-Dist: safe-eth-py (>=6.0.0b14,<7.0.0)
 Requires-Dist: scikit-learn (>=1.3.1,<2.0.0)
+Requires-Dist: sqlmodel (>=0.0.21,<0.0.22)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)
 Requires-Dist: subgrounds (>=1.9.1,<2.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: tavily-python (>=0.3.9,<0.4.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Requires-Dist: typer (>=0.9.0,<1.0.0)
 Requires-Dist: types-pytz (>=2024.1.0.20240203,<2025.0.0.0)

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/prediction_market_agent_tooling/config.py

@@ -43,6 +43,10 @@ class APIKeys(BaseSettings):
     LANGFUSE_PUBLIC_KEY: t.Optional[SecretStr] = None
     LANGFUSE_HOST: t.Optional[str] = None
 
+    TAVILY_API_KEY: t.Optional[SecretStr] = None
+
+    SQLALCHEMY_DB_URL: t.Optional[SecretStr] = None
+
     ENABLE_CACHE: bool = True
     CACHE_DIR: str = "./.cache"
 
@@ -134,6 +138,18 @@ class APIKeys(BaseSettings):
             self.LANGFUSE_HOST, "LANGFUSE_HOST missing in the environment."
         )
 
+    @property
+    def tavily_api_key(self) -> SecretStr:
+        return check_not_none(
+            self.TAVILY_API_KEY, "TAVILY_API_KEY missing in the environment."
+        )
+
+    @property
+    def sqlalchemy_db_url(self) -> SecretStr:
+        return check_not_none(
+            self.SQLALCHEMY_DB_URL, "SQLALCHEMY_DB_URL missing in the environment."
+        )
+
     def model_dump_public(self) -> dict[str, t.Any]:
         return {
             k: v

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -216,6 +216,19 @@ class DeployableTraderAgent(DeployableAgent):
     def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
         return have_bet_on_market_since(keys=APIKeys(), market=market, since=since)
 
+    def check_min_required_balance_to_operate(self, market_type: MarketType) -> None:
+        api_keys = APIKeys()
+        if self.min_required_balance_to_operate is None:
+            return
+        if market_type == MarketType.OMEN and not is_minimum_required_balance(
+            api_keys.public_key,
+            min_required_balance=self.min_required_balance_to_operate,
+        ):
+            raise OutOfFundsError(
+                f"Minimum required balance {self.min_required_balance_to_operate} "
+                f"for agent with address {api_keys.public_key} is not met."
+            )
+
     def pick_markets(
         self, market_type: MarketType, markets: t.Sequence[AgentMarket]
     ) -> t.Sequence[AgentMarket]:
@@ -280,15 +293,7 @@ class DeployableTraderAgent(DeployableAgent):
         if market_type == MarketType.OMEN:
             # Omen is specific, because the user (agent) needs to manually withdraw winnings from the market.
             redeem_from_all_user_positions(api_keys)
-            # Check if we have enough of balance to operate.
-            if self.min_required_balance_to_operate is not None:
-                if not is_minimum_required_balance(
-                    api_keys.public_key,
-                    min_required_balance=self.min_required_balance_to_operate,
-                ):
-                    raise OutOfFundsError(
-                        f"Minimum required balance {self.min_required_balance_to_operate} is not met."
-                    )
+            self.check_min_required_balance_to_operate(market_type)
             # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
             if self.min_balance_to_keep_in_native_currency is not None:
                 withdraw_wxdai_to_xdai_to_keep_balance(
@@ -304,6 +309,8 @@ class DeployableTraderAgent(DeployableAgent):
         available_markets = self.get_markets(market_type)
         markets = self.pick_markets(market_type, available_markets)
         for market in markets:
+            # We need to check it again before each market bet, as the balance might have changed.
+            self.check_min_required_balance_to_operate(market_type)
             result = self.answer_binary_market(market)
             if result is None:
                 logger.info(f"Skipping market {market} as no answer was provided")

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/prediction_market_agent_tooling/markets/data_models.py

@@ -48,7 +48,7 @@ class ResolvedBet(Bet):
     resolved_time: datetime
     profit: ProfitAmount
 
-    @computed_field  # type: ignore[misc]
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def is_correct(self) -> bool:
         return self.outcome == self.market_outcome

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/prediction_market_agent_tooling/monitor/langfuse/langfuse_wrapper.py

@@ -10,7 +10,7 @@ from prediction_market_agent_tooling.tools.utils import utcnow
 class LangfuseWrapper(BaseModel):
     agent_name: str
 
-    @computed_field  # type: ignore[misc] # Mypy issue: https://github.com/python/mypy/issues/14461
+    @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
     @cached_property
     def session_id(self) -> str:
         return f"{self.agent_name} - {utcnow()}"

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/prediction_market_agent_tooling/monitor/monitor.py

@@ -229,7 +229,8 @@ def monitor_agent(agent: DeployedAgent) -> None:
         )
         .interactive()
     )
-    st.altair_chart(
+
+    st.altair_chart(  # type: ignore
         per_day_accuracy_chart.mark_line()
         + per_day_accuracy_chart.transform_loess("x-axis-day", "Is Correct").mark_line(
             color="red", strokeDash=[5, 5]

prediction_market_agent_tooling-0.48.0/prediction_market_agent_tooling/tools/tavily_storage/tavily_models.py

@@ -0,0 +1,135 @@
+import typing as t
+from datetime import datetime
+
+from loguru import logger
+from pydantic import BaseModel
+from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlmodel import ARRAY, Field, Session, SQLModel, String, create_engine
+
+from prediction_market_agent_tooling.config import APIKeys
+
+
+class TavilyResult(BaseModel):
+    title: str
+    url: str
+    content: str
+    score: float
+    raw_content: str
+
+
+class TavilyResponse(BaseModel):
+    query: str
+    follow_up_questions: None = None
+    answer: str
+    images: list[str]
+    results: list[TavilyResult]
+    response_time: float
+
+
+class TavilyResponseModel(SQLModel, table=True):
+    __tablename__ = "tavily_response"
+    __table_args__ = {"extend_existing": True}
+    id: int | None = Field(None, primary_key=True)
+    agent_id: str = Field(index=True, nullable=False)
+    # Parameters used to execute the search
+    query: str
+    search_depth: str
+    topic: str
+    max_results: int
+    include_domains: list[str] | None = Field(
+        None, sa_column=Column(ARRAY(String), nullable=True)
+    )
+    exclude_domains: list[str] | None = Field(
+        None, sa_column=Column(ARRAY(String), nullable=True)
+    )
+    include_answer: bool
+    include_raw_content: bool
+    include_images: bool
+    use_cache: bool
+    # Datetime at the time of search response and response from the search
+    datetime_: datetime = Field(index=True, nullable=False)
+    response: dict[str, t.Any] = Field(sa_column=Column(JSONB, nullable=False))
+
+    @staticmethod
+    def from_model(
+        agent_id: str,
+        query: str,
+        search_depth: t.Literal["basic", "advanced"],
+        topic: t.Literal["general", "news"],
+        max_results: int,
+        include_domains: t.Sequence[str] | None,
+        exclude_domains: t.Sequence[str] | None,
+        include_answer: bool,
+        include_raw_content: bool,
+        include_images: bool,
+        use_cache: bool,
+        response: TavilyResponse,
+    ) -> "TavilyResponseModel":
+        return TavilyResponseModel(
+            agent_id=agent_id,
+            query=query,
+            search_depth=search_depth,
+            topic=topic,
+            max_results=max_results,
+            include_domains=sorted(include_domains) if include_domains else None,
+            exclude_domains=sorted(exclude_domains) if exclude_domains else None,
+            include_answer=include_answer,
+            include_raw_content=include_raw_content,
+            include_images=include_images,
+            use_cache=use_cache,
+            datetime_=datetime.now(),
+            response=response.model_dump(),
+        )
+
+
+class TavilyStorage:
+    def __init__(self, agent_id: str, sqlalchemy_db_url: str | None = None):
+        self.agent_id = agent_id
+        self.engine = create_engine(
+            sqlalchemy_db_url
+            if sqlalchemy_db_url
+            else APIKeys().sqlalchemy_db_url.get_secret_value()
+        )
+        self._initialize_db()
+
+    def _initialize_db(self) -> None:
+        """
+        Creates the tables if they don't exist
+        """
+
+        # trick for making models import mandatory - models must be imported for metadata.create_all to work
+        logger.debug(f"tables being added {TavilyResponseModel}")
+        SQLModel.metadata.create_all(self.engine)
+
+    def save(
+        self,
+        query: str,
+        search_depth: t.Literal["basic", "advanced"],
+        topic: t.Literal["general", "news"],
+        max_results: int,
+        include_domains: t.Sequence[str] | None,
+        exclude_domains: t.Sequence[str] | None,
+        include_answer: bool,
+        include_raw_content: bool,
+        include_images: bool,
+        use_cache: bool,
+        response: TavilyResponse,
+    ) -> None:
+        db_item = TavilyResponseModel.from_model(
+            agent_id=self.agent_id,
+            query=query,
+            search_depth=search_depth,
+            topic=topic,
+            max_results=max_results,
+            include_domains=include_domains,
+            exclude_domains=exclude_domains,
+            include_answer=include_answer,
+            include_raw_content=include_raw_content,
+            include_images=include_images,
+            use_cache=use_cache,
+            response=response,
+        )
+        with Session(self.engine) as session:
+            session.add(db_item)
+            session.commit()

prediction_market_agent_tooling-0.48.0/prediction_market_agent_tooling/tools/tavily_storage/tavily_storage.py

@@ -0,0 +1,97 @@
+import typing as t
+
+import tenacity
+from tavily import TavilyClient
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.tavily_storage.tavily_models import (
+    TavilyResponse,
+    TavilyStorage,
+)
+
+
+def tavily_search(
+    query: str,
+    search_depth: t.Literal["basic", "advanced"] = "advanced",
+    topic: t.Literal["general", "news"] = "general",
+    max_results: int = 5,
+    include_domains: t.Sequence[str] | None = None,
+    exclude_domains: t.Sequence[str] | None = None,
+    include_answer: bool = True,
+    include_raw_content: bool = True,
+    include_images: bool = True,
+    use_cache: bool = False,
+    api_keys: APIKeys | None = None,
+    tavily_storage: TavilyStorage | None = None,
+) -> TavilyResponse:
+    """
+    Wrapper around Tavily's search method that will save the response to `TavilyResponseCache`, if provided.
+
+    Argument default values are different from the original method, to return everything by default, because it can be handy in the future and it doesn't increase the costs.
+    """
+    response = _tavily_search(
+        query=query,
+        search_depth=search_depth,
+        topic=topic,
+        max_results=max_results,
+        include_domains=include_domains,
+        exclude_domains=exclude_domains,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_images=include_images,
+        use_cache=use_cache,
+        api_keys=api_keys,
+    )
+    response_parsed = TavilyResponse.model_validate(response)
+    if tavily_storage:
+        tavily_storage.save(
+            query=query,
+            search_depth=search_depth,
+            topic=topic,
+            max_results=max_results,
+            include_domains=include_domains,
+            exclude_domains=exclude_domains,
+            include_answer=include_answer,
+            include_raw_content=include_raw_content,
+            include_images=include_images,
+            use_cache=use_cache,
+            response=response_parsed,
+        )
+    return response_parsed
+
+
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1), reraise=True
+)
+def _tavily_search(
+    query: str,
+    search_depth: t.Literal["basic", "advanced"],
+    topic: t.Literal["general", "news"],
+    max_results: int,
+    include_domains: t.Sequence[str] | None,
+    exclude_domains: t.Sequence[str] | None,
+    include_answer: bool,
+    include_raw_content: bool,
+    include_images: bool,
+    use_cache: bool,
+    api_keys: APIKeys | None = None,
+) -> dict[str, t.Any]:
+    """
+    Internal minimalistic wrapper around Tavily's search method, that will retry if the call fails.
+    """
+    tavily = TavilyClient(
+        api_key=(api_keys or APIKeys()).tavily_api_key.get_secret_value()
+    )
+    response: dict[str, t.Any] = tavily.search(
+        query=query,
+        search_depth=search_depth,
+        topic=topic,
+        max_results=max_results,
+        include_domains=include_domains,
+        exclude_domains=exclude_domains,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_images=include_images,
+        use_cache=use_cache,
+    )
+    return response

{prediction_market_agent_tooling-0.47.0 → prediction_market_agent_tooling-0.48.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.47.0"
+version = "0.48.0"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"
@@ -37,12 +37,15 @@ google-api-python-client = { version = "2.95.0", optional = true}
 subgrounds = "^1.9.1"
 loguru = "^0.7.2"
 safe-eth-py = "^6.0.0b14"
-eth-account = "^0.8.0"
+eth-account = "^0.11.2"
 prompt-toolkit = "^3.0.43"
 safe-cli = "^1.0.0"
 langfuse = "^2.27.1"
 openai = { version = "^1.0.0", optional = true}
-base58 = "^2.1.1"
+tavily-python = "^0.3.9"
+sqlmodel = "^0.0.21"
+psycopg2-binary = "^2.9.9"
+base58 = ">=1.0.2,<2.0"
 
 [tool.poetry.extras]
 openai = ["openai"]
@@ -51,8 +54,10 @@ google = ["google-api-python-client"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"
-mypy = "^1.9.0"
+mypy = "^1.11.1"
 black = "^23.12.1"
+ape-foundry = "^0.8.2"
+eth-ape = "^0.8.10"
 
 [build-system]
 requires = ["poetry-core"]