prediction-market-agent-tooling 0.67.1__py3-none-any.whl → 0.67.3__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -1,5 +1,6 @@
 import sys
 import typing as t
+from collections import defaultdict
 from enum import Enum
 from typing import Any
 
@@ -15,16 +16,22 @@ from prediction_market_agent_tooling.deploy.constants import (
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
+    ConditionalFilterType,
     FilterBy,
-    MarketType,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    SeerMarket,
+    SeerMarketQuestions,
+    SeerMarketWithQuestions,
+)
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
@@ -62,7 +69,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             )
         )
 
-    def _get_fields_for_markets(self, markets_field: FieldPath) -> list[FieldPath]:
+    def _get_fields_for_markets(
+        self, markets_field: FieldPath, current_level: int = 0, max_level: int = 1
+    ) -> list[FieldPath]:
         fields = [
             markets_field.id,
             markets_field.factory,
@@ -76,7 +85,6 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.payoutNumerators,
             markets_field.hasAnswers,
             markets_field.blockTimestamp,
-            markets_field.parentMarket.id,
             markets_field.openingTs,
             markets_field.finalizeTs,
             markets_field.wrappedTokens,
@@ -85,6 +93,18 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.lowerBound,
             markets_field.templateId,
         ]
+        if current_level < max_level:
+            fields.extend(
+                self._get_fields_for_markets(
+                    markets_field.parentMarket, current_level + 1, max_level
+                )
+            )
+            # TODO: Same situation as with `questions` field above.
+            # fields.extend(
+            #     self._get_fields_for_markets(
+            #         markets_field.childMarkets, current_level + 1, max_level
+            #     )
+            # )
         return fields
 
     @staticmethod
@@ -113,8 +133,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
     def _build_where_statements(
         filter_by: FilterBy,
         outcome_supply_gt_if_open: Wei,
-        include_conditional_markets: bool = False,
-        market_type: MarketType = MarketType.ALL,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
+        parent_market_id: HexBytes | None = None,
     ) -> dict[Any, Any]:
         now = to_int_timestamp(utcnow())
 
@@ -133,12 +154,12 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             case _:
                 raise ValueError(f"Unknown filter {filter_by}")
 
-        if not include_conditional_markets:
-            and_stms["parentMarket"] = ADDRESS_ZERO.lower()
+        if parent_market_id:
+            and_stms["parentMarket"] = parent_market_id.hex().lower()
 
         outcome_filters: list[dict[str, t.Any]] = []
 
-        if market_type == MarketType.SCALAR:
+        if question_type == QuestionType.SCALAR:
             # Template ID "1" + UP/DOWN outcomes for scalar markets
             and_stms["templateId"] = TemplateId.SCALAR.value
             up_filter = SeerSubgraphHandler._create_case_variations_condition(
@@ -149,7 +170,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             )
             outcome_filters.extend([up_filter, down_filter])
 
-        elif market_type == MarketType.BINARY:
+        elif question_type == QuestionType.BINARY:
             # Template ID "2" + YES/NO outcomes for binary markets
             and_stms["templateId"] = TemplateId.CATEGORICAL.value
             yes_filter = SeerSubgraphHandler._create_case_variations_condition(
@@ -160,7 +181,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             )
             outcome_filters.extend([yes_filter, no_filter])
 
-        elif market_type == MarketType.CATEGORICAL:
+        elif question_type == QuestionType.CATEGORICAL:
             # Template ID 2 (categorical) OR Template ID 3 (multi-categorical,
             # we treat them as categorical for now for simplicity)
             # https://reality.eth.limo/app/docs/html/contracts.html#templates
@@ -173,9 +194,21 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
                 }
             )
 
-        # If none specified, don't add any template/outcome filters (returns all types)
+        # Build filters for conditional_filter type
+        conditional_filter = {}
+        match conditional_filter_type:
+            case ConditionalFilterType.ONLY_CONDITIONAL:
+                conditional_filter["parentMarket_not"] = ADDRESS_ZERO.lower()
+            case ConditionalFilterType.ONLY_NOT_CONDITIONAL:
+                conditional_filter["parentMarket"] = ADDRESS_ZERO.lower()
+            case ConditionalFilterType.ALL:
+                pass
+            case _:
+                raise ValueError(
+                    f"Unknown conditional filter {conditional_filter_type}"
+                )
 
