prediction-market-agent-tooling 0.65.5__tar.gz → 0.65.6__tar.gz

{prediction_market_agent_tooling-0.65.5 → prediction_market_agent_tooling-0.65.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.65.5
+Version: 0.65.6
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.65.5 → prediction_market_agent_tooling-0.65.6}/prediction_market_agent_tooling/config.py

@@ -65,6 +65,8 @@ class APIKeys(BaseSettings):
 
     SQLALCHEMY_DB_URL: t.Optional[SecretStr] = None
 
+    PERPLEXITY_API_KEY: t.Optional[SecretStr] = None
+
     ENABLE_CACHE: bool = False
     CACHE_DIR: str = "./.cache"
 
@@ -259,6 +261,12 @@ class APIKeys(BaseSettings):
             if self.model_fields[k].annotation not in SECRET_TYPES and v is not None
         }
 
+    @property
+    def perplexity_api_key(self) -> SecretStr:
+        return check_not_none(
+            self.PERPLEXITY_API_KEY, "PERPLEXITY_API_KEY missing in the environment."
+        )
+
     def model_dump_secrets(self) -> dict[str, t.Any]:
         return {
             k: v.get_secret_value() if isinstance(v, SecretStr) else v

{prediction_market_agent_tooling-0.65.5 → prediction_market_agent_tooling-0.65.6}/prediction_market_agent_tooling/logprobs_parser.py

@@ -61,7 +61,8 @@ class LogprobsParser:
             (
                 i
                 for i in range(result_start_index, len(logprobs))
-                if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
+                if logprobs[i]["token"]
+                in {",", '"', ",\n", "\",\n'", '",\n', '"\n', "\n"}
             ),
             len(logprobs) - 1,
         )

prediction_market_agent_tooling-0.65.6/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-0.65.6/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-0.65.6/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-0.65.5 → prediction_market_agent_tooling-0.65.6}/pyproject.toml

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