prediction-market-agent-tooling 0.68.0.dev999__tar.gz → 0.69.0__tar.gz

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.68.0.dev999
+Version: 0.69.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -14,11 +14,11 @@ Provides-Extra: openai
 Provides-Extra: optuna
 Requires-Dist: autoflake (>=2.2.1,<3.0.0)
 Requires-Dist: base58 (>=1.0.2,<2.0)
-Requires-Dist: cowdao-cowpy (==1.0.0rc5)
+Requires-Dist: cowdao-cowpy (==1.0.1)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
-Requires-Dist: eth-account (>=0.8.0,<0.12.0)
+Requires-Dist: eth-account (>=0.13.0,<0.14.0)
 Requires-Dist: eth-keys (>=0.6.1,<0.7.0)
-Requires-Dist: eth-typing (>=3.0.0,<4.0.0)
+Requires-Dist: eth-typing (>=5.0.0,<6.0.0)
 Requires-Dist: functions-framework (>=3.5.0,<4.0.0)
 Requires-Dist: google-api-python-client (==2.95.0) ; extra == "google"
 Requires-Dist: google-cloud-functions (>=1.16.0,<2.0.0)
@@ -41,6 +41,7 @@ Requires-Dist: prompt-toolkit (>=3.0.43,<4.0.0)
 Requires-Dist: proto-plus (>=1.0.0,<2.0.0)
 Requires-Dist: protobuf (>=5.0.0,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
+Requires-Dist: py-clob-client (>=0.24.0,<0.25.0)
 Requires-Dist: pydantic (>=2.6.1,<3.0.0)
 Requires-Dist: pydantic-ai (>=0.1.9,<1.0.0)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
@@ -48,8 +49,8 @@ Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: pytest-postgresql (>=6.1.1,<7.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: python-json-logger (>=3.3.0,<4.0.0)
-Requires-Dist: safe-cli (>=1.0.0,<2.0.0)
-Requires-Dist: safe-eth-py (>=6.0.0b41,<7.0.0)
+Requires-Dist: safe-cli (>=1.5.0,<2.0.0)
+Requires-Dist: safe-eth-py (>=7.8.0,<8.0.0)
 Requires-Dist: scikit-learn (>=1.3.1,<2.0.0)
 Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)
@@ -62,7 +63,7 @@ Requires-Dist: types-cachetools (>=5.5.0.20240820,<6.0.0.0)
 Requires-Dist: types-python-dateutil (>=2.9.0.20240906,<3.0.0.0)
 Requires-Dist: types-pytz (>=2024.1.0.20240203,<2025.0.0.0)
 Requires-Dist: types-requests (>=2.31.0.0,<3.0.0.0)
-Requires-Dist: web3 (>=6.15.1,<7.0.0)
+Requires-Dist: web3 (>=6,<8)
 Description-Content-Type: text/markdown
 
 # Prediction Market Agent Tooling

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/chains.py

@@ -2,3 +2,4 @@ from prediction_market_agent_tooling.gtypes import ChainID
 
 ETHEREUM_ID = ChainID(1)
 GNOSIS_CHAIN_ID = ChainID(100)
+POLYGON_CHAIN_ID = ChainID(137)

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/config.py

@@ -2,6 +2,7 @@ import json
 import typing as t
 from copy import deepcopy
 
+import cachetools
 from eth_account.signers.local import LocalAccount
 from eth_typing import URI
 from pydantic import Field, model_validator
@@ -12,8 +13,13 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 from web3 import Account, Web3
 from web3._utils.http import construct_user_agent
+from web3.middleware import ExtraDataToPOAMiddleware
 
-from prediction_market_agent_tooling.chains import ETHEREUM_ID, GNOSIS_CHAIN_ID
+from prediction_market_agent_tooling.chains import (
+    ETHEREUM_ID,
+    GNOSIS_CHAIN_ID,
+    POLYGON_CHAIN_ID,
+)
 from prediction_market_agent_tooling.deploy.gcp.utils import gcp_get_secret_value
 from prediction_market_agent_tooling.gtypes import (
     ChainID,
@@ -293,6 +299,8 @@ class RPCConfig(BaseSettings):
     GNOSIS_RPC_URL: URI = Field(default=URI("https://rpc.gnosis.gateway.fm"))
     GNOSIS_RPC_BEARER: SecretStr | None = None
     CHAIN_ID: ChainID = Field(default=GNOSIS_CHAIN_ID)
+    POLYGON_RPC_URL: URI = Field(default=URI("https://polygon-rpc.com"))
+    POLYGON_RPC_BEARER: SecretStr | None = None
 
     @property
     def ethereum_rpc_url(self) -> URI:
@@ -306,26 +314,40 @@ class RPCConfig(BaseSettings):
             self.GNOSIS_RPC_URL, "GNOSIS_RPC_URL missing in the environment."
         )
 
+    @property
+    def polygon_rpc_url(self) -> URI:
+        return check_not_none(
+            self.POLYGON_RPC_URL, "POLYGON_RPC_URL missing in the environment."
+        )
+
     @property
     def chain_id(self) -> ChainID:
         return check_not_none(self.CHAIN_ID, "CHAIN_ID missing in the environment.")
 
+    @property
+    def gnosis_chain_id(self) -> ChainID:
+        return GNOSIS_CHAIN_ID
+
     def chain_id_to_rpc_url(self, chain_id: ChainID) -> URI:
         return {
             ETHEREUM_ID: self.ethereum_rpc_url,
             GNOSIS_CHAIN_ID: self.gnosis_rpc_url,
+            POLYGON_CHAIN_ID: self.polygon_rpc_url,
         }[chain_id]
 
     def chain_id_to_rpc_bearer(self, chain_id: ChainID) -> SecretStr | None:
         return {
             ETHEREUM_ID: self.ETHEREUM_RPC_BEARER,
             GNOSIS_CHAIN_ID: self.GNOSIS_RPC_BEARER,
+            POLYGON_CHAIN_ID: self.POLYGON_RPC_BEARER,
         }[chain_id]
 
     def get_web3(self) -> Web3:
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(str(type(self))),
+            "User-Agent": construct_user_agent(
+                str(type(self)), self.__class__.__name__
+            ),
         }
         if bearer := self.chain_id_to_rpc_bearer(self.chain_id):
             headers["Authorization"] = f"Bearer {bearer.get_secret_value()}"