-        all_filters = [and_stms] + outcome_filters if and_stms else outcome_filters
+        all_filters = outcome_filters + [and_stms, conditional_filter]
         where_stms: dict[str, t.Any] = {"and": all_filters}
         return where_stms
 
@@ -211,16 +244,18 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         sort_by: SortBy = SortBy.NONE,
         limit: int | None = None,
         outcome_supply_gt_if_open: Wei = Wei(0),
-        market_type: MarketType = MarketType.ALL,
-        include_conditional_markets: bool = False,
-    ) -> list[SeerMarket]:
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
+        parent_market_id: HexBytes | None = None,
+    ) -> list[SeerMarketWithQuestions]:
         sort_direction, sort_by_field = self._build_sort_params(sort_by)
 
         where_stms = self._build_where_statements(
             filter_by=filter_by,
             outcome_supply_gt_if_open=outcome_supply_gt_if_open,
-            include_conditional_markets=include_conditional_markets,
-            market_type=market_type,
+            parent_market_id=parent_market_id,
+            question_type=question_type,
+            conditional_filter_type=conditional_filter_type,
         )
 
         # These values can not be set to `None`, but they can be omitted.
@@ -239,12 +274,65 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         )
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
-        return markets
+        market_ids = [m.id for m in markets]
+        # We fetch questions from all markets and all parents in one go
+        parent_market_ids = [
+            m.parent_market.id for m in markets if m.parent_market is not None
+        ]
+        q = SeerQuestionsCache(seer_subgraph_handler=self)
+        q.fetch_questions(list(set(market_ids + parent_market_ids)))
+
+        # Create SeerMarketWithQuestions for each market
+        return [
+            SeerMarketWithQuestions(
+                **m.model_dump(), questions=q.market_id_to_questions[m.id]
+            )
+            for m in markets
+        ]
+
+    def get_questions_for_markets(
+        self, market_ids: list[HexBytes]
+    ) -> list[SeerMarketQuestions]:
+        where = unwrap_generic_value(
+            {"market_in": [market_id.hex().lower() for market_id in market_ids]}
+        )
+        markets_field = self.seer_subgraph.Query.marketQuestions(where=where)
+        fields = self._get_fields_for_questions(markets_field)
+        questions = self.do_query(fields=fields, pydantic_model=SeerMarketQuestions)
+        return questions
 
