prediction-market-agent-tooling 0.61.2.dev479__py3-none-any.whl → 0.62.0__py3-none-any.whl

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -1,7 +1,7 @@
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import Wei, wei_type
+from prediction_market_agent_tooling.gtypes import USD, Wei
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20BaseClass,
@@ -10,31 +10,46 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC4626BaseClass,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
-    get_buy_token_amount,
+    get_sell_token_amount,
     swap_tokens_waiting,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
+from prediction_market_agent_tooling.tools.tokens.usd import get_usd_in_token
 from prediction_market_agent_tooling.tools.utils import should_not_happen
-from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 
 def auto_deposit_collateral_token(
     collateral_token_contract: ContractERC20BaseClass,
-    amount_wei: Wei,
+    collateral_amount_wei_or_usd: Wei | USD,
     api_keys: APIKeys,
     web3: Web3 | None = None,
+    surplus: float = 0.01,
 ) -> None:
+    collateral_amount_wei = (
+        collateral_amount_wei_or_usd
+        if isinstance(collateral_amount_wei_or_usd, Wei)
+        else get_usd_in_token(
+            collateral_amount_wei_or_usd, collateral_token_contract.address
+        ).as_wei
+    )
+    # Deposit a bit more to cover any small changes in conversions.
+    collateral_amount_wei = collateral_amount_wei.with_fraction(surplus)
+
     if isinstance(collateral_token_contract, ContractDepositableWrapperERC20BaseClass):
         # In this case, we can use deposit function directly, no need to go through DEX.
         auto_deposit_depositable_wrapper_erc20(
-            collateral_token_contract, amount_wei, api_keys, web3
+            collateral_token_contract, collateral_amount_wei, api_keys, web3
         )
 
     elif isinstance(collateral_token_contract, ContractERC4626BaseClass):
-        auto_deposit_erc4626(collateral_token_contract, amount_wei, api_keys, web3)
+        auto_deposit_erc4626(
+            collateral_token_contract, collateral_amount_wei, api_keys, web3
+        )
 
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
-        auto_deposit_erc20(collateral_token_contract, amount_wei, api_keys, web3)
+        auto_deposit_erc20(
+            collateral_token_contract, collateral_amount_wei, api_keys, web3
+        )
 
     else:
         should_not_happen("Unsupported ERC20 contract type.")
