prediction-market-agent-tooling 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

prediction_market_agent_tooling/benchmark/utils.py

@@ -55,7 +55,7 @@ class PredictionsCache(BaseModel):
 
     def save(self, path: str) -> None:
         with open(path, "w") as f:
-            json.dump(self.dict(), f, indent=2)
+            json.dump(self.model_dump(), f, indent=2)
 
     @staticmethod
     def load(path: str) -> "PredictionsCache":

prediction_market_agent_tooling/config.py

@@ -4,6 +4,7 @@ from pydantic.types import SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, PrivateKey
+from prediction_market_agent_tooling.markets.manifold.api import get_authenticated_user
 from prediction_market_agent_tooling.tools.utils import check_not_none
 from prediction_market_agent_tooling.tools.web3_utils import private_key_to_public_key
 
@@ -30,6 +31,12 @@ class APIKeys(BaseSettings):
     ENABLE_CACHE: bool = True
     CACHE_DIR: str = "./.cache"
 
+    @property
+    def manifold_user_id(self) -> str:
+        return get_authenticated_user(
+            api_key=self.manifold_api_key.get_secret_value()
+        ).id
+
     @property
     def manifold_api_key(self) -> SecretStr:
         return check_not_none(

prediction_market_agent_tooling/deploy/agent.py

@@ -122,7 +122,6 @@ def {entrypoint_function_name}(request) -> str:
 
         monitor_agent = MARKET_TYPE_TO_DEPLOYED_AGENT[market_type].from_api_keys(
             name=gcp_fname,
-            deployableagent_class_name=self.__class__.__name__,
             start_time=start_time or utcnow(),
             api_keys=gcp_resolve_api_keys_secrets(api_keys),
         )

prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py

@@ -0,0 +1,152 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Metadata(BaseModel):
+    creationTimestamp: datetime
+    generation: int
+    name: str
+    namespace: str
+    resourceVersion: str
+    uid: str
+    labels: dict[str, str]
+
+
+class Metadata1(BaseModel):
+    creationTimestamp: datetime | None
+    name: str
+
+
+class Metadata2(BaseModel):
+    creationTimestamp: datetime | None
+    name: str
+
+
+class SecretKeyRef(BaseModel):
+    key: str
+    name: str
+    optional: bool
+
+
+class ValueFrom(BaseModel):
+    secretKeyRef: SecretKeyRef
+
+
+class EnvItem(BaseModel):
+    name: str
+    valueFrom: ValueFrom
+
+
+class ConfigMapRef(BaseModel):
+    name: str
+    optional: bool
+
+
+class EnvFromItem(BaseModel):
+    configMapRef: ConfigMapRef
+
+
+class Limits(BaseModel):
+    cpu: str
+    memory: str
+
+
+class Requests(BaseModel):
+    cpu: str
+    memory: str
+
+
+class Resources(BaseModel):
+    limits: Limits
+    requests: Requests
+
+
+class Container(BaseModel):
+    env: list[EnvItem]
+    envFrom: list[EnvFromItem]
+    image: str
+    imagePullPolicy: str
+    name: str
+    resources: Resources
+    terminationMessagePath: str
+    terminationMessagePolicy: str
+
+
+class NodeSelector(BaseModel):
+    role: str
+
+
+class Toleration(BaseModel):
+    effect: str
+    key: str
+    operator: str
+    value: str
+
+
+class Spec2(BaseModel):
+    automountServiceAccountToken: bool
+    containers: list[Container]
+    dnsPolicy: str
+    enableServiceLinks: bool
+    nodeSelector: NodeSelector
+    restartPolicy: str
+    schedulerName: str
+    securityContext: dict[str, Any]
+    shareProcessNamespace: bool
+    terminationGracePeriodSeconds: int
+    tolerations: list[Toleration]
+
+
+class Template(BaseModel):
+    metadata: Metadata2
+    spec: Spec2
+
+
+class Spec1(BaseModel):
+    activeDeadlineSeconds: int
+    backoffLimit: int
+    completions: int
+    manualSelector: bool
+    parallelism: int
+    template: Template
+
+
+class JobTemplate(BaseModel):
+    metadata: Metadata1
+    spec: Spec1
+
+
+class Spec(BaseModel):
+    concurrencyPolicy: str
+    failedJobsHistoryLimit: int
+    jobTemplate: JobTemplate
+    schedule: str
+    successfulJobsHistoryLimit: int
+    suspend: bool
+    timeZone: str
+
+
+class Status(BaseModel):
+    lastScheduleTime: str | None = None
+    lastSuccessfulTime: str | None = None
+
+
+class KubernetesCronJob(BaseModel):
+    apiVersion: str
+    kind: str
+    metadata: Metadata
+    spec: Spec
+    status: Status
+
+
+class Metadata3(BaseModel):
+    resourceVersion: str
+
+
+class KubernetesCronJobsModel(BaseModel):
+    apiVersion: str
+    items: list[KubernetesCronJob]
+    kind: str
+    metadata: Metadata3

prediction_market_agent_tooling/deploy/gcp/utils.py

@@ -1,3 +1,4 @@
+import json
 import subprocess
 import sys
 
@@ -8,6 +9,9 @@ from google.cloud.functions_v2.types.functions import Function
 from google.cloud.secretmanager import SecretManagerServiceClient
 
 from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.deploy.gcp.kubernetes_models import (
+    KubernetesCronJobsModel,
+)
 
 
 def gcloud_deploy_cmd(
@@ -153,6 +157,33 @@ def list_gcp_functions() -> list[Function]:
     return functions
 
 
+def list_gcp_cronjobs(namespace: str) -> KubernetesCronJobsModel:
+    return KubernetesCronJobsModel.model_validate_json(
+        subprocess.run(
+            f"kubectl get cronjobs -o json -n {namespace}",
+            shell=True,
+            capture_output=True,
+            check=True,
+        )
+        .stdout.decode()
+        .strip()
+    )
+
+
+def get_gcp_configmap_data(namespace: str, name: str) -> dict[str, str]:
+    data: dict[str, str] = json.loads(
+        subprocess.run(
+            f"kubectl get configmap {name} -o json -n {namespace}",
+            shell=True,
+            capture_output=True,
+            check=True,
+        )
+        .stdout.decode()
+        .strip()
+    )["data"]
+    return data
+
+
 def get_gcp_function(fname: str) -> Function:
     response = list_gcp_functions()
     for function in response:

prediction_market_agent_tooling/gtypes.py

@@ -1,6 +1,5 @@
 import typing as t
 from datetime import datetime
-from decimal import Decimal
 from typing import NewType, Union
 
 from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy importing with others from here.
@@ -23,23 +22,22 @@ from prediction_market_agent_tooling.tools.hexbytes_custom import (  # noqa: F40
 )
 
 Wad = Wei  # Wei tends to be referred to as `wad` variable in contracts.
-USD = NewType(
-    "USD", Decimal
-)  # Decimals are more precise than floats, good for finances.
+USD = NewType("USD", float)
 PrivateKey = NewType("PrivateKey", SecretStr)
-xDai = NewType("xDai", Decimal)
-GNO = NewType("GNO", Decimal)
+xDai = NewType("xDai", float)
+GNO = NewType("GNO", float)
 ABI = NewType("ABI", str)
 OmenOutcomeToken = NewType("OmenOutcomeToken", int)
+OutcomeStr = NewType("OutcomeStr", str)
 Probability = NewType("Probability", float)
-Mana = NewType("Mana", Decimal)  # Manifold's "currency"
-USDC = NewType("USDC", Decimal)
+Mana = NewType("Mana", float)  # Manifold's "currency"
+USDC = NewType("USDC", float)
 DatetimeWithTimezone = NewType("DatetimeWithTimezone", datetime)
 ChainID = NewType("ChainID", int)
 
 
-def usd_type(amount: Union[str, int, float, Decimal]) -> USD:
-    return USD(Decimal(amount))
+def usd_type(amount: Union[str, int, float]) -> USD:
+    return USD(float(amount))
 
 
 def wei_type(amount: Union[str, int]) -> Wei:
@@ -50,16 +48,16 @@ def omen_outcome_type(amount: Union[str, int, Wei]) -> OmenOutcomeToken:
     return OmenOutcomeToken(wei_type(amount))
 
 
-def xdai_type(amount: Union[str, int, float, Decimal]) -> xDai:
-    return xDai(Decimal(amount))
+def xdai_type(amount: Union[str, int, float]) -> xDai:
+    return xDai(float(amount))
 
 
-def mana_type(amount: Union[str, int, float, Decimal]) -> Mana:
-    return Mana(Decimal(amount))
+def mana_type(amount: Union[str, int, float]) -> Mana:
+    return Mana(float(amount))
 
 
-def usdc_type(amount: Union[str, int, float, Decimal]) -> USDC:
-    return USDC(Decimal(amount))
+def usdc_type(amount: Union[str, int, float]) -> USDC:
+    return USDC(float(amount))
 
 
 def private_key_type(k: str) -> PrivateKey:

prediction_market_agent_tooling/markets/agent_market.py

@@ -1,6 +1,5 @@
 import typing as t
 from datetime import datetime
-from decimal import Decimal
 from enum import Enum
 
 from pydantic import BaseModel, field_validator
@@ -9,6 +8,7 @@ from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.data_models import (
     BetAmount,
     Currency,
+    Position,
     Resolution,
     TokenAmount,
 )
@@ -45,10 +45,10 @@ class AgentMarket(BaseModel):
     outcomes: list[str]
     resolution: Resolution | None
     created_time: datetime | None
-    close_time: datetime
+    close_time: datetime | None
     p_yes: Probability
     url: str
-    volume: Decimal | None  # Should be in currency of `currency` above.
+    volume: float | None  # Should be in currency of `currency` above.
 
     _add_timezone_validator_created_time = field_validator("created_time")(
         add_utc_timezone_validator
@@ -62,20 +62,20 @@ class AgentMarket(BaseModel):
         return Probability(1 - self.p_yes)
 
     @property
-    def yes_outcome_price(self) -> Decimal:
+    def yes_outcome_price(self) -> float:
         """
         Price at prediction market is equal to the probability of given outcome.
         Keep as an extra property, in case it wouldn't be true for some prediction market platform.
         """
-        return Decimal(self.p_yes)
+        return self.p_yes
 
     @property
-    def no_outcome_price(self) -> Decimal:
+    def no_outcome_price(self) -> float:
         """
         Price at prediction market is equal to the probability of given outcome.
         Keep as an extra property, in case it wouldn't be true for some prediction market platform.
         """
-        return Decimal(self.p_no)
+        return self.p_no
 
     @property
     def probable_resolution(self) -> Resolution:
@@ -96,7 +96,7 @@ class AgentMarket(BaseModel):
                 return False
         should_not_happen(f"Market {self.id} does not have a successful resolution.")
 
-    def get_bet_amount(self, amount: Decimal) -> BetAmount:
+    def get_bet_amount(self, amount: float) -> BetAmount:
         return BetAmount(amount=amount, currency=self.currency)
 
     def get_tiny_bet_amount(self) -> BetAmount:
@@ -153,3 +153,9 @@ class AgentMarket(BaseModel):
 
     def get_token_balance(self, user_id: str, outcome: str) -> TokenAmount:
         raise NotImplementedError("Subclasses must implement this method")
+
+    def get_positions(self, user_id: str) -> list[Position]:
+        """
+        Get all non-zero positions a user has in any market.
+        """
+        raise NotImplementedError("Subclasses must implement this method")

prediction_market_agent_tooling/markets/data_models.py

@@ -1,10 +1,11 @@
 from datetime import datetime
-from decimal import Decimal
 from enum import Enum
 from typing import TypeAlias
 
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+
 
 class Currency(str, Enum):
     xDai = "xDai"
@@ -20,7 +21,7 @@ class Resolution(str, Enum):
 
 
 class TokenAmount(BaseModel):
-    amount: Decimal
+    amount: float
     currency: Currency
 
 
@@ -43,3 +44,15 @@ class ResolvedBet(Bet):
     @property
     def is_correct(self) -> bool:
         return self.outcome == self.market_outcome
+
+
+class Position(BaseModel):
+    market_id: str
+    amounts: dict[OutcomeStr, TokenAmount]
+
+    def __str__(self) -> str:
+        amounts_str = ", ".join(
+            f"{amount.amount} '{outcome}' tokens"
+            for outcome, amount in self.amounts.items()
+        )
+        return f"Position for market id {self.market_id}: {amounts_str}"

prediction_market_agent_tooling/markets/manifold/api.py

@@ -5,8 +5,7 @@ import requests
 import tenacity
 from loguru import logger
 
-from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import Mana
+from prediction_market_agent_tooling.gtypes import Mana, SecretStr
 from prediction_market_agent_tooling.markets.data_models import (
     BetAmount,
     Currency,
@@ -107,7 +106,9 @@ def get_one_manifold_binary_market() -> ManifoldMarket:
     wait=tenacity.wait_fixed(1),
     after=lambda x: logger.debug(f"place_bet failed, {x.attempt_number=}."),
 )
-def place_bet(amount: Mana, market_id: str, outcome: bool) -> None:
+def place_bet(
+    amount: Mana, market_id: str, outcome: bool, manifold_api_key: SecretStr
+) -> None:
     outcome_str = "YES" if outcome else "NO"
     url = f"{MANIFOLD_API_BASE_URL}/v0/bet"
     params = {
@@ -117,7 +118,7 @@ def place_bet(amount: Mana, market_id: str, outcome: bool) -> None:
     }
 
     headers = {
-        "Authorization": f"Key {APIKeys().manifold_api_key.get_secret_value()}",
+        "Authorization": f"Key {manifold_api_key.get_secret_value()}",
         "Content-Type": "application/json",
     }
     response = requests.post(url, json=params, headers=headers)
@@ -139,12 +140,18 @@ def get_authenticated_user(api_key: str) -> ManifoldUser:
     headers = {
         "Authorization": f"Key {api_key}",
         "Content-Type": "application/json",
+        "Cache-Control": "private, no-store, max-age=0",
     }
     response = requests.get(url, headers=headers)
     response.raise_for_status()
     return ManifoldUser.model_validate(response.json())
 
 
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(f"get_manifold_market failed, {x.attempt_number=}."),
+)
 def get_manifold_market(market_id: str) -> ManifoldMarket:
     url = f"{MANIFOLD_API_BASE_URL}/v0/market/{market_id}"
     response = requests.get(url)
@@ -152,6 +159,11 @@ def get_manifold_market(market_id: str) -> ManifoldMarket:
     return ManifoldMarket.model_validate(response.json())
 
 
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(f"get_manifold_bets failed, {x.attempt_number=}."),
+)
 def get_manifold_bets(
     user_id: str,
     start_time: datetime,

prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -1,6 +1,5 @@
 import typing as t
 from datetime import datetime, timedelta
-from decimal import Decimal
 
 from pydantic import BaseModel, field_validator
 
@@ -123,17 +122,17 @@ class ManifoldUser(BaseModel):
 class ManifoldBetFills(BaseModel):
     amount: Mana
     matchedBetId: t.Optional[str]
-    shares: Decimal
+    shares: float
     timestamp: int
 
 
 class ManifoldBetFees(BaseModel):
-    platformFee: Decimal
-    liquidityFee: Decimal
-    creatorFee: Decimal
+    platformFee: float
+    liquidityFee: float
+    creatorFee: float
 
-    def get_total(self) -> Decimal:
-        return Decimal(sum([self.platformFee, self.liquidityFee, self.creatorFee]))
+    def get_total(self) -> float:
+        return sum([self.platformFee, self.liquidityFee, self.creatorFee])
 
 
 class ManifoldBet(BaseModel):
@@ -141,7 +140,7 @@ class ManifoldBet(BaseModel):
     https://docs.manifold.markets/api#get-v0bets
     """
 
-    shares: Decimal
+    shares: float
     probBefore: Probability
     isFilled: t.Optional[bool] = None
     probAfter: Probability
@@ -187,13 +186,13 @@ class ManifoldContractMetric(BaseModel):
     hasNoShares: bool
     hasShares: bool
     hasYesShares: bool
-    invested: Decimal
-    loan: Decimal
+    invested: float
+    loan: float
     maxSharesOutcome: t.Optional[str]
-    payout: Decimal
-    profit: Decimal
-    profitPercent: Decimal
-    totalShares: dict[str, Decimal]
+    payout: float
+    profit: float
+    profitPercent: float
+    totalShares: dict[str, float]
     userId: str
     userUsername: str
     userName: str

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -1,8 +1,8 @@
 import typing as t
 from datetime import datetime
-from decimal import Decimal
 from math import ceil
 
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import Mana, Probability, mana_type
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
@@ -32,7 +32,7 @@ class ManifoldAgentMarket(AgentMarket):
     base_url: t.ClassVar[str] = MANIFOLD_BASE_URL
 
     def get_tiny_bet_amount(self) -> BetAmount:
-        return BetAmount(amount=Decimal(1), currency=self.currency)
+        return BetAmount(amount=1, currency=self.currency)
 
     def get_minimum_bet_to_win(self, answer: bool, amount_to_win: float) -> Mana:
         # Manifold lowest bet is 1 Mana, so we need to ceil the result.
@@ -45,6 +45,7 @@ class ManifoldAgentMarket(AgentMarket):
             amount=Mana(amount.amount),
             market_id=self.id,
             outcome=outcome,
+            manifold_api_key=APIKeys().manifold_api_key,
         )
 
     @staticmethod

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -1,6 +1,5 @@
 import typing as t
 from datetime import datetime
-from decimal import Decimal
 
 from pydantic import BaseModel
 from web3 import Web3
@@ -90,6 +89,24 @@ class OmenPosition(BaseModel):
     collateralTokenAddress: HexAddress
     indexSets: list[int]
 
+    @property
+    def condition_id(self) -> HexBytes:
+        # I didn't find any example where this wouldn't hold, but keeping this double-check here in case something changes in the future.
+        # May be the case if the market is created with multiple oracles.
+        if len(self.conditionIds) != 1:
+            raise ValueError(
+                f"Bug in the logic, please investigate why zero or multiple conditions are returned for position {self.id=}"
+            )
+        return self.conditionIds[0]
+
+    @property
+    def index_set(self) -> int:
+        if len(self.indexSets) != 1:
+            raise ValueError(
+                f"Bug in the logic, please investigate why zero or multiple index sets are returned for position {self.id=}"
+            )
+        return self.indexSets[0]
+
     @property
     def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
         return Web3.to_checksum_address(self.collateralTokenAddress)
@@ -133,7 +150,7 @@ class OmenMarket(BaseModel):
     fee: t.Optional[Wei]
     resolutionTimestamp: t.Optional[int] = None
     answerFinalizedTimestamp: t.Optional[int] = None
-    currentAnswer: t.Optional[str] = None
+    currentAnswer: t.Optional[HexBytes] = None
     creationTimestamp: int
     condition: Condition
     question: Question
@@ -156,7 +173,7 @@ class OmenMarket(BaseModel):
 
     @property
     def answer_index(self) -> t.Optional[int]:
-        return int(self.currentAnswer, 16) if self.currentAnswer else None
+        return self.currentAnswer.as_int() if self.currentAnswer else None
 
     @property
     def has_valid_answer(self) -> bool:
@@ -338,9 +355,7 @@ class OmenBet(BaseModel):
             )
 
         return ResolvedBet(
-            amount=BetAmount(
-                amount=Decimal(self.collateralAmountUSD), currency=Currency.xDai
-            ),
+            amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
             market_question=self.title,