-    def get_market_by_id(self, market_id: HexBytes) -> SeerMarket:
+    def get_market_by_id(self, market_id: HexBytes) -> SeerMarketWithQuestions:
         markets_field = self.seer_subgraph.Query.market(id=market_id.hex().lower())
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
+        if len(markets) != 1:
+            raise ValueError(
+                f"Fetched wrong number of markets. Expected 1 but got {len(markets)}"
+            )
+        q = SeerQuestionsCache(self)
+        q.fetch_questions([market_id])
+        questions = q.market_id_to_questions[market_id]
+        s = SeerMarketWithQuestions.model_validate(
+            markets[0].model_dump() | {"questions": questions}
+        )
+        return s
+
+    def _get_fields_for_questions(self, questions_field: FieldPath) -> list[FieldPath]:
+        fields = [
+            questions_field.question.id,
+            questions_field.question.best_answer,
+            questions_field.question.finalize_ts,
+            questions_field.market.id,
+        ]
+        return fields
+
+    def get_market_by_wrapped_token(self, token: ChecksumAddress) -> SeerMarket:
+        where_stms = {"wrappedTokens_contains": [token]}
+        markets_field = self.seer_subgraph.Query.markets(
+            where=unwrap_generic_value(where_stms)
+        )
+        fields = self._get_fields_for_markets(markets_field)
+        markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
         if len(markets) != 1:
             raise ValueError(
                 f"Fetched wrong number of markets. Expected 1 but got {len(markets)}"
@@ -303,3 +391,44 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             # We select the first one
             return pools[0]
         return None
+
+
+class SeerQuestionsCache(metaclass=SingletonMeta):
+    """A singleton cache for storing and retrieving Seer market questions.
+
+    This class provides an in-memory cache for Seer market questions, preventing
+    redundant subgraph queries by maintaining a mapping of market IDs to their
+    associated questions. It implements the singleton pattern to ensure a single
+    cache instance is used throughout the agent run.
+
+    Attributes:
+        market_id_to_questions: A dictionary mapping market IDs to lists of SeerMarketQuestions
+        seer_subgraph_handler: Handler for interacting with the Seer subgraph
+    """
+
+    def __init__(self, seer_subgraph_handler: SeerSubgraphHandler | None = None):
+        self.market_id_to_questions: dict[
+            HexBytes, list[SeerMarketQuestions]
+        ] = defaultdict(list)
+        self.seer_subgraph_handler = seer_subgraph_handler or SeerSubgraphHandler()
+
+    def fetch_questions(self, market_ids: list[HexBytes]) -> None:
+        filtered_list = [
+            market_id
+            for market_id in market_ids
+            if market_id not in self.market_id_to_questions
+        ]
+        if not filtered_list:
+            return
+
+        questions = self.seer_subgraph_handler.get_questions_for_markets(filtered_list)
+        # Group questions by market_id
+        questions_by_market: dict[HexBytes, list[SeerMarketQuestions]] = defaultdict(
+            list
+        )
+        for q in questions:
+            questions_by_market[q.market.id].append(q)
+
+        # Update the cache with the new questions for each market
+        for market_id, market_questions in questions_by_market.items():
+            self.market_id_to_questions[market_id] = market_questions

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -58,7 +58,3 @@ class CreateCategoricalMarketsParams(BaseModel):
     )  # typed as int for later .model_dump() usage (if using Wei, other keys also exported)
     opening_time: int = Field(..., alias="openingTime")
     token_names: list[str] = Field(..., alias="tokenNames")
-
-
-class SeerParentMarket(BaseModel):
-    id: HexBytes

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -19,7 +19,6 @@ from prediction_market_agent_tooling.markets.seer.seer_contracts import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
-from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 
 
 class SwapPoolHandler:
@@ -91,15 +90,6 @@ class SwapPoolHandler:
             amount_out_minimum=amount_out_minimum,
         )
 
-        # make sure user has enough tokens to sell
-        balance_collateral_token = ContractERC20OnGnosisChain(
-            address=token_in
-        ).balanceOf(self.api_keys.bet_from_address, web3=web3)
-        if balance_collateral_token < amount_wei:
-            raise ValueError(
-                f"Balance {balance_collateral_token} of {token_in} insufficient for trade, required {amount_wei}"
-            )
-
         tx_receipt = SwaprRouterContract().exact_input_single(
             api_keys=self.api_keys, params=p, web3=web3
         )

prediction_market_agent_tooling/tools/contract.py