@@ -55,16 +70,16 @@ def auto_deposit_depositable_wrapper_erc20(
         return
 
     # If we don't have enough, we need to deposit the difference.
-    left_to_deposit = Wei(amount_wei - collateral_token_balance)
+    left_to_deposit = amount_wei - collateral_token_balance
     logger.info(
-        f"Depositing {wei_to_xdai(left_to_deposit)} {collateral_token_contract.symbol()}."
+        f"Depositing {left_to_deposit.as_token} {collateral_token_contract.symbol()}."
     )
     collateral_token_contract.deposit(api_keys, left_to_deposit, web3=web3)
 
 
 def auto_deposit_erc4626(
     collateral_token_contract: ContractERC4626BaseClass,
-    asset_amount_wei: Wei,
+    collateral_amount_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None,
 ) -> None:
@@ -72,12 +87,12 @@ def auto_deposit_erc4626(
     collateral_token_balance_in_shares = collateral_token_contract.balanceOf(
         for_address=for_address, web3=web3
     )
-    asset_amount_wei_in_shares = collateral_token_contract.convertToShares(
-        asset_amount_wei, web3
+    asset_amount_wei = collateral_token_contract.convertToAssets(
+        collateral_amount_wei, web3
     )
 
     # If we have enough shares, we don't need to deposit.
-    if collateral_token_balance_in_shares >= asset_amount_wei_in_shares:
+    if collateral_token_balance_in_shares >= collateral_amount_wei:
         return
 
     # If we need to deposit into erc4626, we first need to have enough of the asset token.
@@ -89,7 +104,7 @@ def auto_deposit_erc4626(
         collateral_token_balance_in_assets = collateral_token_contract.convertToAssets(
             collateral_token_balance_in_shares, web3
         )
-        left_to_deposit = Wei(asset_amount_wei - collateral_token_balance_in_assets)
+        left_to_deposit = asset_amount_wei - collateral_token_balance_in_assets
         if (
             collateral_token_contract.get_asset_token_balance(for_address, web3)
             < left_to_deposit
@@ -108,31 +123,25 @@ def auto_deposit_erc4626(
 
 def auto_deposit_erc20(
     collateral_token_contract: ContractERC20BaseClass,
-    amount_xdai_wei: Wei,
+    collateral_amount_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None,
 ) -> None:
-    # How much it is in the other token (collateral token).
-    collateral_amount_wei = get_buy_token_amount(
-        amount_xdai_wei,
-        KEEPING_ERC20_TOKEN.address,
-        collateral_token_contract.address,
-    )
     # How much do we have already in the other token (collateral token).
     collateral_balance_wei = collateral_token_contract.balanceOf(
         api_keys.bet_from_address
     )
     # Amount of collateral token remaining to get.
     remaining_to_get_in_collateral_wei = max(
-        0, collateral_amount_wei - collateral_balance_wei
+        Wei(0), collateral_amount_wei - collateral_balance_wei
     )
     if not remaining_to_get_in_collateral_wei:
         return
-    # Estimate of how much of the source token we need to sell in order to fill the remaining collateral amount, with 1% slippage to be sure.
-    amount_to_sell_wei = wei_type(
-        (remaining_to_get_in_collateral_wei * amount_xdai_wei)
-        / collateral_amount_wei
-        * 1.01
+    # Get of how much of the source token we need to sell in order to fill the remaining collateral amount.
+    amount_to_sell_wei = get_sell_token_amount(
+        remaining_to_get_in_collateral_wei,
+        sell_token=KEEPING_ERC20_TOKEN.address,
+        buy_token=collateral_token_contract.address,
     )
     # If we don't have enough of the source token.
     if amount_to_sell_wei > ContractERC20OnGnosisChain(

prediction_market_agent_tooling/tools/tokens/auto_withdraw.py

@@ -7,16 +7,9 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC20BaseClass,
     ContractERC4626BaseClass,
 )
-from prediction_market_agent_tooling.tools.cow.cow_order import (
-    get_buy_token_amount,
-    swap_tokens_waiting,
-)
+from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
 from prediction_market_agent_tooling.tools.utils import should_not_happen
-from prediction_market_agent_tooling.tools.web3_utils import (
-    remove_fraction,
-    wei_to_xdai,
-)
 
 
 def auto_withdraw_collateral_token(
@@ -24,14 +17,7 @@ def auto_withdraw_collateral_token(
     amount_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None = None,
-    slippage: float = 0.001,
 ) -> None:
-    # Small slippage as exact exchange rate constantly changes and we don't care about small differences.
-    amount_wei = remove_fraction(
-        amount_wei,
-        slippage,
-    )
-
     if not amount_wei:
         logger.warning(
             f"Amount to withdraw is zero, skipping withdrawal of {collateral_token_contract.symbol_cached(web3)}."
@@ -51,7 +37,7 @@ def auto_withdraw_collateral_token(
     ):
         # If the ERC4626 is backed by KEEPING_ERC20_TOKEN, we can withdraw it directly, no need to go through DEX.
         logger.info(
-            f"Withdrawing {wei_to_xdai(amount_wei)} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
+            f"Withdrawing {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         collateral_token_contract.withdraw_in_shares(
             api_keys,
@@ -60,18 +46,11 @@ def auto_withdraw_collateral_token(
         )
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
         logger.info(
-            f"Swapping {wei_to_xdai(amount_wei)} {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
+            f"Swapping {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         # Otherwise, DEX will handle the rest of token swaps.
-        # First, convert `amount_wei` from xDai-based value into the collateral token-based value.
-        collateral_amount_wei = get_buy_token_amount(
-            amount_wei,
-            KEEPING_ERC20_TOKEN.address,
-            collateral_token_contract.address,
-        )
-        # And then sell it.
         swap_tokens_waiting(
-            amount_wei=collateral_amount_wei,
+            amount_wei=amount_wei,
             sell_token=collateral_token_contract.address,
             buy_token=KEEPING_ERC20_TOKEN.address,
             api_keys=api_keys,

prediction_market_agent_tooling/tools/tokens/main_token.py

@@ -1,4 +1,4 @@
-from prediction_market_agent_tooling.gtypes import xdai_type
+from prediction_market_agent_tooling.gtypes import xDai
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
@@ -15,4 +15,4 @@ KEEPING_ERC20_TOKEN = ContractDepositableWrapperERC20OnGnosisChain(
     address=WRAPPED_XDAI_CONTRACT_ADDRESS
 )
 
-MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES = xdai_type(0.1)
+MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES = xDai(0.1)

prediction_market_agent_tooling/tools/tokens/token_utils.py

@@ -0,0 +1,46 @@
+from eth_typing.evm import ChecksumAddress
+from web3 import Web3
+
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
+from prediction_market_agent_tooling.tools.contract import (
+    ContractERC4626BaseClass,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
+)
+from prediction_market_agent_tooling.tools.cow.cow_order import get_buy_token_amount
+
+
+def convert_to_another_token(
+    amount: Wei,
+    from_token: ChecksumAddress,
+    to_token: ChecksumAddress,
+    web3: Web3 | None = None,
+) -> Wei:
+    from_token_contract = to_gnosis_chain_contract(
+        init_collateral_token_contract(from_token, web3)
+    )
+    to_token_contract = to_gnosis_chain_contract(
+        init_collateral_token_contract(to_token, web3)
+    )
+
+    if from_token == to_token:
+        return amount
+
+    elif (
+        isinstance(to_token_contract, ContractERC4626BaseClass)
+        and to_token_contract.get_asset_token_contract().address == from_token
+    ):
+        return to_token_contract.convertToShares(amount)
+
+    elif (
+        isinstance(from_token_contract, ContractERC4626BaseClass)
+        and from_token_contract.get_asset_token_contract().address == to_token
+    ):
+        return from_token_contract.convertToAssets(amount)
+
+    else:
+        return get_buy_token_amount(
+            amount,
+            from_token,
+            to_token,
+        )

prediction_market_agent_tooling/tools/tokens/usd.py

@@ -0,0 +1,79 @@
+from cachetools import TTLCache, cached
+from eth_typing.evm import ChecksumAddress
+
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    ChecksumAddress,
+    CollateralToken,
+    xDai,
+)
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    SDAI_CONTRACT_ADDRESS,
+    WRAPPED_XDAI_CONTRACT_ADDRESS,
+)
+from prediction_market_agent_tooling.tools.contract import ContractERC4626OnGnosisChain
+from prediction_market_agent_tooling.tools.cow.cow_order import get_buy_token_amount
+
+
+def get_usd_in_xdai(amount: USD) -> xDai:
+    # xDai is stable coin against USD, so for simplicity we just cast it.
+    return xDai(amount.value)
+
+
+def get_xdai_in_usd(amount: xDai) -> USD:
+    # xDai is stable coin against USD, so for simplicity we just cast it.
+    return USD(amount.value)
+
+
+def get_usd_in_token(amount: USD, token_address: ChecksumAddress) -> CollateralToken:
+    rate = get_single_usd_to_token_rate(token_address)
+    return CollateralToken(amount.value * rate.value)
+
+
+def get_token_in_usd(amount: CollateralToken, token_address: ChecksumAddress) -> USD:
+    rate = get_single_token_to_usd_rate(token_address)
+    return USD(amount.value * rate.value)
+
+
+# A short cache to not spam CoW and prevent timeouts, but still have relatively fresh data.
+@cached(TTLCache(maxsize=100, ttl=5 * 60))
+def get_single_token_to_usd_rate(token_address: ChecksumAddress) -> USD:
+    # (w)xDai is a stable coin against USD, so use it to estimate USD worth.
+    if WRAPPED_XDAI_CONTRACT_ADDRESS == token_address:
+        return USD(1.0)
+    # sDai is ERC4626 with wxDai as asset, we can take the rate directly from there instead of calling CoW.
+    if SDAI_CONTRACT_ADDRESS == token_address:
+        return USD(
+            ContractERC4626OnGnosisChain(address=SDAI_CONTRACT_ADDRESS)
+            .convertToAssets(CollateralToken(1).as_wei)
+            .as_token.value
+        )
+    in_wei = get_buy_token_amount(
+        sell_amount=CollateralToken(1).as_wei,
+        sell_token=token_address,
+        buy_token=WRAPPED_XDAI_CONTRACT_ADDRESS,
+    )
+    in_token = in_wei.as_token
+    return USD(in_token.value)
+
+
+# A short cache to not spam CoW and prevent timeouts, but still have relatively fresh data.
+@cached(TTLCache(maxsize=100, ttl=5 * 60))
+def get_single_usd_to_token_rate(token_address: ChecksumAddress) -> CollateralToken:
+    # (w)xDai is a stable coin against USD, so use it to estimate USD worth.
+    if WRAPPED_XDAI_CONTRACT_ADDRESS == token_address:
+        return CollateralToken(1.0)
+    # sDai is ERC4626 with wxDai as asset, we can take the rate directly from there instead of calling CoW.
+    if SDAI_CONTRACT_ADDRESS == token_address:
+        return CollateralToken(
+            ContractERC4626OnGnosisChain(address=SDAI_CONTRACT_ADDRESS)
+            .convertToShares(CollateralToken(1).as_wei)
+            .as_token.value
+        )
+    in_wei = get_buy_token_amount(
+        sell_amount=CollateralToken(1).as_wei,
+        sell_token=WRAPPED_XDAI_CONTRACT_ADDRESS,
+        buy_token=token_address,
+    )
+    in_token = in_wei.as_token
+    return CollateralToken(in_token.value)

prediction_market_agent_tooling/tools/utils.py

@@ -9,7 +9,13 @@ from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
 
-from prediction_market_agent_tooling.gtypes import DatetimeUTC, Probability, SecretStr
+from prediction_market_agent_tooling.gtypes import (
+    CollateralToken,
+    DatetimeUTC,
+    OutcomeToken,
+    Probability,
+    SecretStr,
+)
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 
@@ -182,11 +188,11 @@ def prob_uncertainty(prob: Probability) -> float:
 
 
 def calculate_sell_amount_in_collateral(
-    shares_to_sell: float,
-    holdings: float,
-    other_holdings: float,
+    shares_to_sell: OutcomeToken,
+    holdings: OutcomeToken,
+    other_holdings: OutcomeToken,
     fees: MarketFees,
-) -> float:
+) -> CollateralToken:
     """
     Computes the amount of collateral that needs to be sold to get `shares`
     amount of shares. Returns None if the amount can't be computed.
@@ -199,11 +205,11 @@ def calculate_sell_amount_in_collateral(
             raise ValueError("All share args must be greater than 0")
 
     def f(r: float) -> float:
-        R = (r + fees.absolute) / (1 - fees.bet_proportion)
+        R = OutcomeToken((r + fees.absolute) / (1 - fees.bet_proportion))
         first_term = other_holdings - R
         second_term = holdings + shares_to_sell - R
         third_term = holdings * other_holdings
-        return (first_term * second_term) - third_term
+        return ((first_term * second_term) - third_term).value
 
     amount_to_sell = newton(f, 0)
-    return float(amount_to_sell) * 0.999999  # Avoid rounding errors
+    return CollateralToken(float(amount_to_sell) * 0.999999)  # Avoid rounding errors

prediction_market_agent_tooling/tools/web3_utils.py

@@ -1,6 +1,6 @@
 import binascii
 import secrets
-from typing import Any, Optional, TypeVar
+from typing import Any, Optional
 
 import base58
 import tenacity
@@ -11,7 +11,7 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
-from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt, Wei
+from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt
 
 from prediction_market_agent_tooling.gtypes import (
     ABI,
@@ -23,12 +23,13 @@ from prediction_market_agent_tooling.gtypes import (
     PrivateKey,
     private_key_type,
     xDai,
-    xdai_type,
+    xDaiWei,
 )
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools._generic_value import _GenericValue
 
 ONE_NONCE = Nonce(1)
-ONE_XDAI = xdai_type(1)
+ONE_XDAI = xDai(1)
 ZERO_BYTES = HexBytes(HASH_ZERO)
 NOT_REVERTED_ICASE_REGEX_PATTERN = "(?i)(?!.*reverted.*)"
 
@@ -42,17 +43,6 @@ def private_key_to_public_key(private_key: SecretStr) -> ChecksumAddress:
     return verify_address(account.address)
 
 
-def wei_to_xdai(wei: Wei) -> xDai:
-    return xDai(float(Web3.from_wei(wei, "ether")))
-
-
-def xdai_to_wei(native: xDai) -> Wei:
-    return Web3.to_wei(native, "ether")
-
-
-RemoveOrAddFractionAmountType = TypeVar("RemoveOrAddFractionAmountType", bound=int)
-
-
 def verify_address(address: str) -> ChecksumAddress:
     if not Web3.is_checksum_address(address):
         raise ValueError(
@@ -61,26 +51,6 @@ def verify_address(address: str) -> ChecksumAddress:
     return ChecksumAddress(HexAddress(HexStr(address)))
 
 
-def remove_fraction(
-    amount: RemoveOrAddFractionAmountType, fraction: float
-) -> RemoveOrAddFractionAmountType:
-    """Removes the given fraction from the given integer-bounded amount and returns the value as an original type."""
-    if 0 <= fraction <= 1:
-        keep_percentage = 1 - fraction
-        return type(amount)(int(amount * keep_percentage))
-    raise ValueError(f"The given fraction {fraction!r} is not in the range [0, 1].")
-
-
-def add_fraction(
-    amount: RemoveOrAddFractionAmountType, fraction: float
-) -> RemoveOrAddFractionAmountType:
-    """Adds the given fraction to the given integer-bounded amount and returns the value as an original type."""
-    if 0 <= fraction <= 1:
-        keep_percentage = 1 + fraction
-        return type(amount)(int(amount * keep_percentage))
-    raise ValueError(f"The given fraction {fraction!r} is not in the range [0, 1].")
-
-
 def check_tx_receipt(receipt: TxReceipt) -> None:
     if receipt["status"] != 1:
         raise ValueError(
@@ -88,7 +58,20 @@ def check_tx_receipt(receipt: TxReceipt) -> None:
         )
 
 
+def unwrap_generic_value(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, _GenericValue):
+        return value.value
+    elif isinstance(value, list):
+        return [unwrap_generic_value(v) for v in value]
+    elif isinstance(value, dict):
+        return {k: unwrap_generic_value(v) for k, v in value.items()}
+    return value
+
+
 def parse_function_params(params: Optional[list[Any] | dict[str, Any]]) -> list[Any]:
+    params = unwrap_generic_value(params)
     if params is None:
         return []
     if isinstance(params, list):
@@ -172,8 +155,8 @@ def _prepare_tx_params(
     # Don't retry on `reverted` messages, as they would always fail again.
     # TODO: Check this, see https://github.com/gnosis/prediction-market-agent-tooling/issues/625.
     # retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
-    stop=tenacity.stop_after_attempt(9),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
+    stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx failed, {x.attempt_number=}."
     ),
@@ -210,7 +193,7 @@ def send_function_on_contract_tx(
     # Don't retry on `reverted` messages, as they would always fail again.
     # TODO: Check this, see https://github.com/gnosis/prediction-market-agent-tooling/issues/625.
     # retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
     stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx_using_safe failed, {x.attempt_number=}."
@@ -307,14 +290,14 @@ def send_xdai_to(
     web3: Web3,
     from_private_key: PrivateKey,
     to_address: ChecksumAddress,
-    value: Wei,
+    value: xDaiWei,
     data_text: Optional[str | bytes] = None,
     tx_params: Optional[TxParams] = None,
     timeout: int = 180,
 ) -> TxReceipt:
     from_address = private_key_to_public_key(from_private_key)
 
-    tx_params_new: TxParams = {"value": value, "to": to_address}
+    tx_params_new: TxParams = {"value": value.value, "to": to_address}
     if data_text is not None:
         tx_params_new["data"] = (
             Web3.to_bytes(text=data_text)
@@ -360,7 +343,7 @@ def byte32_to_ipfscidv0(hex: HexBytes) -> IPFSCIDVersion0:
 
 
 @tenacity.retry(
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
     stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"get_receipt_block_timestamp failed, {x.attempt_number=}."

{prediction_market_agent_tooling-0.61.2.dev479.dist-info → prediction_market_agent_tooling-0.62.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.61.2.dev479
+Version: 0.62.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -56,6 +56,7 @@ Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: tavily-python (>=0.5.0,<0.6.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Requires-Dist: typer (>=0.9.0,<1.0.0)
+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)