prediction-market-agent-tooling 0.22.0__tar.gz → 0.24.0__tar.gz

{prediction_market_agent_tooling-0.22.0 → prediction_market_agent_tooling-0.24.0}/PKG-INFO

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

{prediction_market_agent_tooling-0.22.0 → prediction_market_agent_tooling-0.24.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -84,62 +84,30 @@ class Answer(BaseModel):
 
 
 class DeployableAgent:
-    bet_on_n_markets_per_run: int = 1
-
     def __init__(self) -> None:
         self.langfuse_wrapper = LangfuseWrapper(agent_name=self.__class__.__name__)
         self.load()
 
     def __init_subclass__(cls, **kwargs: t.Any) -> None:
-        if cls.__init__ is not DeployableAgent.__init__:
+        if "DeployableAgent" not in str(
+            cls.__init__
+        ) and "DeployableTraderAgent" not in str(cls.__init__):
             raise TypeError(
-                "Cannot override __init__ method of DeployableAgent class, please override the `load` method to set up the agent."
+                "Cannot override __init__ method of deployable agent class, please override the `load` method to set up the agent."
             )
 
     def load(self) -> None:
         pass
 
-    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 pick_markets(self, markets: t.Sequence[AgentMarket]) -> t.Sequence[AgentMarket]:
-        """
-        Subclasses can implement their own logic instead of this one, or on top of this one.
-        By default, it picks only the first {n_markets_per_run} markets where user didn't bet recently and it's a reasonable question.
-        """
-        picked: list[AgentMarket] = []
-
-        for market in markets:
-            if len(picked) >= self.bet_on_n_markets_per_run:
-                break
-
-            if self.have_bet_on_market_since(market, since=timedelta(hours=24)):
-                continue
-
-            # Do as a last check, as it uses paid OpenAI API.
-            if not is_predictable_binary(market.question):
-                continue
-
-            picked.append(market)
-
-        return picked
-
-    def answer_binary_market(self, market: AgentMarket) -> Answer | None:
-        """
-        Answer the binary market. This method must be implemented by the subclass.
-        """
-        raise NotImplementedError("This method must be implemented by the subclass")
-
     def deploy_local(
         self,
         market_type: MarketType,
         sleep_time: float,
         timeout: float,
-        place_bet: bool,
     ) -> None:
         start_time = time.time()
         while True:
-            self.run(market_type=market_type, _place_bet=place_bet)
+            self.run(market_type=market_type)
             time.sleep(sleep_time)
             if time.time() - start_time > timeout:
                 break
@@ -223,6 +191,51 @@ def {entrypoint_function_name}(request) -> str:
         if cron_schedule:
             schedule_deployed_gcp_function(fname, cron_schedule=cron_schedule)
 
+    def run(self, market_type: MarketType) -> None:
+        raise NotImplementedError("This method must be implemented by the subclass.")
+
+    def get_gcloud_fname(self, market_type: MarketType) -> str:
+        return f"{self.__class__.__name__.lower()}-{market_type}-{datetime.now().strftime('%Y-%m-%d--%H-%M-%S')}"
+
+
+class DeployableTraderAgent(DeployableAgent):
+    bet_on_n_markets_per_run: int = 1
+
+    def __init__(self, place_bet: bool = True) -> None:
+        super().__init__()
+        self.place_bet = place_bet
+
+    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 pick_markets(self, markets: t.Sequence[AgentMarket]) -> t.Sequence[AgentMarket]:
+        """
+        Subclasses can implement their own logic instead of this one, or on top of this one.
+        By default, it picks only the first {n_markets_per_run} markets where user didn't bet recently and it's a reasonable question.
+        """
+        picked: list[AgentMarket] = []
+
+        for market in markets:
+            if len(picked) >= self.bet_on_n_markets_per_run:
+                break
+
+            if self.have_bet_on_market_since(market, since=timedelta(hours=24)):
+                continue
+
+            # Do as a last check, as it uses paid OpenAI API.
+            if not is_predictable_binary(market.question):
+                continue
+
+            picked.append(market)
+
+        return picked
+
+    def answer_binary_market(self, market: AgentMarket) -> Answer | None:
+        """
+        Answer the binary market. This method must be implemented by the subclass.
+        """
+        raise NotImplementedError("This method must be implemented by the subclass")
+
     def calculate_bet_amount(self, answer: Answer, market: AgentMarket) -> BetAmount:
         """
         Calculate the bet amount. By default, it returns the minimum bet amount.
@@ -253,7 +266,7 @@ def {entrypoint_function_name}(request) -> str:
             # Omen is specific, because the user (agent) needs to manually withdraw winnings from the market.
             redeem_from_all_user_positions(private_credentials)
 
-    def process_bets(self, market_type: MarketType, _place_bet: bool = True) -> None:
+    def process_bets(self, market_type: MarketType) -> None:
         """
         Processes bets placed by agents on a given market.
         """
@@ -264,7 +277,7 @@ def {entrypoint_function_name}(request) -> str:
             if result is None:
                 logger.debug(f"Skipping market {market} as no answer was provided")
                 continue
-            if _place_bet:
+            if self.place_bet:
                 amount = self.calculate_bet_amount(result, market)
                 logger.debug(
                     f"Placing bet on {market} with result {result} and amount {amount}"
@@ -277,10 +290,7 @@ def {entrypoint_function_name}(request) -> str:
     def after(self, market_type: MarketType) -> None:
         pass
 
-    def run(self, market_type: MarketType, _place_bet: bool = True) -> None:
+    def run(self, market_type: MarketType) -> None:
         self.before(market_type)
-        self.process_bets(market_type, _place_bet)
+        self.process_bets(market_type)
         self.after(market_type)
-
-    def get_gcloud_fname(self, market_type: MarketType) -> str:
-        return f"{self.__class__.__name__.lower()}-{market_type}-{datetime.now().strftime('%Y-%m-%d--%H-%M-%S')}"

{prediction_market_agent_tooling-0.22.0 → prediction_market_agent_tooling-0.24.0}/prediction_market_agent_tooling/deploy/agent_example.py

@@ -3,13 +3,13 @@ import typing as t
 
 from prediction_market_agent_tooling.deploy.agent import (
     Answer,
-    DeployableAgent,
+    DeployableTraderAgent,
     Probability,
 )
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 
 
-class DeployableCoinFlipAgent(DeployableAgent):
+class DeployableCoinFlipAgent(DeployableTraderAgent):
     def pick_markets(self, markets: t.Sequence[AgentMarket]) -> t.Sequence[AgentMarket]:
         return random.sample(markets, 1)
 
@@ -23,6 +23,6 @@ class DeployableCoinFlipAgent(DeployableAgent):
         )
 
 
-class DeployableAlwaysRaiseAgent(DeployableAgent):
+class DeployableAlwaysRaiseAgent(DeployableTraderAgent):
     def answer_binary_market(self, market: AgentMarket) -> Answer | None:
         raise RuntimeError("I always raise!")

prediction_market_agent_tooling-0.24.0/prediction_market_agent_tooling/loggers.py

@@ -0,0 +1,75 @@
+import logging
+import sys
+import warnings
+from enum import Enum
+
+from loguru import logger
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class LogFormat(str, Enum):
+    DEFAULT = "default"
+    GCP = "gcp"
+
+
+class LogConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env", env_file_encoding="utf-8", extra="ignore"
+    )
+
+    LOG_FORMAT: LogFormat = LogFormat.DEFAULT
+
+
+GCP_LOG_LOGURU_FORMAT = (
+    "{level:<.1}{time:MMDD HH:mm:ss} {process} {name}:{line}] {message}"
+)
+GCP_LOG_LOGGING_FORMAT, GCP_LOG_FORMAT_LOGGING_DATEFMT = (
+    "%(levelname).1s%(asctime)s %(process)d %(name)s:%(lineno)d] %(message)s"
+), "%m%d %H:%M:%S"
+
+
+def patch_logger() -> None:
+    config = LogConfig()
+
+    if config.LOG_FORMAT == LogFormat.GCP:
+        format_loguru = GCP_LOG_LOGURU_FORMAT
+        format_logging = GCP_LOG_LOGGING_FORMAT
+        datefmt_logging = GCP_LOG_FORMAT_LOGGING_DATEFMT
+
+    elif config.LOG_FORMAT == LogFormat.DEFAULT:
+        format_loguru, format_logging, datefmt_logging = None, None, None
+
+    else:
+        raise ValueError(f"Unknown log format: {config.LOG_FORMAT}")
+
+    # Change built-in logging.
+    if format_logging is not None:
+        logging.basicConfig(
+            level=logging.DEBUG, format=format_logging, datefmt=datefmt_logging
+        )
+
+    # Change loguru.
+    if format_loguru is not None:
+        logger.remove()
+        logger.add(
+            sys.stdout,
+            format=format_loguru,
+            level="DEBUG",  # Can be the lowest level, higher ones will use by default this one.
+            colorize=True,
+        )
+
+    # Change warning formatting to a simpler one (no source code in a new line).
+    warnings.formatwarning = simple_warning_format
+    # Use logging module for warnings.
+    logging.captureWarnings(True)
+
+    logger.info(f"Patched logger for {config.LOG_FORMAT.value} format.")
+
+
+def simple_warning_format(message, category, filename, lineno, line=None):  # type: ignore[no-untyped-def] # Not typed in the standard library neither.
+    return f"{category.__name__}: {message}"
+
+
+if not getattr(logger, "_patched", False):
+    patch_logger()
+    logger._patched = True  # type: ignore[attr-defined] # Hacky way to store a flag on the logger object, to not patch it multiple times.

{prediction_market_agent_tooling-0.22.0 → prediction_market_agent_tooling-0.24.0}/pyproject.toml

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

prediction_market_agent_tooling-0.22.0/prediction_market_agent_tooling/loggers.py

@@ -1,54 +0,0 @@
-import sys
-import typing as t
-from enum import Enum
-
-from loguru import logger
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-if t.TYPE_CHECKING:
-    from loguru import Logger
-
-
-class LogFormat(str, Enum):
-    DEFAULT = "default"
-    GCP = "gcp"
-
-
-class LogConfig(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=".env", env_file_encoding="utf-8", extra="ignore"
-    )
-
-    LOG_FORMAT: LogFormat = LogFormat.DEFAULT
-
-
-GCP_LOG_FORMAT = "{level:<.1}{time:MMDD HH:mm:ss.SSSSSS} {process} {name}:{line}] {message} | {extra}"
-
-
-def patch_logger(logger: "Logger") -> None:
-    config = LogConfig()
-
-    if config.LOG_FORMAT == LogFormat.GCP:
-        format_ = GCP_LOG_FORMAT
-
-    elif config.LOG_FORMAT == LogFormat.DEFAULT:
-        format_ = None
-
-    else:
-        raise ValueError(f"Unknown log format: {config.LOG_FORMAT}")
-
-    if format_ is not None:
-        logger.remove()
-        logger.add(
-            sys.stdout,
-            format=format_,
-            level="DEBUG",  # Can be the lowest level, higher ones will use by default this one.
-            colorize=True,
-        )
-
-    logger.info(f"Patched logger for {config.LOG_FORMAT.value} format.")
-
-
-if not getattr(logger, "_patched", False):
-    patch_logger(logger)
-    logger._patched = True  # type: ignore[attr-defined] # Hacky way to store a flag on the logger object, to not patch it multiple times.