@@ -339,6 +361,19 @@ class RPCConfig(BaseSettings):
             )
         )
 
+    @cachetools.cached(
+        cachetools.TTLCache(maxsize=100, ttl=5 * 60),
+        key=lambda self: f"{self.model_dump_json()}",
+    )
+    def get_polygon_web3(self) -> Web3:
+        web3 = self.get_web3()
+        if self.chain_id != POLYGON_CHAIN_ID:
+            raise ValueError(f"Chain ID {self.chain_id} is not Polygon Mainnet")
+
+        # We need to inject middleware into the Polygon web3 instance (https://web3py.readthedocs.io/en/stable/middleware.html#proof-of-authority)
+        web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+        return web3
+
 
 class CloudCredentials(BaseSettings):
     model_config = SettingsConfigDict(

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -25,7 +25,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ConditionalFilterType,
     FilterBy,
     ProcessedMarket,
-    ProcessedTradedMarket,
     QuestionType,
     SortBy,
 )
@@ -38,9 +37,6 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
 )
 from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.markets.omen.omen import (
-    send_keeping_token_to_eoa_xdai,
-)
 from prediction_market_agent_tooling.tools.custom_exceptions import (
     CantPayForGasError,
     OutOfFundsError,
@@ -414,15 +410,13 @@ class DeployablePredictionAgent(DeployableAgent):
         """
         Executed before processing of each market.
         """
-        api_keys = APIKeys()
 
         if market_type.is_blockchain_market:
-            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
+            # Ensure we have enough native token balance for transaction fees
             if self.min_balance_to_keep_in_native_currency is not None:
-                send_keeping_token_to_eoa_xdai(
-                    api_keys,
+                market.ensure_min_native_balance(
                     min_required_balance=self.min_balance_to_keep_in_native_currency,
-                    multiplier=3,
+                    multiplier=3.0,
                 )
 
     def build_answer(
@@ -515,7 +509,7 @@ class DeployablePredictionAgent(DeployableAgent):
             self.verify_answer_outcomes(market=market, answer=answer)
 
         processed_market = (
-            ProcessedMarket(answer=answer) if answer is not None else None
+            ProcessedMarket(answer=answer, trades=[]) if answer is not None else None
         )
 
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
@@ -636,7 +630,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         api_keys = APIKeys()
 
         # Get the strategy to know how much it will bet.
-        strategy = self.get_betting_strategy(market)
+        strategy = self.get_betting_strategy_supported(market)
         # Have a little bandwidth after the bet.
         min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
 
@@ -664,13 +658,24 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         total_amount = self.get_total_amount_to_bet(market)
         return CategoricalMaxAccuracyBettingStrategy(max_position_amount=total_amount)
 
+    def get_betting_strategy_supported(self, market: AgentMarket) -> BettingStrategy:
+        """
+        Use this class internally to assert that the configured betting strategy works with the given market.
+        """
+        strategy = self.get_betting_strategy(market=market)
+        if not strategy.is_market_supported(market):
+            raise ValueError(
+                f"Market {market.url} is not supported by the strategy {strategy}."
+            )
+        return strategy
+
     def build_trades(
         self,
         market: AgentMarket,
         answer: CategoricalProbabilisticAnswer,
         existing_position: ExistingPosition | None,
     ) -> list[Trade]:
-        strategy = self.get_betting_strategy(market=market)
+        strategy = self.get_betting_strategy_supported(market=market)
         trades = strategy.calculate_trades(existing_position, answer, market)
         return trades
 
@@ -742,7 +747,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         market_type: MarketType,
         market: AgentMarket,
         verify_market: bool = True,
-    ) -> ProcessedTradedMarket | None:
+    ) -> ProcessedMarket | None:
         processed_market = super().process_market(market_type, market, verify_market)
         if processed_market is None:
             return None
@@ -762,7 +767,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         )
         placed_trades = self.execute_trades(market, trades)
 
