digitalkin 0.2.23__py3-none-any.whl → 0.3.1.dev2__py3-none-any.whl

digitalkin/utils/dynamic_schema.py

@@ -0,0 +1,483 @@
+"""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

digitalkin/utils/package_discover.py

@@ -1,4 +1,4 @@
-"""."""
+"""Secure module discovery and import utility for trigger handlers."""
 
 import importlib
 import importlib.util
@@ -276,7 +276,6 @@ class ModuleDiscoverer:
         Args:
             packages: List of package names to scan.
             file_pattern: Glob pattern for matching modules.
-            safe_mode: If True, blocks modules with forbidden names.
             max_file_size: Limit for module file sizes in bytes.
         """
         self.packages = packages

{digitalkin-0.2.23.dist-info → digitalkin-0.3.1.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.23
+Version: 0.3.1.dev2
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,36 +452,17 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto>=0.1.16
-Requires-Dist: grpcio-health-checking>=1.71.0
-Requires-Dist: grpcio-reflection>=1.71.0
-Requires-Dist: grpcio-status>=1.71.0
-Requires-Dist: pydantic>=2.11.5
-Provides-Extra: dev
-Requires-Dist: typos>=1.34.0; extra == "dev"
-Requires-Dist: ruff>=0.12.5; extra == "dev"
-Requires-Dist: mypy>=1.17.0; extra == "dev"
-Requires-Dist: pyright>=1.1.403; extra == "dev"
-Requires-Dist: pre-commit>=4.3.0; extra == "dev"
-Requires-Dist: bump2version>=1.0.1; extra == "dev"
-Requires-Dist: build>=1.3.0; extra == "dev"
-Requires-Dist: twine>=6.1.0; extra == "dev"
-Requires-Dist: cryptography>=45.0.5; extra == "dev"
-Provides-Extra: examples
-Requires-Dist: openai>=1.75.0; extra == "examples"
-Provides-Extra: tests
-Requires-Dist: freezegun>=1.5.3; extra == "tests"
-Requires-Dist: hdrhistogram>=0.10.3; extra == "tests"
-Requires-Dist: grpcio-testing>=1.71.0; extra == "tests"
-Requires-Dist: psutil>=7.0.0; extra == "tests"
-Requires-Dist: pytest>=8.4.0; extra == "tests"
-Requires-Dist: pytest-asyncio>=1.1.0; extra == "tests"
-Requires-Dist: pytest-cov>=6.1.0; extra == "tests"
+Requires-Dist: digitalkin-proto==0.2.0.dev5
+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: surrealdb>=1.0.6
 Provides-Extra: taskiq
-Requires-Dist: rstream>=0.30.0; extra == "taskiq"
-Requires-Dist: taskiq-aio-pika>=0.4.3; extra == "taskiq"
-Requires-Dist: taskiq-redis>=1.1.0; extra == "taskiq"
-Requires-Dist: taskiq[reload]>=0.11.18; extra == "taskiq"
+Requires-Dist: rstream>=0.40.0; extra == "taskiq"
+Requires-Dist: taskiq-aio-pika>=0.5.0; extra == "taskiq"
+Requires-Dist: taskiq-redis>=1.1.2; extra == "taskiq"
+Requires-Dist: taskiq[reload]>=0.12.0; extra == "taskiq"
 Dynamic: license-file
 
 # DigitalKin Python SDK

digitalkin-0.3.1.dev2.dist-info/RECORD

@@ -0,0 +1,119 @@
+base_server/__init__.py,sha256=gs8t9Dg0dNVHRdYYbEQY8bn8tzEUv2zE6eBhKNPG3kU,88
+base_server/server_async_insecure.py,sha256=Rvj5Xj8tDMglAj6aOGlQdMeD-FL97_OBEhHYHxxQrVo,3887
+base_server/server_async_secure.py,sha256=SV_CqEmD6YNHHP2Y369T2PLPJ-9JG3bvXytchX_Ensk,4684
+base_server/server_sync_insecure.py,sha256=VgSH8YghagK3fiwHhc7d6__zjN6lj_FgBUponFbOoxM,3127
+base_server/server_sync_secure.py,sha256=MMkq67vAZNiDLJSySjoXtHIEIK1pAlRz57n75Egnndk,3939
+base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,143
+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=rxdfBPxh61wYhnALMkZQcAZXlglrXOhzea_oGgV1Was,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
+digitalkin/core/common/__init__.py,sha256=Gh2eJAJRnrUE93jSEfG7r0nb01Xh1kSkNL6nEpfzK_s,218
+digitalkin/core/common/factories.py,sha256=mV6SmXXrZxzIQ7DLdDtPdjapSDZt5Ua-nBIDsozs_Vk,5047
+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/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/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/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/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
+digitalkin/grpc_servers/utils/exceptions.py,sha256=LtaDtlqXCeT6iqApogs4pbtezotOVeg4fhnFzGBvFsY,692
+digitalkin/grpc_servers/utils/grpc_client_wrapper.py,sha256=a4xeulweovugI-IUVBrSZ-CswZHrBdeh9r-yzP8dl1w,2753
+digitalkin/grpc_servers/utils/grpc_error_handler.py,sha256=0wPEU4713_ZlgIilaeXJV2bi90tHwYO1myDrSLeenKk,1848
+digitalkin/mixins/__init__.py,sha256=d6ljaoyJZJT9XxOrXZG5FVNvbLURb3_CZrkp4GPZWYM,590
+digitalkin/mixins/base_mixin.py,sha256=uLkg6MbDtVc9DysjdfNIGKahxQLnnjuL3DYpuyNLbk8,486
+digitalkin/mixins/callback_mixin.py,sha256=90nHm9-pbKT14GAy3CB3fsBtpYu5IH0woOQdNLM2e_Y,836
+digitalkin/mixins/chat_history_mixin.py,sha256=SqCmnh6Ybed3TQoQbvUjbzwKs_evvfW_lr4j_Uncg0A,4231
+digitalkin/mixins/cost_mixin.py,sha256=nFqhLsRHdXAt3GOH6qI8sqX9KW3leTPW3gaclensBVw,2274
+digitalkin/mixins/file_history_mixin.py,sha256=5MgxglccVe11M7YnoeuXbJYXNEwVZdiGd5Fl8sytcTM,3504
+digitalkin/mixins/filesystem_mixin.py,sha256=Q1sEY_dKZVi2Sa21fypwpsz9h7uQ7ggVqzpuVgheF_o,1510
+digitalkin/mixins/logger_mixin.py,sha256=l-SK3qACIzRfyHgj7KhzvW3ZhmVa-W1JB9tmppgpqg4,1842
+digitalkin/mixins/storage_mixin.py,sha256=ptZ4a2bydIa48q0V9e395vWHTu7yw4A6rI4jwKY6gwI,2392
+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/grpc_servers/__init__.py,sha256=0tA71nPSXgRrh9DoLvx-TSwZXdYIRUEItoadpTL1cTo,42
+digitalkin/models/grpc_servers/models.py,sha256=unV1Wo0u3Efm7ddgYyYZZYUC_W6F0S5BQYH3xsOmXjw,8965
+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=0sKIvLYt0KHR4oF0MUQ4RQZDBrPjmOSaIHNMcl7vUmI,4649
+digitalkin/models/module/module_types.py,sha256=Z46NPBCf8yDot4ZT_iJfBMo8J-IhpYiJJlKJsXxe6vA,14445
+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/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=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
+digitalkin/services/cost/__init__.py,sha256=sD_a5LrnLluASOC5m5vgIqjaco-MzZJd6XhillIBHr0,400
+digitalkin/services/cost/cost_strategy.py,sha256=MpPX33P_S5b2by6F4zT-rcyeRuh2V4NYPZe05VpDOGQ,2649
+digitalkin/services/cost/default_cost.py,sha256=XE7kNFde8NmbulU9m1lc3mi-vHFkbaJf0XHUc0D4UHE,3945
+digitalkin/services/cost/grpc_cost.py,sha256=B4HlrpsOpeq7jLSDyympOXvl6uXAzq_Ifk4t1EGjCpI,5289
+digitalkin/services/filesystem/__init__.py,sha256=BhwMl_BUvM0d65fmglkp0SVwn3RfYiUOKJgIMnOCaGM,381
+digitalkin/services/filesystem/default_filesystem.py,sha256=WQbU-Bsi9r-28VqhKbrplce3otzjSKS-5iqKEpGWdQU,15117
+digitalkin/services/filesystem/filesystem_strategy.py,sha256=zibVLvX_IBQ-kgh-KYzHdszDeiHFPEAZszu_k99x1GQ,9487
+digitalkin/services/filesystem/grpc_filesystem.py,sha256=TSj70so3YxeuTXSvSFJrA6LHwM07HNZ9kDdqCBAbC70,12154
+digitalkin/services/identity/__init__.py,sha256=InkeyLgFYYwItx8mePA8HpfacOMWZwwuc0G4pWtKq9s,270
+digitalkin/services/identity/default_identity.py,sha256=Y2auZHrGSZTIN5D8HyjLvLcNbYFM1CNUE23x7p5VIGw,386
+digitalkin/services/identity/identity_strategy.py,sha256=skappBbds1_qa0Gr24FGrNX1N0_OYhYT1Lh7dUaAirE,429
+digitalkin/services/registry/__init__.py,sha256=Zl4QAkCe9tOmmKGBWVuLQVFepdZiL0ec3VDj27IeyYM,270
+digitalkin/services/registry/default_registry.py,sha256=VnWkF6nHpFxUKuUbZLPqzXqdA6oXmyV_ySpeuOCf_ko,277
+digitalkin/services/registry/registry_strategy.py,sha256=uBXgZIv25jeXbeVO8vWvlNPxxNYu7_KiCw2PoE6AWr8,423
+digitalkin/services/setup/__init__.py,sha256=t6xcvEWqTbcRZstBFK9cESEqaZKvpW14VtYygxIqfYQ,65
+digitalkin/services/setup/default_setup.py,sha256=fnLSCMFQt5bYxbiOLM6wgP0ElIf1j9hf8whhogvl6Sg,8239
+digitalkin/services/setup/grpc_setup.py,sha256=52nRFWLxnDSAWRacve04nRguiIQZAWMM-gcoiwxJ8Mo,13942
+digitalkin/services/setup/setup_strategy.py,sha256=ZnJ_HwWCkHCPrqKekSD5L9y3p8wMwfjQ8sj2hLZq6go,4004
+digitalkin/services/snapshot/__init__.py,sha256=Uzlnzo0CYlSpVsdiI37hW7xQk8hu3YA1fOI6O6MSzB0,270
+digitalkin/services/snapshot/default_snapshot.py,sha256=Mb8QwWRsHh9I_tN0ln_ZiFa1QCZxOVWmuVLemQOTWpc,1058
+digitalkin/services/snapshot/snapshot_strategy.py,sha256=B1TU3V_k9A-OdqBkdyc41-ihnrW5Btcwd1KyQdHT46A,898
+digitalkin/services/storage/__init__.py,sha256=T-ocYLLphudkQgzvG47jBOm5GQsRFRIGA88y7Ur4akg,341
+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=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/user_profile_strategy.py,sha256=luzpPvm2f4xXajWAbRGSk5YCIPBUrn5EOrXSz8NL1So,1148
+digitalkin/utils/__init__.py,sha256=gDoEk5CP8tiBmIq-38aPhIMlnDUiqRrduuVXhpSPQnc,541
+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.dev2.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.dev2.dist-info/METADATA,sha256=KoDE-dtTv3fG6XGdSBsCcwlyQhcJMb3hnESKNKP3LaY,29719
+digitalkin-0.3.1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+digitalkin-0.3.1.dev2.dist-info/top_level.txt,sha256=gcjqlyrZuLjIyxrOIavCQM_olpr6ND5kPKkZd2j0xGo,40
+digitalkin-0.3.1.dev2.dist-info/RECORD,,