digitalkin 0.3.1__py3-none-any.whl → 0.3.1.dev0__py3-none-any.whl

digitalkin/utils/__init__.py

@@ -1,29 +1 @@
 """General utils folder."""
-
-from digitalkin.utils.dynamic_schema import (
-    DEFAULT_TIMEOUT,
-    DynamicField,
-    Fetcher,
-    ResolveResult,
-    get_dynamic_metadata,
-    get_fetchers,
-    has_dynamic,
-    resolve,
-    resolve_safe,
-)
-
-# Alias for cleaner API: `Dynamic` is shorter than `DynamicField`
-Dynamic = DynamicField
-
-__all__ = [
-    "DEFAULT_TIMEOUT",
-    "Dynamic",
-    "DynamicField",
-    "Fetcher",
-    "ResolveResult",
-    "get_dynamic_metadata",
-    "get_fetchers",
-    "has_dynamic",
-    "resolve",
-    "resolve_safe",
-]

{digitalkin-0.3.1.dist-info → digitalkin-0.3.1.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1
+Version: 0.3.1.dev0
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,17 +452,17 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto==0.2.0
+Requires-Dist: digitalkin-proto>=0.2.0.dev4
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: surrealdb>=1.0.6
 Provides-Extra: taskiq
 Requires-Dist: rstream>=0.40.0; extra == "taskiq"
-Requires-Dist: taskiq-aio-pika>=0.5.0; extra == "taskiq"
+Requires-Dist: taskiq-aio-pika>=0.4.4; extra == "taskiq"
 Requires-Dist: taskiq-redis>=1.1.2; extra == "taskiq"
-Requires-Dist: taskiq[reload]>=0.12.0; extra == "taskiq"
+Requires-Dist: taskiq[reload]>=0.11.20; extra == "taskiq"
 Dynamic: license-file
 
 # DigitalKin Python SDK

{digitalkin-0.3.1.dist-info → digitalkin-0.3.1.dev0.dist-info}/RECORD

@@ -7,7 +7,7 @@ base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,
 base_server/mock/mock_pb2.py,sha256=sETakcS3PAAm4E-hTCV1jIVaQTPEAIoVVHupB8Z_k7Y,1843
 base_server/mock/mock_pb2_grpc.py,sha256=BbOT70H6q3laKgkHfOx1QdfmCS_HxCY4wCOX84YAdG4,3180
 digitalkin/__init__.py,sha256=7LLBAba0th-3SGqcpqFO-lopWdUkVLKzLZiMtB-mW3M,162
-digitalkin/__version__.py,sha256=0omxzqFcYfxaU-TVHe1JXWxx_WF4A1CqJ5Rn6pCDm30,190
+digitalkin/__version__.py,sha256=Q0IBkIes3oz9LCKqzDtGa5rK6FC1xTmf-s6rHrrfiuQ,195
 digitalkin/logger.py,sha256=8ze_tjt2G6mDTuQcsf7-UTXWP3UHZ7LZVSs_iqF4rX4,4685
 digitalkin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 digitalkin/core/__init__.py,sha256=FJRcJ-B1Viyn-38L8XpOpZ8KOnf1I7PCDOAmKXLQhqc,71
@@ -16,19 +16,19 @@ digitalkin/core/common/factories.py,sha256=mV6SmXXrZxzIQ7DLdDtPdjapSDZt5Ua-nBIDs
 digitalkin/core/job_manager/__init__.py,sha256=gGtgQpE6vbBHxAj1SYMbcpj45Q6x8IcsqnyQPfyZZ-8,25
 digitalkin/core/job_manager/base_job_manager.py,sha256=yVaakJNIEPWc6ND1bWrUgBA-8r1yEEQZ_iNP1RnK0jY,10076
 digitalkin/core/job_manager/single_job_manager.py,sha256=7MkttI7pP0aZUHgz8apQf3kXHNI3Mbh8F5LfKwLhRpo,13789
-digitalkin/core/job_manager/taskiq_broker.py,sha256=ti-wb9yNsspQEDOCbL0OhUwsvcA447lLKywjvKHgVQA,11406
-digitalkin/core/job_manager/taskiq_job_manager.py,sha256=IQ2g34mA_AsbIHNiSpzxxT6KzoOEUVb_67659LgBT_4,21251
+digitalkin/core/job_manager/taskiq_broker.py,sha256=4BbuvKZNWIVbAHmle8XdpPolHhiOv9XgCWR1VGAFg8E,11400
+digitalkin/core/job_manager/taskiq_job_manager.py,sha256=04DDMhik09368aCGxmrqR011VOEDgmpFVxC_ugN6Fzs,21352
 digitalkin/core/task_manager/__init__.py,sha256=k9i-qIoee_1yXogyQolaVFDUQBIZU3ENbYKtjrCNmTQ,31
-digitalkin/core/task_manager/base_task_manager.py,sha256=ahkflSul07hMAWRX22CoJf9FxpQhWzi_oKZz3YAN6lc,19416
+digitalkin/core/task_manager/base_task_manager.py,sha256=CCAltJul85WMVEaJMsNHO58QSIirRrOcVZj7cQud-v8,16751
 digitalkin/core/task_manager/local_task_manager.py,sha256=Z1gv4dCGD32LBSfMZJ4dGyYDe80lZRAyowTgGC6E4Vk,3534
 digitalkin/core/task_manager/remote_task_manager.py,sha256=zgccmnwwtB0nyeIZlL5Ji8SY1J89z_vjA4JD9ur7HzY,3082
 digitalkin/core/task_manager/surrealdb_repository.py,sha256=eNOVrYhTiIM0jd8j46fsKDr_THbGdK3xrog2jeqSQyA,9671
-digitalkin/core/task_manager/task_executor.py,sha256=8xh5_1zuRAaGZIH_gWyNsA4T7YYaF0sl51dLS8a6aAk,10981
-digitalkin/core/task_manager/task_session.py,sha256=ZU2GqtWAZidG7M7K_6GgEemBKRZ_RP2pW-3ODQSqP84,13665
+digitalkin/core/task_manager/task_executor.py,sha256=EN8aIXZFh01dMcMw01u5QEKw3mz1IAkIWpe4l3zssc0,7373
+digitalkin/core/task_manager/task_session.py,sha256=OT0jV_xYCAEyB3krSaGMqHUiGEOinu2h7Y-3kIu3Zx8,11525
 digitalkin/grpc_servers/__init__.py,sha256=ZIRMJ1Lcas8yQ106GCup6hn2UBOsx1sNk8ap0lpEDnY,72
 digitalkin/grpc_servers/_base_server.py,sha256=ZVeCDwI7w7fFbPTXPkeJb_SOuLfd2T7za3T4oCu2UWY,18680
 digitalkin/grpc_servers/module_server.py,sha256=fJncoCQ-nHK4rs1PFM99Ds0U1Axjxj1X4ILeud96AvM,10235
-digitalkin/grpc_servers/module_servicer.py,sha256=V8rlOUKGF4wq27dBtCpqvYUd0WVgXRDBB7jaGtofTck,19724
+digitalkin/grpc_servers/module_servicer.py,sha256=JxZwoMNi1nkMOW7qCQrvV5fJd5y-PWU-bq-EAgwtLHc,19404
 digitalkin/grpc_servers/registry_server.py,sha256=v4pFpkcnWHL3Sm4CHw8wTKbSAvppEYgg_ikgdirmazc,2235
 digitalkin/grpc_servers/registry_servicer.py,sha256=5AaGacM875fHCiOmMRuqx4Q3ZsR5yvdfjuRsV4xhRcA,16485
 digitalkin/grpc_servers/utils/__init__.py,sha256=ZnAIb_F8z4NhtPypqkdmzgRSzolKnJTk3oZx5GfWH5Y,38
@@ -47,26 +47,26 @@ digitalkin/mixins/storage_mixin.py,sha256=ptZ4a2bydIa48q0V9e395vWHTu7yw4A6rI4jwK
 digitalkin/models/__init__.py,sha256=hDHtUfswaNh8wo4NZaBItg9JqC0uNSRqXArNWSrGynY,163
 digitalkin/models/core/__init__.py,sha256=jOMDmPX0uSfGA9zUi0u_kOvYJ46VdIssoIhVYvNSeew,19
 digitalkin/models/core/job_manager_models.py,sha256=RCrW20HCTQ7l2D1JtNgEKefZpMzoN-uAXK8bPorIqqA,1120
-digitalkin/models/core/task_monitor.py,sha256=XNYCxhN9QqJZhuO2LoiWEHZwhA35dsupyfYvek_pgE8,2295
+digitalkin/models/core/task_monitor.py,sha256=JBMzqaKLrsxb0QZYM1BlvCxxkbqD_YKgsWob7bsmBeE,1626
 digitalkin/models/grpc_servers/__init__.py,sha256=0tA71nPSXgRrh9DoLvx-TSwZXdYIRUEItoadpTL1cTo,42
-digitalkin/models/grpc_servers/models.py,sha256=unV1Wo0u3Efm7ddgYyYZZYUC_W6F0S5BQYH3xsOmXjw,8965
+digitalkin/models/grpc_servers/models.py,sha256=ZQ1Gk4zmLRX_ueuwFOwXgtyG9OEPSzFa_91I_CXZmZ0,8957
 digitalkin/models/grpc_servers/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w6ELjmjgBao,539
 digitalkin/models/module/__init__.py,sha256=nFPHp0JcAZq9ISkcSu1y2zeNyXH3V4j10oMjHzMBYBU,599
 digitalkin/models/module/module.py,sha256=k0W8vfJJFth8XdDzkHm32SyTuSf3h2qF0hSrxAfGF1s,956
-digitalkin/models/module/module_context.py,sha256=Ykul3foD_-dpn-b54vkTeGOYvktagMp2fFEkCI_1-5A,4905
-digitalkin/models/module/module_types.py,sha256=Z46NPBCf8yDot4ZT_iJfBMo8J-IhpYiJJlKJsXxe6vA,14445
+digitalkin/models/module/module_context.py,sha256=0sKIvLYt0KHR4oF0MUQ4RQZDBrPjmOSaIHNMcl7vUmI,4649
+digitalkin/models/module/module_types.py,sha256=FPoF5PenhfFr6gCDF7ZyyJQDkt9JZAfpiHlE8HErIuM,3699
 digitalkin/models/services/__init__.py,sha256=jhfVw6egq0OcHmos_fypH9XFehbHTBw09wluVFVFEyw,226
 digitalkin/models/services/cost.py,sha256=9PXvd5RrIk9vCrRjcUGQ9ZyAokEbwLg4s0RfnE-aLP4,1616
 digitalkin/models/services/storage.py,sha256=wp7F-AvTsU46ujGPcguqM5kUKRZx4399D4EGAAJt2zs,1143
 digitalkin/modules/__init__.py,sha256=VwVbKok81NGyPIBZgEj_SR-59G8tTlSb4eBJI9W6Vx4,281
-digitalkin/modules/_base_module.py,sha256=g9QhgZAkTOei7_eB76Yg6WX87noN2G8V016FF6guTEk,18359
+digitalkin/modules/_base_module.py,sha256=UDLPbsVqlRdvT1weJ_Skzgv7R16TOyfSWeddg5ZqxzI,16513
 digitalkin/modules/archetype_module.py,sha256=lOe3yYufwfylZR_VGy1w-zqdqVaMI_JANfKkbH9eODE,471
 digitalkin/modules/tool_module.py,sha256=rLJfdYMWddiUgPLBDGG_UcHnRCHEeaqX6Fdp4DOUaCs,472
 digitalkin/modules/trigger_handler.py,sha256=qPNMi-8NHqscOxciHeaXtpwjXApT3YzjMF23zQAjaZY,1770
 digitalkin/services/__init__.py,sha256=LqGk_5DJy8Bzz62ajIq9jCeYNKQUIgtSCpafZk15FLc,910
 digitalkin/services/base_strategy.py,sha256=yA9KUJGRKuuaxA6l3GcMv8zKfWoIsW03UxJT80Yea2I,766
-digitalkin/services/services_config.py,sha256=r9h6iYdsIifyBxaEEuZ4cKRPo3u-703Ea9hOjiK3GLU,8063
-digitalkin/services/services_models.py,sha256=0HmveQ1H-dvGRl1ljFSpWNlLWIiDhbhyqKUxq5UjbLo,1759
+digitalkin/services/services_config.py,sha256=JnyzZcG7OYBelwgn-wdVgY2n3yFTEkwLPHRZB8Tjw10,7468
+digitalkin/services/services_models.py,sha256=5zXkWcfKnXGwQi9sN4OAL3XrgqOcmsTl8ai5Mi4RPsw,1668
 digitalkin/services/agent/__init__.py,sha256=vJc8JN0pdtA8ecypLBeHrwAUIW6H2C8NyW-dk24rTpk,244
 digitalkin/services/agent/agent_strategy.py,sha256=42Q9RciHX6tg3CgDQkbrlIx4h_TX0WIuSpLmCjitVmA,492
 digitalkin/services/agent/default_agent.py,sha256=4N_E_eQxJGOx1KVUUg5jNOje-3ncMxF3ePB-uDuGrJc,345
@@ -95,25 +95,23 @@ digitalkin/services/storage/__init__.py,sha256=T-ocYLLphudkQgzvG47jBOm5GQsRFRIGA
 digitalkin/services/storage/default_storage.py,sha256=D8e-UYUkb2GvDEHMWcN3EkcIKXWA8DrsaQsXVjoXAYQ,7975
 digitalkin/services/storage/grpc_storage.py,sha256=fFg83gvwJZW1a7f2AwSrxJFx949-KbNwpakPaCuGEvo,7217
 digitalkin/services/storage/storage_strategy.py,sha256=sERF5tIJnzpb1iNqTXic9xRkGaXMifo6kb709ubB-Yo,8848
-digitalkin/services/user_profile/__init__.py,sha256=RKEZCsgCHS7fmswhWgUoQd6vZ_1pYnRqERoF8fmu7jw,434
+digitalkin/services/user_profile/__init__.py,sha256=zwD91Q6Q8iL6RXFB5GmtE6ldFQXU6_OVir6dVXAGKqI,35
 digitalkin/services/user_profile/default_user_profile.py,sha256=46DH_VBCHKXJVyagVcc8kH5sLwRK54Fe_0ahqYJ1maA,1847
-digitalkin/services/user_profile/grpc_user_profile.py,sha256=VBjXTySGBJO7cQ_hMsdYSUUyk3KFykeQqed82LlTihk,2811
+digitalkin/services/user_profile/grpc_user_profile.py,sha256=97-19z7ioBVFeiF3Fc-gejY84pWuRZQXVNPr56gksg8,2794
 digitalkin/services/user_profile/user_profile_strategy.py,sha256=luzpPvm2f4xXajWAbRGSk5YCIPBUrn5EOrXSz8NL1So,1148
-digitalkin/utils/__init__.py,sha256=gDoEk5CP8tiBmIq-38aPhIMlnDUiqRrduuVXhpSPQnc,541
+digitalkin/utils/__init__.py,sha256=sJnY-ZUgsjMfojAjONC1VN14mhgIDnzyOlGkw21rRnM,28
 digitalkin/utils/arg_parser.py,sha256=wzscRlE1Qp1gGl-lAJlkkwnbU1O2oezj6BwK_BZFBIk,3158
 digitalkin/utils/development_mode_action.py,sha256=2hznh0ajW_4ZTysfoc0Y49161f_PQPATRgNk8NAn1_o,1623
-digitalkin/utils/dynamic_schema.py,sha256=5-B3dBGlCYYv6uRJkgudtc0ZpBOTYxl0yKedDGsteZQ,15184
 digitalkin/utils/llm_ready_schema.py,sha256=JjMug_lrQllqFoanaC091VgOqwAd-_YzcpqFlS7p778,2375
 digitalkin/utils/package_discover.py,sha256=sa6Zp5Kape1Zr4iYiNrnZxiHDnqM06ODk6yfWHom53w,13465
-digitalkin-0.3.1.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
+digitalkin-0.3.1.dev0.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
 modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modules/cpu_intensive_module.py,sha256=ejB9XPnFfA0uCuFUQbM3fy5UYfqqAlF36rv_P5Ri8ho,8363
-modules/dynamic_setup_module.py,sha256=GPJwfaPZUkcOlMX9d_sYUDzT8aPrfjrCCQ4OyPtulD8,12507
 modules/minimal_llm_module.py,sha256=Ijld__ZnhzfLwpXD1XVkLZ7jyKZKyOFZczOpiPttJZc,11216
 modules/text_transform_module.py,sha256=bwPSnEUthZQyfLwcTLo52iAxItAoknkLh8Y3m5aywaY,7251
 services/filesystem_module.py,sha256=71Mcja8jCQqiqFHPdsIXplFIHTvgkxRhp0TRXuCfgkk,7430
 services/storage_module.py,sha256=ybTMqmvGaTrR8PqJ4FU0cwxaDjT36TskVrGoetTGmno,6955
-digitalkin-0.3.1.dist-info/METADATA,sha256=TLih9e_7ssTTi6R8maDOVg7J4TZkdILV_qR9jYbGjqk,29709
-digitalkin-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-digitalkin-0.3.1.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
-digitalkin-0.3.1.dist-info/RECORD,,
+digitalkin-0.3.1.dev0.dist-info/METADATA,sha256=orxFRM6GJLgC6DrDpmpzlrtK17hop_3x3rqagEEWu_k,29720
+digitalkin-0.3.1.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+digitalkin-0.3.1.dev0.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
+digitalkin-0.3.1.dev0.dist-info/RECORD,,

digitalkin/utils/dynamic_schema.py

@@ -1,483 +0,0 @@
-"""Dynamic schema utilities for runtime value refresh in Pydantic models.
-
-This module provides a clean way to mark fields as dynamic using Annotated metadata,
-allowing their schema values to be refreshed at runtime via sync or async fetchers.
-
-Example:
-    from typing import Annotated
-    from digitalkin.utils import DynamicField
-
-    class AgentSetup(SetupModel):
-        model_name: Annotated[str, DynamicField(enum=fetch_models)] = Field(default="gpt-4")
-
-See Also:
-    - Documentation: docs/api/dynamic_schema.md
-    - Tests: tests/utils/test_dynamic_schema.py
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-import traceback
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
-from itertools import starmap
-from typing import TYPE_CHECKING, Any, TypeVar
-
-from digitalkin.logger import logger
-
-if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
-T = TypeVar("T")
-
-# Fetcher callable type: sync or async function with no arguments
-Fetcher = Callable[[], T | Awaitable[T]]
-
-# Default timeout for fetcher resolution (None = no timeout)
-DEFAULT_TIMEOUT: float | None = None
-
-
-@dataclass
-class ResolveResult:
-    """Result of resolving dynamic fetchers.
-
-    Provides structured access to resolved values and any errors that occurred.
-    This allows callers to handle partial failures gracefully.
-
-    Attributes:
-        values: Dict mapping key names to successfully resolved values.
-        errors: Dict mapping key names to exceptions that occurred during resolution.
-    """
-
-    values: dict[str, Any] = field(default_factory=dict)
-    errors: dict[str, Exception] = field(default_factory=dict)
-
-    @property
-    def success(self) -> bool:
-        """Check if all fetchers resolved successfully.
-
-        Returns:
-            True if no errors occurred, False otherwise.
-        """
-        return len(self.errors) == 0
-
-    @property
-    def partial(self) -> bool:
-        """Check if some but not all fetchers succeeded.
-
-        Returns:
-            True if there are both values and errors, False otherwise.
-        """
-        return len(self.values) > 0 and len(self.errors) > 0
-
-    def get(self, key: str, default: T | None = None) -> T | None:
-        """Get a resolved value by key.
-
-        Args:
-            key: The fetcher key name.
-            default: Default value if key not found or errored.
-
-        Returns:
-            The resolved value or default.
-        """
-        return self.values.get(key, default)  # type: ignore[return-value]
-
-
-class DynamicField:
-    """Metadata class for Annotated fields with dynamic fetchers.
-
-    Use with typing.Annotated to mark fields that need runtime value resolution.
-    Fetchers are callables (sync or async) that return values at runtime.
-
-    Args:
-        **fetchers: Mapping of key names to fetcher callables.
-            Each fetcher is a function (sync or async) that takes no arguments
-            and returns the value for that key (e.g., enum values, defaults).
-
-    Example:
-        from typing import Annotated
-
-        async def fetch_models() -> list[str]:
-            return await api.get_models()
-
-        class Setup(SetupModel):
-            model: Annotated[str, DynamicField(enum=fetch_models)] = Field(default="gpt-4")
-    """
-
-    __slots__ = ("fetchers",)
-
-    def __init__(self, **fetchers: Fetcher[Any]) -> None:
-        """Initialize with fetcher callables."""
-        self.fetchers: dict[str, Fetcher[Any]] = fetchers
-
-    def __repr__(self) -> str:
-        """Return string representation."""
-        keys = ", ".join(self.fetchers.keys())
-        return f"DynamicField({keys})"
-
-    def __eq__(self, other: object) -> bool:
-        """Check equality based on fetchers.
-
-        Returns:
-            True if fetchers are equal, NotImplemented for non-DynamicField types.
-        """
-        if not isinstance(other, DynamicField):
-            return NotImplemented
-        return self.fetchers == other.fetchers
-
-    def __hash__(self) -> int:
-        """Hash based on fetcher keys (fetchers themselves aren't hashable).
-
-        Returns:
-            Hash value based on sorted fetcher keys.
-        """
-        return hash(tuple(sorted(self.fetchers.keys())))
-
-
-def get_dynamic_metadata(field_info: FieldInfo) -> DynamicField | None:
-    """Extract DynamicField metadata from a FieldInfo's metadata list.
-
-    Args:
-        field_info: The Pydantic FieldInfo object to inspect.
-
-    Returns:
-        The DynamicField metadata instance if found, None otherwise.
-    """
-    for meta in field_info.metadata:
-        if isinstance(meta, DynamicField):
-            return meta
-    return None
-
-
-def has_dynamic(field_info: FieldInfo) -> bool:
-    """Check if a field has DynamicField metadata.
-
-    Args:
-        field_info: The Pydantic FieldInfo object to check.
-
-    Returns:
-        True if the field has DynamicField metadata, False otherwise.
-    """
-    return get_dynamic_metadata(field_info) is not None
-
-
-def get_fetchers(field_info: FieldInfo) -> dict[str, Fetcher[Any]]:
-    """Extract fetchers from a field's DynamicField metadata.
-
-    Args:
-        field_info: The Pydantic FieldInfo object to extract from.
-
-    Returns:
-        Dict mapping key names to fetcher callables, empty if no DynamicField metadata.
-    """
-    meta = get_dynamic_metadata(field_info)
-    if meta is None:
-        return {}
-    return meta.fetchers
-
-
-def _get_fetcher_info(fetcher: Fetcher[Any]) -> str:
-    """Get descriptive info about a fetcher for logging.
-
-    Args:
-        fetcher: The fetcher callable.
-
-    Returns:
-        A string describing the fetcher (module.name or repr).
-    """
-    if hasattr(fetcher, "__module__") and hasattr(fetcher, "__qualname__"):
-        return f"{fetcher.__module__}.{fetcher.__qualname__}"
-    if hasattr(fetcher, "__name__"):
-        return fetcher.__name__
-    return repr(fetcher)
-
-
-async def _resolve_one(key: str, fetcher: Fetcher[Any]) -> tuple[str, Any]:
-    """Resolve a single fetcher.
-
-    Args:
-        key: The fetcher key name.
-        fetcher: The fetcher callable.
-
-    Returns:
-        Tuple of (key, resolved_value).
-
-    Raises:
-        Exception: If the fetcher raises an exception.
-    """
-    fetcher_info = _get_fetcher_info(fetcher)
-    logger.debug(
-        "Resolving fetcher '%s' using %s",
-        key,
-        fetcher_info,
-        extra={"fetcher_key": key, "fetcher": fetcher_info},
-    )
-
-    start_time = time.perf_counter()
-
-    try:
-        result = fetcher()
-        is_async = asyncio.iscoroutine(result)
-
-        if is_async:
-            logger.debug(
-                "Fetcher '%s' returned coroutine, awaiting...",
-                key,
-                extra={"fetcher_key": key, "is_async": True},
-            )
-            result = await result
-
-    except Exception as e:
-        elapsed_ms = (time.perf_counter() - start_time) * 1000
-        logger.error(
-            "Fetcher '%s' (%s) failed after %.2fms: %s: %s",
-            key,
-            fetcher_info,
-            elapsed_ms,
-            type(e).__name__,
-            str(e) or "(no message)",
-            extra={
-                "fetcher_key": key,
-                "fetcher": fetcher_info,
-                "elapsed_ms": elapsed_ms,
-                "error_type": type(e).__name__,
-                "error_message": str(e),
-                "traceback": traceback.format_exc(),
-            },
-        )
-        raise
-
-    elapsed_ms = (time.perf_counter() - start_time) * 1000
-
-    logger.debug(
-        "Fetcher '%s' resolved successfully in %.2fms, result type: %s",
-        key,
-        elapsed_ms,
-        type(result).__name__,
-        extra={
-            "fetcher_key": key,
-            "elapsed_ms": elapsed_ms,
-            "result_type": type(result).__name__,
-        },
-    )
-
-    return key, result
-
-
-async def resolve(
-    fetchers: dict[str, Fetcher[Any]],
-    *,
-    timeout: float | None = DEFAULT_TIMEOUT,
-) -> dict[str, Any]:
-    """Resolve all dynamic fetchers to their actual values in parallel.
-
-    Fetchers are executed concurrently using asyncio.gather() for better
-    performance when multiple async fetchers are involved.
-
-    Args:
-        fetchers: Dict mapping key names to fetcher callables.
-        timeout: Optional timeout in seconds for all fetchers combined.
-            If None (default), no timeout is applied.
-
-    Returns:
-        Dict mapping key names to resolved values.
-
-    Raises:
-        asyncio.TimeoutError: If timeout is exceeded.
-        Exception: If any fetcher raises an exception, it is propagated.
-
-    Example:
-        fetchers = {"enum": fetch_models, "default": get_default}
-        resolved = await resolve(fetchers, timeout=5.0)
-        # resolved = {"enum": ["gpt-4", "gpt-3.5"], "default": "gpt-4"}
-    """
-    if not fetchers:
-        logger.debug("resolve() called with empty fetchers, returning {}")
-        return {}
-
-    fetcher_keys = list(fetchers.keys())
-    fetcher_infos = {k: _get_fetcher_info(f) for k, f in fetchers.items()}
-
-    logger.info(
-        "resolve() starting parallel resolution of %d fetcher(s): %s",
-        len(fetchers),
-        fetcher_keys,
-        extra={
-            "fetcher_count": len(fetchers),
-            "fetcher_keys": fetcher_keys,
-            "fetcher_infos": fetcher_infos,
-            "timeout": timeout,
-        },
-    )
-
-    start_time = time.perf_counter()
-
-    # Create tasks for parallel execution
-    tasks = list(starmap(_resolve_one, fetchers.items()))
-
-    # Execute with optional timeout
-    try:
-        if timeout is not None:
-            results = await asyncio.wait_for(asyncio.gather(*tasks), timeout=timeout)
-        else:
-            results = await asyncio.gather(*tasks)
-    except asyncio.TimeoutError:
-        elapsed_ms = (time.perf_counter() - start_time) * 1000
-        logger.error(
-            "resolve() timed out after %.2fms (timeout=%.2fs)",
-            elapsed_ms,
-            timeout,
-            extra={"elapsed_ms": elapsed_ms, "timeout": timeout},
-        )
-        raise
-
-    elapsed_ms = (time.perf_counter() - start_time) * 1000
-    logger.info(
-        "resolve() completed successfully in %.2fms, resolved %d fetcher(s)",
-        elapsed_ms,
-        len(results),
-        extra={"elapsed_ms": elapsed_ms, "resolved_count": len(results)},
-    )
-
-    return dict(results)
-
-
-async def resolve_safe(
-    fetchers: dict[str, Fetcher[Any]],
-    *,
-    timeout: float | None = DEFAULT_TIMEOUT,
-) -> ResolveResult:
-    """Resolve fetchers with structured error handling.
-
-    Unlike `resolve()`, this function catches individual fetcher errors
-    and returns them in a structured result, allowing partial success.
-
-    Args:
-        fetchers: Dict mapping key names to fetcher callables.
-        timeout: Optional timeout in seconds for all fetchers combined.
-            If None (default), no timeout is applied. Note: timeout applies
-            to the entire operation, not individual fetchers.
-
-    Returns:
-        ResolveResult with values and any errors that occurred.
-
-    Example:
-        result = await resolve_safe(fetchers, timeout=5.0)
-        if result.success:
-            print("All resolved:", result.values)
-        elif result.partial:
-            print("Partial success:", result.values)
-            print("Errors:", result.errors)
-        else:
-            print("All failed:", result.errors)
-    """
-    if not fetchers:
-        logger.debug("resolve_safe() called with empty fetchers, returning empty ResolveResult")
-        return ResolveResult()
-
-    fetcher_keys = list(fetchers.keys())
-    fetcher_infos = {k: _get_fetcher_info(f) for k, f in fetchers.items()}
-
-    logger.info(
-        "resolve_safe() starting parallel resolution of %d fetcher(s): %s",
-        len(fetchers),
-        fetcher_keys,
-        extra={
-            "fetcher_count": len(fetchers),
-            "fetcher_keys": fetcher_keys,
-            "fetcher_infos": fetcher_infos,
-            "timeout": timeout,
-        },
-    )
-
-    start_time = time.perf_counter()
-    result = ResolveResult()
-
-    async def safe_resolve_one(key: str, fetcher: Fetcher[Any]) -> None:
-        """Resolve one fetcher, capturing errors."""
-        try:
-            _, value = await _resolve_one(key, fetcher)
-            result.values[key] = value
-        except Exception as e:
-            # Error already logged in _resolve_one, just capture it
-            result.errors[key] = e
-
-    # Create tasks for parallel execution
-    tasks = list(starmap(safe_resolve_one, fetchers.items()))
-
-    try:
-        if timeout is not None:
-            await asyncio.wait_for(asyncio.gather(*tasks), timeout=timeout)
-        else:
-            await asyncio.gather(*tasks)
-    except asyncio.TimeoutError as e:
-        elapsed_ms = (time.perf_counter() - start_time) * 1000
-        # Add timeout error for any keys that didn't complete
-        resolved_keys = set(result.values.keys()) | set(result.errors.keys())
-        timed_out_keys = [key for key in fetchers if key not in resolved_keys]
-        for key in timed_out_keys:
-            result.errors[key] = e
-
-        logger.error(
-            "resolve_safe() timed out after %.2fms (timeout=%.2fs), %d succeeded, %d failed, %d timed out",
-            elapsed_ms,
-            timeout,
-            len(result.values),
-            len(result.errors) - len(timed_out_keys),
-            len(timed_out_keys),
-            extra={
-                "elapsed_ms": elapsed_ms,
-                "timeout": timeout,
-                "succeeded_keys": list(result.values.keys()),
-                "failed_keys": [k for k in result.errors if k not in timed_out_keys],
-                "timed_out_keys": timed_out_keys,
-            },
-        )
-
-    elapsed_ms = (time.perf_counter() - start_time) * 1000
-
-    # Log summary
-    if result.success:
-        logger.info(
-            "resolve_safe() completed successfully in %.2fms, all %d fetcher(s) resolved",
-            elapsed_ms,
-            len(result.values),
-            extra={
-                "elapsed_ms": elapsed_ms,
-                "success": True,
-                "resolved_count": len(result.values),
-            },
-        )
-    elif result.partial:
-        logger.warning(
-            "resolve_safe() completed with partial success in %.2fms: %d succeeded, %d failed",
-            elapsed_ms,
-            len(result.values),
-            len(result.errors),
-            extra={
-                "elapsed_ms": elapsed_ms,
-                "success": False,
-                "partial": True,
-                "resolved_count": len(result.values),
-                "error_count": len(result.errors),
-                "succeeded_keys": list(result.values.keys()),
-                "failed_keys": list(result.errors.keys()),
-            },
-        )
-    else:
-        logger.error(
-            "resolve_safe() completed with all failures in %.2fms: %d failed",
-            elapsed_ms,
-            len(result.errors),
-            extra={
-                "elapsed_ms": elapsed_ms,
-                "success": False,
-                "partial": False,
-                "error_count": len(result.errors),
-                "failed_keys": list(result.errors.keys()),
-            },
-        )
-
-    return result