prediction-market-agent-tooling 0.48.9__tar.gz → 0.48.11__tar.gz

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.48.9
+Version: 0.48.11
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -608,21 +608,25 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         )
         return [b for b in bets if b.fpmm.is_resolved_with_valid_answer]
 
-    def get_questions(
-        self,
+    @staticmethod
+    def get_reality_question_filters(
         user: HexAddress | None = None,
         claimed: bool | None = None,
         current_answer_before: datetime | None = None,
         finalized_before: datetime | None = None,
         finalized_after: datetime | None = None,
         id_in: list[str] | None = None,
+        question_id: HexBytes | None = None,
         question_id_in: list[HexBytes] | None = None,
-    ) -> list[RealityQuestion]:
+    ) -> dict[str, t.Any]:
         where_stms: dict[str, t.Any] = {}
 
         if user is not None:
             where_stms["user"] = user.lower()
 
+        if question_id is not None:
+            where_stms["questionId"] = question_id.hex()
+
         if claimed is not None:
             if claimed:
                 where_stms["historyHash"] = ZERO_BYTES.hex()
@@ -650,6 +654,27 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         if question_id_in is not None:
             where_stms["questionId_in"] = [x.hex() for x in question_id_in]
 
+        return where_stms
+
+    def get_questions(
+        self,
+        user: HexAddress | None = None,
+        claimed: bool | None = None,
+        current_answer_before: datetime | None = None,
+        finalized_before: datetime | None = None,
+        finalized_after: datetime | None = None,
+        id_in: list[str] | None = None,
+        question_id_in: list[HexBytes] | None = None,
+    ) -> list[RealityQuestion]:
+        where_stms: dict[str, t.Any] = self.get_reality_question_filters(
+            user=user,
+            claimed=claimed,
+            finalized_before=finalized_before,
+            finalized_after=finalized_after,
+            current_answer_before=current_answer_before,
+            id_in=id_in,
+            question_id_in=question_id_in,
+        )
         questions = self.realityeth_subgraph.Query.questions(where=where_stms)
         fields = self._get_fields_for_reality_questions(questions)
         result = self.sg.query_json(fields)
@@ -669,11 +694,24 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         items = self._parse_items_from_json(result)
         return [RealityAnswer.model_validate(i) for i in items]
 
-    def get_responses(self, question_id: HexBytes) -> list[RealityResponse]:
-        response = self.realityeth_subgraph.Response
-        where_stms = [
-            response.question.questionId == question_id.hex(),
-        ]
+    def get_responses(
+        self,
+        user: HexAddress | None = None,
+        question_id: HexBytes | None = None,
+        question_claimed: bool | None = None,
+        question_finalized_before: datetime | None = None,
+    ) -> list[RealityResponse]:
+        where_stms: dict[str, t.Any] = {}
+
+        if user is not None:
+            where_stms["user"] = user.lower()
+
+        where_stms["question_"] = self.get_reality_question_filters(
+            question_id=question_id,
+            claimed=question_claimed,
+            finalized_before=question_finalized_before,
+        )
+
         responses = self.realityeth_subgraph.Query.responses(where=where_stms)
         fields = self._get_fields_for_responses(responses)
         result = self.sg.query_json(fields)

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/prediction_market_agent_tooling/tools/tavily_storage/tavily_models.py

@@ -1,13 +1,24 @@
 import typing as t
-from datetime import datetime
+from datetime import datetime, timedelta
 
+import tenacity
 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 sqlmodel import (
+    ARRAY,
+    Field,
+    Session,
+    SQLModel,
+    String,
+    create_engine,
+    desc,
+    select,
+)
 
 from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class TavilyResult(BaseModel):