@@ -413,6 +413,20 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         return self.convertToShares(amount, web3=web3)
 
 
+class ContractWrapped1155BaseClass(ContractERC20BaseClass):
+    """Wrapped 1155 contract from Seer (https://gnosisscan.io/address/0x2f9c49974ad8b9b31424d9dc812667b16310ca50#readContract)
+    Source code - https://github.com/seer-pm/demo/blob/main/contracts/src/interaction/1155-to-20/Wrapped1155Factory.sol#L224
+    This contract inherits from ERC20 and contains additional properties, such as multiToken (conditional Token contract implementation)
+    and tokenId (token identifier). Goal is to wrap individual tokens into a standalone ERC20 token.
+    """
+
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "../abis/erc1155.abi.json"
+        )
+    )
+
+
 class OwnableContract(ContractBaseClass):
     abi: ABI = abi_field_validator(
         os.path.join(
@@ -533,6 +547,12 @@ class ContractDepositableWrapperERC20OnGnosisChain(
     """
 
 
+class ContractWrapped1155OnGnosisChain(
+    ContractWrapped1155BaseClass, ContractERC20OnGnosisChain
+):
+    pass
+
+
 class ContractERC4626OnGnosisChain(
     ContractERC4626BaseClass, ContractERC20OnGnosisChain
 ):
@@ -626,6 +646,11 @@ def contract_implements_function(
                 function_name=function_name,
                 web3=web3,
                 function_arg_types=function_arg_types,
+            ) or seer_minimal_proxy_implements_function(
+                contract_address=contract_address,
+                function_name=function_name,
+                web3=web3,
+                function_arg_types=function_arg_types,
             )
 
     return implements
@@ -654,6 +679,31 @@ def minimal_proxy_implements_function(
         return False
 
 
+def seer_minimal_proxy_implements_function(
+    contract_address: ChecksumAddress,
+    function_name: str,
+    web3: Web3,
+    function_arg_types: list[str] | None = None,
+) -> bool:
+    try:
+        # Read address between specific indices to find logic contract
+        bytecode = web3.eth.get_code(contract_address)
+        logic_contract_address = bytecode[11:31]
+        if not Web3.is_address(logic_contract_address):
+            return False
+
+        return contract_implements_function(
+            Web3.to_checksum_address(logic_contract_address),
+            function_name=function_name,
+            web3=web3,
+            function_arg_types=function_arg_types,
+            look_for_proxy_contract=False,
+        )
+    except DecodingError:
+        logger.info("Error decoding contract address on seer minimal proxy")
+        return False
+
+
 def init_collateral_token_contract(
     address: ChecksumAddress, web3: Web3 | None
 ) -> ContractERC20BaseClass:
@@ -673,6 +723,13 @@ def init_collateral_token_contract(
     ):
         return ContractDepositableWrapperERC20BaseClass(address=address)
 
+    elif contract_implements_function(
+        address,
+        "multiToken",
+        web3=web3,
+    ):
+        return ContractWrapped1155BaseClass(address=address)
+
     elif contract_implements_function(
         address,
         "balanceOf",
@@ -694,6 +751,8 @@ def to_gnosis_chain_contract(
         return ContractERC4626OnGnosisChain(address=contract.address)
     elif isinstance(contract, ContractDepositableWrapperERC20BaseClass):
         return ContractDepositableWrapperERC20OnGnosisChain(address=contract.address)
+    elif isinstance(contract, ContractWrapped1155BaseClass):
+        return ContractWrapped1155OnGnosisChain(address=contract.address)
     elif isinstance(contract, ContractERC20BaseClass):
         return ContractERC20OnGnosisChain(address=contract.address)
     else:

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -167,10 +167,13 @@ def handle_allowance(
     api_keys: APIKeys,
     sell_token: ChecksumAddress,
     amount_wei: Wei,
+    for_address: ChecksumAddress | None = None,
     web3: Web3 | None = None,
 ) -> None:
     # Approve the CoW Swap Vault Relayer to get the sell token only if allowance not sufficient.
-    for_address = Web3.to_checksum_address(CowContractAddress.VAULT_RELAYER.value)
+    for_address = for_address or Web3.to_checksum_address(
+        CowContractAddress.VAULT_RELAYER.value
+    )
     current_allowance = ContractERC20OnGnosisChain(address=sell_token).allowance(
         owner=api_keys.bet_from_address,
         for_address=for_address,

prediction_market_agent_tooling/tools/rephrase.py

@@ -0,0 +1,71 @@
+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.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+from prediction_market_agent_tooling.tools.utils import (
+    LLM_SEED,
+    LLM_SUPER_LOW_TEMPERATURE,
+)
+
+REPHRASE_QUESTION_PROMPT = """Given the following question of main interest: {question}
+
+But it's conditioned on `{parent_question}` resolving to `{needed_parent_outcome}`.
+
+Rewrite the main question to contain the parent question in the correct form. 
+
+The main question will be used as a prediction market, so it does need to be rephrased using the parent question properly. Such that the probability of the main question also accounts for the conditioned outcome.
+
+For example:
+```
+Main question: What is the probability of <X> happening before <date>?
+Conditioned on: Will <Y> happen before <another-date>?
+Rephrased: What is the joint probability of Y happening before <another-date> and then X happening before <date>?
+```
+
+Output only the rephrased question.
+"""
+
+
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
+@observe()
+@db_cache
+def rephrase_question_to_unconditional(
+    question: str,
+    parent_question: str,
+    needed_parent_outcome: str,
+    engine: str = "gpt-4.1",
+    temperature: float = LLM_SUPER_LOW_TEMPERATURE,
+    seed: int = LLM_SEED,
+    prompt_template: str = REPHRASE_QUESTION_PROMPT,
+    max_tokens: int = 1024,
+) -> str:
+    try:
+        from langchain.prompts import ChatPromptTemplate
+        from langchain_openai import ChatOpenAI
+    except ImportError:
+        raise ImportError("langchain not installed")
+
+    llm = ChatOpenAI(
+        model_name=engine,
+        temperature=temperature,
+        seed=seed,
+        openai_api_key=APIKeys().openai_api_key,
+    )
+
+    prompt = ChatPromptTemplate.from_template(template=prompt_template)
+    messages = prompt.format_messages(
+        question=question,
+        parent_question=parent_question,
+        needed_parent_outcome=needed_parent_outcome,
+    )
+    completion = str(
+        llm.invoke(
+            messages, max_tokens=max_tokens, config=get_langfuse_langchain_config()
+        ).content
+    )
+
+    return completion

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -3,14 +3,22 @@ from web3 import Web3
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import USD, Wei
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.seer.seer_contracts import GnosisRouter
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20BaseClass,
     ContractERC20BaseClass,
     ContractERC20OnGnosisChain,
     ContractERC4626BaseClass,
+    ContractWrapped1155BaseClass,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_sell_token_amount,
+    handle_allowance,
     swap_tokens_waiting,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
@@ -49,6 +57,9 @@ def auto_deposit_collateral_token(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
         )
 
+    elif isinstance(collateral_token_contract, ContractWrapped1155BaseClass):
+        mint_full_set(collateral_token_contract, collateral_amount_wei, api_keys, web3)
+
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
         auto_deposit_erc20(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
@@ -170,3 +181,49 @@ def auto_deposit_erc20(
         web3=web3,
         slippage_tolerance=slippage_tolerance,
     )
+
+
+def mint_full_set(
+    collateral_token_contract: ContractERC20BaseClass,
+    collateral_amount_wei: Wei,
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    router = GnosisRouter()
+    # We need to fetch the parent's market collateral token, to split it and get the collateral token
+    # of the child market.
+    seer_subgraph_handler = SeerSubgraphHandler()
+    market = seer_subgraph_handler.get_market_by_wrapped_token(
+        token=collateral_token_contract.address
+    )
+    market_collateral_token = Web3.to_checksum_address(market.collateral_token)
+
+    balance_market_collateral = ContractERC20OnGnosisChain(
+        address=market_collateral_token
+    ).balanceOf(for_address=api_keys.bet_from_address, web3=web3)
+    if balance_market_collateral < collateral_amount_wei:
+        logger.debug(
+            f"Not enough collateral token in the market. Expected {collateral_amount_wei} but got {balance_market_collateral}. Auto-depositing market collateral."
+        )
+        market_collateral_token_contract = to_gnosis_chain_contract(
+            init_collateral_token_contract(market_collateral_token, web3=web3)
+        )
+        auto_deposit_collateral_token(
+            market_collateral_token_contract, collateral_amount_wei, api_keys, web3
+        )
+
+    handle_allowance(
+        api_keys=api_keys,
+        sell_token=market_collateral_token,
+        amount_wei=collateral_amount_wei,
+        for_address=router.address,
+        web3=web3,
+    )
+
+    router.split_position(
+        api_keys=api_keys,
+        collateral_token=market_collateral_token,
+        market_id=Web3.to_checksum_address(market.id),
+        amount=collateral_amount_wei,
+        web3=web3,
+    )

{prediction_market_agent_tooling-0.67.1.dist-info → prediction_market_agent_tooling-0.67.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.67.1
+Version: 0.67.3
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -42,6 +42,7 @@ 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: 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)
 Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: pytest-postgresql (>=6.1.1,<7.0.0)