prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/tools/db/db_manager.py

@@ -1,7 +1,10 @@
+import asyncio
 import hashlib
+import threading
 from contextlib import contextmanager
 from typing import Generator, Sequence
 
+from pydantic import SecretStr
 from sqlalchemy import Connection
 from sqlmodel import Session, SQLModel, create_engine
 
@@ -79,3 +82,59 @@ class DBManager:
         if tables_to_create:
             for table in tables_to_create:
                 self.cache_table_initialized[table.name] = True
+
+
+class EnsureTableManager:
+    """
+    Manages database table initialization with thread-safe and async-safe locking.
+    Ensures tables are created only once per database URL.
+    """
+
+    def __init__(self, tables: Sequence[type[SQLModel]]) -> None:
+        """
+        Initialize the table manager with the tables to manage.
+
+        Args:
+            tables: Sequence of SQLModel table classes to ensure in the database.
+        """
+        # Ensure tables only once, as it's a time costly operation.
+        self._tables = tables
+        self._lock_thread = threading.Lock()
+        self._lock_async = asyncio.Lock()
+        self._ensured: dict[SecretStr, bool] = {}
+
+    def is_ensured(self, db_url: SecretStr) -> bool:
+        """Check if tables have been ensured for the given database URL."""
+        return self._ensured.get(db_url, False)
+
+    def mark_ensured(self, db_url: SecretStr) -> None:
+        """Mark tables as ensured for the given database URL."""
+        self._ensured[db_url] = True
+
+    def ensure_tables_sync(self, api_keys: APIKeys) -> None:
+        """
+        Ensure tables exist for the given API keys (synchronous version).
+        Thread-safe with double-checked locking pattern.
+        """
+        if not self.is_ensured(api_keys.sqlalchemy_db_url):
+            with self._lock_thread:
+                if not self.is_ensured(api_keys.sqlalchemy_db_url):
+                    self._create_tables(api_keys)
+                    self.mark_ensured(api_keys.sqlalchemy_db_url)
+
+    async def ensure_tables_async(self, api_keys: APIKeys) -> None:
+        """
+        Ensure tables exist for the given API keys (asynchronous version).
+        Async-safe with double-checked locking pattern.
+        """
+        if not self.is_ensured(api_keys.sqlalchemy_db_url):
+            async with self._lock_async:
+                if not self.is_ensured(api_keys.sqlalchemy_db_url):
+                    await asyncio.to_thread(self._create_tables, api_keys)
+                    self.mark_ensured(api_keys.sqlalchemy_db_url)
+
+    def _create_tables(self, api_keys: APIKeys) -> None:
+        """Create the database tables."""
+        DBManager(api_keys.sqlalchemy_db_url.get_secret_value()).create_tables(
+            list(self._tables)
+        )

prediction_market_agent_tooling/tools/hexbytes_custom.py

@@ -11,7 +11,7 @@ from pydantic_core.core_schema import (
     with_info_before_validator_function,
 )
 
-hex_serializer = plain_serializer_function_ser_schema(function=lambda x: x.hex())
+hex_serializer = plain_serializer_function_ser_schema(function=lambda x: x.to_0x_hex())
 
 
 class BaseHex:
@@ -60,6 +60,9 @@ class HexBytes(HexBytesBase, BaseHex):
         value = hex_str[2:] if hex_str.startswith("0x") else hex_str
         return super().fromhex(value)
 