-        traded_market = ProcessedTradedMarket(
+        traded_market = ProcessedMarket(
             answer=processed_market.answer, trades=placed_trades
         )
         logger.info(f"Traded market {market.question=} from {market.url=}.")
@@ -780,10 +785,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
             market,
             processed_market,
         )
-        if isinstance(processed_market, ProcessedTradedMarket):
-            if self.store_trades:
-                market.store_trades(processed_market, api_keys, self.agent_name)
-            else:
-                logger.info(
-                    f"Trades {processed_market.trades} not stored because {self.store_trades=}."
-                )
+
+        if self.store_trades and processed_market is not None:
+            market.store_trades(processed_market, api_keys, self.agent_name)
+        else:
+            logger.info(
+                f"Trades {processed_market=} not stored because {self.store_trades=}."
+            )

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -16,7 +16,11 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket, MarketFees
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    MarketFees,
+    QuestionType,
+)
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     ExistingPosition,
@@ -24,10 +28,12 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
+from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import (
     get_buy_outcome_token_amount,
 )
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
+    KellyType,
     get_kelly_bet_full,
     get_kelly_bet_simplified,
     get_kelly_bets_categorical_full,
@@ -45,9 +51,21 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    supported_question_types: set[QuestionType]
+    supported_market_types: set[MarketType]
+
     def __init__(self, take_profit: bool = True) -> None:
         self.take_profit = take_profit
 