@@ -33,7 +44,7 @@ class TavilyResponseModel(SQLModel, table=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
+    query: str = Field(index=True, nullable=False)
     search_depth: str
     topic: str
     max_results: int
@@ -102,6 +113,7 @@ class TavilyStorage:
         logger.debug(f"tables being added {TavilyResponseModel}")
         SQLModel.metadata.create_all(self.engine)
 
+    @tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
     def save(
         self,
         query: str,
@@ -133,3 +145,38 @@ class TavilyStorage:
         with Session(self.engine) as session:
             session.add(db_item)
             session.commit()
+
+    @tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
+    def find(
+        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,
+        max_age: timedelta = timedelta(days=1),
+    ) -> TavilyResponse | None:
+        with Session(self.engine) as session:
+            sql_query = (
+                select(TavilyResponseModel)
+                .where(TavilyResponseModel.query == query)
+                .where(TavilyResponseModel.search_depth == search_depth)
+                .where(TavilyResponseModel.topic == topic)
+                .where(TavilyResponseModel.max_results == max_results)
+                .where(TavilyResponseModel.include_domains == include_domains)
+                .where(TavilyResponseModel.exclude_domains == exclude_domains)
+                .where(TavilyResponseModel.include_answer == include_answer)
+                .where(TavilyResponseModel.include_raw_content == include_raw_content)
+                .where(TavilyResponseModel.include_images == include_images)
+                .where(TavilyResponseModel.use_cache == use_cache)
+                .where(TavilyResponseModel.datetime_ >= utcnow() - max_age)
+            )
+            item = session.exec(
+                sql_query.order_by(desc(TavilyResponseModel.datetime_))
+            ).first()
+            return TavilyResponse.model_validate(item.response) if item else None

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/prediction_market_agent_tooling/tools/tavily_storage/tavily_storage.py

@@ -29,6 +29,21 @@ def tavily_search(
 
     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.
     """
+    if tavily_storage and (
+        response_parsed := tavily_storage.find(
+            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_parsed
     response = _tavily_search(
         query=query,
         search_depth=search_depth,

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/prediction_market_agent_tooling/tools/web3_utils.py

@@ -10,7 +10,7 @@ from gnosis.safe.safe import Safe
 from pydantic.types import SecretStr
 from web3 import Web3
 from web3.constants import HASH_ZERO
-from web3.types import Nonce, TxParams, TxReceipt, Wei
+from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt, Wei
 
 from prediction_market_agent_tooling.gtypes import (
     ABI,
@@ -118,9 +118,10 @@ def prepare_tx(
     from_address: ChecksumAddress | None,
     function_name: str,
     function_params: Optional[list[Any] | dict[str, Any]] = None,
+    access_list: Optional[AccessList] = None,
     tx_params: Optional[TxParams] = None,
 ) -> TxParams:
-    tx_params_new = _prepare_tx_params(web3, from_address, tx_params)
+    tx_params_new = _prepare_tx_params(web3, from_address, access_list, tx_params)
     contract = web3.eth.contract(address=contract_address, abi=contract_abi)
 
     # Build the transaction.
@@ -132,6 +133,7 @@ def prepare_tx(
 def _prepare_tx_params(
     web3: Web3,
     from_address: ChecksumAddress | None,
+    access_list: Optional[AccessList] = None,
     tx_params: Optional[TxParams] = None,
 ) -> TxParams:
     # Fill in required defaults, if not provided.
@@ -151,6 +153,9 @@ def _prepare_tx_params(
         from_checksummed = Web3.to_checksum_address(tx_params_new["from"])
         tx_params_new["nonce"] = web3.eth.get_transaction_count(from_checksummed)
 
+    if access_list is not None:
+        tx_params_new["accessList"] = access_list
+
     return tx_params_new
 
 
@@ -211,6 +216,36 @@ def send_function_on_contract_tx_using_safe(
     tx_params: Optional[TxParams] = None,
     timeout: int = 180,
 ) -> TxReceipt:
+    if not web3.provider.endpoint_uri:  # type: ignore
+        raise EnvironmentError("RPC_URL not available in web3 object.")
+    ethereum_client = EthereumClient(ethereum_node_url=URI(web3.provider.endpoint_uri))  # type: ignore
+    s = Safe(safe_address, ethereum_client)  # type: ignore
+    safe_master_copy_address = s.retrieve_master_copy_address()
+    eoa_public_key = private_key_to_public_key(from_private_key)
+    # See https://ethereum.stackexchange.com/questions/123750/how-to-implement-eip-2930-access-list for details,
+    # required to not go out-of-gas when calling a contract functions using Safe.
+    access_list = AccessList(
+        [
+            AccessListEntry(
+                {
+                    "address": eoa_public_key,
+                    "storageKeys": [HASH_ZERO],
+                }
+            ),
+            AccessListEntry(
+                {
+                    "address": safe_address,
+                    "storageKeys": [HASH_ZERO],
+                }
+            ),
+            AccessListEntry(
+                {
+                    "address": safe_master_copy_address,
+                    "storageKeys": [],
+                }
+            ),
+        ]
+    )
     tx_params = prepare_tx(
         web3=web3,
         contract_address=contract_address,
@@ -218,13 +253,9 @@ def send_function_on_contract_tx_using_safe(
         from_address=safe_address,
         function_name=function_name,
         function_params=function_params,
+        access_list=access_list,
         tx_params=tx_params,
     )
-
-    if not web3.provider.endpoint_uri:  # type: ignore
-        raise EnvironmentError(f"RPC_URL not available in web3 object.")
-    ethereum_client = EthereumClient(ethereum_node_url=URI(web3.provider.endpoint_uri))  # type: ignore
-    s = Safe(safe_address, ethereum_client)  # type: ignore
     safe_tx = s.build_multisig_tx(
         to=Web3.to_checksum_address(tx_params["to"]),
         data=HexBytes(tx_params["data"]),
@@ -270,7 +301,7 @@ def send_xdai_to(
     tx_params_new: TxParams = {"value": value, "to": to_address}
     if tx_params:
         tx_params_new.update(tx_params)
-    tx_params_new = _prepare_tx_params(web3, from_address, tx_params_new)
+    tx_params_new = _prepare_tx_params(web3, from_address, tx_params=tx_params_new)
 
     # We need gas and gasPrice here (and not elsewhere) because we are not calling
     # contract.functions.myFunction().build_transaction, which autofills some params

{prediction_market_agent_tooling-0.48.9 → prediction_market_agent_tooling-0.48.11}/pyproject.toml

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