+    def __repr__(self) -> str:
+        return f'HexBytes("{self.to_0x_hex()}")'
+
     @classmethod
     def __eth_pydantic_validate__(
         cls, value: t.Any, info: ValidationInfo | None = None

prediction_market_agent_tooling/tools/httpx_cached_client.py

@@ -1,14 +1,23 @@
+from datetime import timedelta
+
 import hishel
+import httpx
+
+from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 
+ONE_DAY = timedelta(days=1)
 
-class HttpxCachedClient:
-    def __init__(self) -> None:
+
+class HttpxCachedClient(metaclass=SingletonMeta):
+    def __init__(self, ttl: timedelta = ONE_DAY) -> None:
         storage = hishel.FileStorage(
-            ttl=24 * 60 * 60,
-            check_ttl_every=1 * 60 * 60,
+            ttl=ttl.total_seconds(),
+            check_ttl_every=60,
         )
         controller = hishel.Controller(force_cache=True)
-        self.client = hishel.CacheClient(storage=storage, controller=controller)
+        self.client: httpx.Client = hishel.CacheClient(
+            storage=storage, controller=controller
+        )
 
-    def get_client(self) -> hishel.CacheClient:
+    def get_client(self) -> httpx.Client:
         return self.client

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -5,7 +5,9 @@ from langfuse import Langfuse
 from langfuse.client import TraceWithDetails
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.deploy.agent import MarketType
 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 (
     CategoricalProbabilisticAnswer,
     PlacedTrade,
@@ -16,12 +18,13 @@ from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
+from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 class ProcessMarketTrace(BaseModel):
     timestamp: int
-    market: OmenAgentMarket
+    market: SeerAgentMarket | OmenAgentMarket
     answer: CategoricalProbabilisticAnswer
     trades: list[PlacedTrade]
 
@@ -40,13 +43,18 @@ class ProcessMarketTrace(BaseModel):
     def from_langfuse_trace(
         trace: TraceWithDetails,
     ) -> t.Optional["ProcessMarketTrace"]:
-        market = trace_to_omen_agent_market(trace)
+        market = trace_to_agent_market(trace)
         answer = trace_to_answer(trace)
         trades = trace_to_trades(trace)
 
         if not market or not answer or not trades:
             return None
 
+        if not isinstance(market, (SeerAgentMarket, OmenAgentMarket)):
+            raise ValueError(
+                f"Market type {type(market)} is not supported for ProcessMarketTrace"
+            )
+
         return ProcessMarketTrace(
             market=market,
             answer=answer,
@@ -68,6 +76,7 @@ def get_traces_for_agent(
     client: Langfuse,
     to_timestamp: DatetimeUTC | None = None,
     tags: str | list[str] | None = None,
+    limit: int | None = None,
 ) -> list[TraceWithDetails]:
     """
     Fetch agent traces using pagination
@@ -98,20 +107,27 @@ def get_traces_for_agent(
         if has_output:
             agent_traces = [t for t in agent_traces if t.output is not None]
         all_agent_traces.extend(agent_traces)
+        if limit is not None and len(all_agent_traces) >= limit:
+            all_agent_traces = all_agent_traces[:limit]
+            break
     return all_agent_traces
 
 
-def trace_to_omen_agent_market(trace: TraceWithDetails) -> OmenAgentMarket | None:
+def trace_to_agent_market(trace: TraceWithDetails) -> AgentMarket | None:
     if not trace.input:
         logger.warning(f"No input in the trace: {trace}")
         return None
     if not trace.input["args"]:
         logger.warning(f"No args in the trace: {trace}")
         return None
-    assert len(trace.input["args"]) == 2 and trace.input["args"][0] == "omen"
+    assert len(trace.input["args"]) == 2
+
+    market_type = MarketType(trace.input["args"][0])
+    market_class = market_type.market_class
+
     try:
         # If the market model is invalid (e.g. outdated), it will raise an exception
-        market = OmenAgentMarket.model_validate(trace.input["args"][1])
+        market = market_class.model_validate(trace.input["args"][1])
         return market
     except Exception as e:
         logger.warning(f"Market not parsed from langfuse because: {e}")
@@ -155,9 +171,6 @@ def get_trace_for_bet(
             not in WRAPPED_XDAI_CONTRACT_ADDRESS
         ):
             # TODO: We need to compute bet amount token in USD here, but at the time of bet placement!
-            logger.warning(
-                "This currently works only for WXDAI markets, because we need to compare against USD value."
-            )
             continue
         # Cannot use exact comparison due to gas fees
         if (

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/perplexity/perplexity_client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, List, Optional
+
+import httpx
+from pydantic import SecretStr
+
+from prediction_market_agent_tooling.tools.perplexity.perplexity_models import (
+    PerplexityModelSettings,
+    PerplexityRequestParameters,
+    PerplexityResponse,
+)
+
+
+class PerplexityModel:
+    def __init__(
+        self,
+        model_name: str,
+        *,
+        api_key: SecretStr,
+        completition_endpoint: str = "https://api.perplexity.ai/chat/completions",
+    ) -> None:
+        self.model_name = model_name
+        self.api_key = api_key
+        self.completition_endpoint = completition_endpoint
+
+    async def request(
+        self,
+        messages: List[dict[str, str]],
+        model_settings: Optional[PerplexityModelSettings],
+        model_request_parameters: PerplexityRequestParameters,
+    ) -> PerplexityResponse:
+        payload: Dict[str, Any] = {"model": self.model_name, "messages": messages}
+
+        if model_settings:
+            model_settings_dict = model_settings.model_dump()
+            model_settings_dict = {
+                k: v for k, v in model_settings_dict.items() if v is not None
+            }
+            payload.update(model_settings_dict)
+
+        params_dict = model_request_parameters.model_dump()
+        params_dict = {k: v for k, v in params_dict.items() if v is not None}
+
+        # Extract and handle search_context_size specially
+        if "search_context_size" in params_dict:
+            search_context_size = params_dict.pop("search_context_size")
+            payload["web_search_options"] = {"search_context_size": search_context_size}
+
+        # Add remaining Perplexity parameters to payload
+        payload.update(params_dict)
+
+        try:
+            async with httpx.AsyncClient(timeout=180) as client:
+                response = await client.post(
+                    self.completition_endpoint,
+                    headers={
+                        "Authorization": f"Bearer {self.api_key.get_secret_value()}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                )
+                response.raise_for_status()
+                result: dict[str, Any] = response.json()
+
+                choices = result.get("choices", [])
+                if not choices:
+                    raise ValueError("Invalid response: no choices")
+
+                content = choices[0].get("message", {}).get("content")
+                if not content:
+                    raise ValueError("Invalid response: no content")
+
+                return PerplexityResponse(
+                    content=content,
+                    citations=result.get("citations", []),
+                    usage=result.get("usage", {}),
+                )
+        except httpx.HTTPStatusError as e:
+            raise ValueError(
+                f"HTTP error from Perplexity API: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except httpx.RequestError as e:
+            raise ValueError(f"Request error to Perplexity API: {str(e)}") from e
+        except Exception as e:
+            raise ValueError(
+                f"Unexpected error in Perplexity API request: {str(e)}"
+            ) from e

prediction_market_agent_tooling/tools/perplexity/perplexity_models.py

@@ -0,0 +1,26 @@
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel
+
+
+class PerplexityRequestParameters(BaseModel):
+    search_context_size: Optional[Literal["low", "medium", "high"]]
+    search_recency_filter: Optional[Literal["any", "day", "week", "month", "year"]]
+    search_return_related_questions: Optional[bool]
+    search_domain_filter: Optional[List[str]]
+    search_after_date_filter: Optional[str]
+    search_before_date_filter: Optional[str]
+
+
+class PerplexityResponse(BaseModel):
+    content: str
+    citations: list[str]
+    usage: dict[str, Any]
+
+
+class PerplexityModelSettings(BaseModel):
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None

prediction_market_agent_tooling/tools/perplexity/perplexity_search.py

@@ -0,0 +1,73 @@
+import asyncio
+import typing as t
+from datetime import date, timedelta
+
+import tenacity
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.caches.db_cache import db_cache
+from prediction_market_agent_tooling.tools.perplexity.perplexity_client import (
+    PerplexityModel,
+)
+from prediction_market_agent_tooling.tools.perplexity.perplexity_models import (
+    PerplexityModelSettings,
+    PerplexityRequestParameters,
+    PerplexityResponse,
+)
+
+SYSTEM_PROMPT = "You are a helpful search assistant. Your task is to provide accurate information based on web searches."
+
+
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
+@db_cache(
+    max_age=timedelta(days=1),
+    ignore_args=["api_keys"],
+    log_error_on_unsavable_data=False,
+)
+def perplexity_search(
+    query: str,
+    api_keys: APIKeys,
+    search_context_size: t.Literal["low", "medium", "high"] = "medium",
+    search_recency_filter: t.Literal["any", "day", "week", "month", "year"]
+    | None = None,
+    search_filter_before_date: date | None = None,
+    search_filter_after_date: date | None = None,
+    search_return_related_questions: bool | None = None,
+    include_domains: list[str] | None = None,
+    temperature: float = 0,
+    model_name: str = "sonar-pro",
+    max_tokens: int = 2048,
+) -> PerplexityResponse:
+    # Create messages in ModelMessage format
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": query},
+    ]
+
+    # Define special parameters for the request and create the settings
+    model_settings = PerplexityModelSettings(
+        max_tokens=max_tokens, temperature=temperature
+    )
+
+    # Create a basic request parameters object with required base parameters
+    request_params = PerplexityRequestParameters(
+        search_domain_filter=include_domains,
+        search_after_date_filter=search_filter_after_date.strftime("%Y-%m-%d")
+        if search_filter_after_date
+        else None,
+        search_before_date_filter=search_filter_before_date.strftime("%Y-%m-%d")
+        if search_filter_before_date
+        else None,
+        search_recency_filter=search_recency_filter,
+        search_context_size=search_context_size,
+        search_return_related_questions=search_return_related_questions,
+    )
+
+    model = PerplexityModel(model_name=model_name, api_key=api_keys.perplexity_api_key)
+    return asyncio.run(
+        model.request(
+            messages=messages,
+            model_settings=model_settings,
+            model_request_parameters=request_params,
+        )
+    )

prediction_market_agent_tooling/tools/rephrase.py

@@ -0,0 +1,71 @@
+import tenacity
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.caches.db_cache import db_cache
+from prediction_market_agent_tooling.tools.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+from prediction_market_agent_tooling.tools.utils import (
+    LLM_SEED,
+    LLM_SUPER_LOW_TEMPERATURE,
+)
+
+REPHRASE_QUESTION_PROMPT = """Given the following question of main interest: {question}
+
+But it's conditioned on `{parent_question}` resolving to `{needed_parent_outcome}`.
+
+Rewrite the main question to contain the parent question in the correct form. 
+
+The main question will be used as a prediction market, so it does need to be rephrased using the parent question properly. Such that the probability of the main question also accounts for the conditioned outcome.
+
+For example:
+```
+Main question: What is the probability of <X> happening before <date>?
+Conditioned on: Will <Y> happen before <another-date>?
+Rephrased: What is the joint probability of Y happening before <another-date> and then X happening before <date>?
+```
+
+Output only the rephrased question.
+"""
+
+
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
+@observe()
+@db_cache
+def rephrase_question_to_unconditional(
+    question: str,
+    parent_question: str,
+    needed_parent_outcome: str,
+    engine: str = "gpt-4.1",
+    temperature: float = LLM_SUPER_LOW_TEMPERATURE,
+    seed: int = LLM_SEED,
+    prompt_template: str = REPHRASE_QUESTION_PROMPT,
+    max_tokens: int = 1024,
+) -> str:
+    try:
+        from langchain.prompts import ChatPromptTemplate
+        from langchain_openai import ChatOpenAI
+    except ImportError:
+        raise ImportError("langchain not installed")
+
+    llm = ChatOpenAI(
+        model_name=engine,
+        temperature=temperature,
+        seed=seed,
+        openai_api_key=APIKeys().openai_api_key,
+    )
+
+    prompt = ChatPromptTemplate.from_template(template=prompt_template)
+    messages = prompt.format_messages(
+        question=question,
+        parent_question=parent_question,
+        needed_parent_outcome=needed_parent_outcome,
+    )
+    completion = str(
+        llm.invoke(
+            messages, max_tokens=max_tokens, config=get_langfuse_langchain_config()
+        ).content
+    )
+
+    return completion

prediction_market_agent_tooling/tools/singleton.py

@@ -8,16 +8,21 @@ class SingletonMeta(type, t.Generic[_T]):
     The Singleton class can be implemented in different ways in Python. Some
     possible methods include: base class, decorator, metaclass. We will use the
     metaclass because it is best suited for this purpose.
+
+    This version creates a unique instance for each unique set of __init__ arguments.
     """
 
-    _instances: dict[t.Any, _T] = {}
+    _instances: dict[
+        tuple[t.Any, tuple[t.Any, ...], tuple[tuple[str, t.Any], ...]], _T
+    ] = {}
 
     def __call__(self, *args: t.Any, **kwargs: t.Any) -> _T:
         """
-        Possible changes to the value of the `__init__` argument do not affect
-        the returned instance.
+        Different __init__ arguments will result in different instances.
         """
-        if self not in self._instances:
+        # Create a key based on the class, args, and kwargs (sorted for consistency)
+        key = (self, args, tuple(sorted(kwargs.items())))
+        if key not in self._instances:
             instance = super().__call__(*args, **kwargs)
-            self._instances[self] = instance
-        return self._instances[self]
+            self._instances[key] = instance
+        return self._instances[key]