+    def is_market_supported(self, market: AgentMarket) -> bool:
+        if market.question_type not in self.supported_question_types:
+            return False
+
+        if MarketType.from_market(market) not in self.supported_market_types:
+            return False
+
+        return True
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -251,6 +269,13 @@ class BettingStrategy(ABC):
 
 
 class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+    supported_question_types = {
+        QuestionType.BINARY,
+        QuestionType.CATEGORICAL,
+        QuestionType.SCALAR,
+    }
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(self, max_position_amount: USD, take_profit: bool = True):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
@@ -362,18 +387,20 @@ class MaxExpectedValueBettingStrategy(CategoricalMaxAccuracyBettingStrategy):
         return f"MaxExpectedValueBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class BinaryKellyBettingStrategy(BettingStrategy):
+class _BinaryKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None = None,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -396,7 +423,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             else override_p_yes
         )
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bet = get_kelly_bet_simplified(
                 max_bet=market.get_usd_in_token(self.max_position_amount),
                 market_p_yes=market.probability_for_market_outcome(direction),
@@ -447,7 +474,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             # Adjust amount
             max_price_impact_bet_amount = self.calculate_bet_amount_for_price_impact(
                 market,
-                kelly_bet.size,
                 direction=direction,
                 max_price_impact=self.max_price_impact,
             )
@@ -460,7 +486,9 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         amounts = {
             bet_outcome: BettingStrategy.cap_to_profitable_bet_amount(
                 market, market.get_token_in_usd(kelly_bet_size), bet_outcome
-            ),
+            )
+            if kelly_bet_size > 0
+            else USD(0),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
@@ -490,7 +518,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
     @staticmethod
     def calculate_bet_amount_for_price_impact(
         market: AgentMarket,
-        kelly_bet_size: CollateralToken,
         direction: OutcomeStr,
         max_price_impact: float,
     ) -> CollateralToken:
@@ -499,7 +526,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
             price_impact = (
-                BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
+                _BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
                     outcome_idx=outcome_idx,
                     bet_amount=CollateralToken(bet_amount_collateral),
                     pool_balances=pool_balances,
@@ -510,10 +537,9 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             return abs(price_impact - max_price_impact)
 
         if not market.outcome_token_pool:
-            logger.warning(
+            raise ValueError(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet_size
 
         pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
         # stay float for compatibility with `minimize_scalar`
@@ -530,10 +556,47 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit})"
+
+
+class SimpleBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            take_profit=take_profit,
+        )
+
+
+class FullBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    # Supports only OMEN because it uses closed-form formula derived from a binary FPMM.
+    supported_market_types = {MarketType.OMEN}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            take_profit=take_profit,
+        )
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+    supported_market_types = {MarketType.OMEN}
+
     def __init__(
         self,
         max_position_amount: USD,
@@ -565,7 +628,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         # We ignore the direction nudge given by Kelly, hence we assume we have a perfect prediction.
         estimated_p_yes = 1.0
 
-        kelly_bet = BinaryKellyBettingStrategy(
+        kelly_bet = FullBinaryKellyBettingStrategy(
             max_position_amount=self.max_position_amount
         ).get_kelly_bet(
             market=market,
@@ -593,24 +656,27 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class CategoricalKellyBettingStrategy(BettingStrategy):
+class _CategoricalKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY, QuestionType.CATEGORICAL}
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None,
         allow_multiple_bets: bool,
         allow_shorting: bool,
         multicategorical: bool,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
         self.allow_multiple_bets = allow_multiple_bets
         self.allow_shorting = allow_shorting
         self.multicategorical = multicategorical
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -624,7 +690,7 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
     ) -> list[CategoricalKellyBet]:
         max_bet = market.get_usd_in_token(max_bet_amount)
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bets = get_kelly_bets_categorical_simplified(
                 market_probabilities=[market.probabilities[o] for o in market.outcomes],
                 estimated_probabilities=[
@@ -639,8 +705,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
 
         else:
             kelly_bets = get_kelly_bets_categorical_full(
-                outcome_pool_sizes=[
-                    market.outcome_token_pool[o] for o in market.outcomes
+                market_probabilities=[
+                    market.probability_for_market_outcome(o) for o in market.outcomes
                 ],
                 estimated_probabilities=[
                     answer.probability_for_market_outcome(o) for o in market.outcomes
@@ -651,6 +717,11 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
                 allow_multiple_bets=self.allow_multiple_bets,
                 allow_shorting=self.allow_shorting,
                 multicategorical=self.multicategorical,
+                get_buy_token_amount=lambda bet_amount, outcome_index: check_not_none(
+                    market.get_buy_token_amount(
+                        bet_amount, market.get_outcome_str(outcome_index)
+                    )
+                ),
             )
 
         return kelly_bets
@@ -681,9 +752,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         if self.max_price_impact:
             # Adjust amount
             max_price_impact_bet_amount = (
-                BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
+                _BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
                     market,
-                    best_kelly_bet.size,
                     direction=market.get_outcome_str(best_kelly_bet.index),
                     max_price_impact=self.max_price_impact,
                 )
@@ -704,4 +774,45 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit})"
+
+
+class SimpleCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )
+
+
+class FullCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/jobs/jobs_models.py

@@ -9,7 +9,7 @@ from prediction_market_agent_tooling.deploy.betting_strategy import (
 from prediction_market_agent_tooling.gtypes import USD, Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
-    ProcessedTradedMarket,
+    ProcessedMarket,
 )
 from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_FALSE_OUTCOME,
@@ -64,7 +64,7 @@ class JobAgentMarket(AgentMarket, ABC):
     @abstractmethod
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         """Submit the completed result for this job."""
 
     def to_simple_job(self, max_bond: USD) -> SimpleJob:

{prediction_market_agent_tooling-0.68.0.dev999 → prediction_market_agent_tooling-0.69.0}/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,13 +1,9 @@
 import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.deploy.betting_strategy import (
-    BinaryKellyBettingStrategy,
-    TradeType,
-)
 from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
-from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
 from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
     OmenAgentMarket,
@@ -72,7 +68,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         if not APIKeys().enable_ipfs_upload:
             raise RuntimeError(
                 f"ENABLE_IPFS_UPLOAD must be set to True to upload job results."
@@ -81,7 +77,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         trade = self.get_job_trade(max_bond, result)
         buy_id = self.buy_tokens(outcome=trade.outcome, amount=trade.amount)
 
-        processed_traded_market = ProcessedTradedMarket(
+        processed_traded_market = ProcessedMarket(
             answer=self.get_job_answer(result),
             trades=[PlacedTrade.from_trade(trade, id=buy_id)],
         )
@@ -92,20 +88,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return processed_traded_market
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
+        raise NotImplementedError("TODO: Refactor to avoid circular imports.")
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = BinaryKellyBettingStrategy(max_position_amount=max_bond)
-        required_trades = strategy.calculate_trades(
-            existing_position=None,
-            answer=self.get_job_answer(result),
-            market=self,
-        )
-        assert (
-            len(required_trades) == 1
-        ), f"Shouldn't process same job twice: {required_trades}"
-        trade = required_trades[0]
-        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-        assert trade.outcome, "Should buy only YES on job markets."
-        return required_trades[0]
+        # strategy = FullBinaryKellyBettingStrategy(max_position_amount=max_bond)
+        # required_trades = strategy.calculate_trades(
+        #     existing_position=None,
+        #     answer=self.get_job_answer(result),
+        #     market=self,
+        # )
+        # assert (
+        #     len(required_trades) == 1
+        # ), f"Shouldn't process same job twice: {required_trades}"
+        # trade = required_trades[0]
+        # assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        # assert trade.outcome, "Should buy only YES on job markets."
+        # return required_trades[0]
 
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":