digmind-sdk 0.1.0__tar.gz

digmind_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: digmind-sdk
+Version: 0.1.0
+Summary: DigMind Function Tool SDK for Python
+Author: DigMind Team
+License: MIT
+Project-URL: Homepage, https://digmind.ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pydantic>=2.0.0
+
+# DigMind SDK
+
+**DigMind SDK** is the official Python library for developing **Function Tools** and orchestrating agent workflows within the [DigMind Platform](https://digmind.ai).
+
+## Installation
+
+```bash
+pip install digmind-sdk
+```
+
+## Creating a Function Tool
+
+Function Tools allow you to construct composite tools locally using Python and connect them securely to DigMind's execution engine via the `ToolBridge`.
+
+### Usage Example
+
+```python
+from pydantic import BaseModel
+from digmind_sdk import FunctionToolContext, tool_model
+
+# 1. Define the Pydantic schema and bind it to a platform Tool Reference
+@tool_model("rss.list_feeds")
+class ListFeeds(BaseModel):
+    source_ids: list[str]
+
+# 2. Implement the entry point function
+def run(ctx: FunctionToolContext) -> dict:
+    # Safely call the platform tools via context
+    ctx.progress(0.1, "Fetching RSS feeds...")
+    feeds = ctx.call(ListFeeds(source_ids=["tech-blog"]))
+    
+    # Process results locally...
+    ctx.progress(1.0, "Complete!")
+    return {"status": "success", "data": feeds}
+```
+
+## Features
+
+- **Pydantic Validation**: Ensure type-safety immediately before making network requests.
+- **Progress Tracking**: Send real-time partial completion updates back to the DigMind web UI.
+- **Parallel Dispatch**: Run multiple tool calls simultaneously (`ctx.parallel_call`) to drastically reduce overall execution latency.
+
+## Requirements
+
+- Python 3.11+
+- You must connect this SDK running instance to a valid DigMind platform context (normally provided automatically when executed dynamically within DigMind Sandbox environments).

digmind_sdk-0.1.0/README.md

@@ -0,0 +1,46 @@
+# DigMind SDK
+
+**DigMind SDK** is the official Python library for developing **Function Tools** and orchestrating agent workflows within the [DigMind Platform](https://digmind.ai).
+
+## Installation
+
+```bash
+pip install digmind-sdk
+```
+
+## Creating a Function Tool
+
+Function Tools allow you to construct composite tools locally using Python and connect them securely to DigMind's execution engine via the `ToolBridge`.
+
+### Usage Example
+
+```python
+from pydantic import BaseModel
+from digmind_sdk import FunctionToolContext, tool_model
+
+# 1. Define the Pydantic schema and bind it to a platform Tool Reference
+@tool_model("rss.list_feeds")
+class ListFeeds(BaseModel):
+    source_ids: list[str]
+
+# 2. Implement the entry point function
+def run(ctx: FunctionToolContext) -> dict:
+    # Safely call the platform tools via context
+    ctx.progress(0.1, "Fetching RSS feeds...")
+    feeds = ctx.call(ListFeeds(source_ids=["tech-blog"]))
+    
+    # Process results locally...
+    ctx.progress(1.0, "Complete!")
+    return {"status": "success", "data": feeds}
+```
+
+## Features
+
+- **Pydantic Validation**: Ensure type-safety immediately before making network requests.
+- **Progress Tracking**: Send real-time partial completion updates back to the DigMind web UI.
+- **Parallel Dispatch**: Run multiple tool calls simultaneously (`ctx.parallel_call`) to drastically reduce overall execution latency.
+
+## Requirements
+
+- Python 3.11+
+- You must connect this SDK running instance to a valid DigMind platform context (normally provided automatically when executed dynamically within DigMind Sandbox environments).

digmind_sdk-0.1.0/__init__.py

@@ -0,0 +1,24 @@
+"""
+digmind_sdk — Function Tool SDK for DigMind Sandbox
+
+Provides the runtime context and utilities for building Function Tools.
+Function Tools are Python-based composite tools that Agent can create
+to orchestrate platform tool calls with custom logic.
+
+Usage in main.py:
+    from digmind_sdk import FunctionToolContext, tool_model
+
+    @tool_model("rss.list_feeds")
+    class ListFeeds(BaseModel):
+        source_ids: list[str]
+
+    def run(ctx: FunctionToolContext) -> dict:
+        feeds = ctx.call(ListFeeds(source_ids=["s1"]))
+        return {"feeds": feeds}
+"""
+
+from digmind_sdk.context import FunctionToolContext
+from digmind_sdk.decorators import tool_model
+
+__all__ = ["FunctionToolContext", "tool_model"]
+__version__ = "0.1.0"

digmind_sdk-0.1.0/context.py

@@ -0,0 +1,256 @@
+"""
+FunctionToolContext — Runtime context for Function Tools.
+
+Provides safe, validated tool invocation via ToolBridge HTTP API.
+All tool calls are routed through the existing ``/api/v1/toolbridge/call``
+endpoint, ensuring consistent auth, rate-limiting, and observability.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any, Optional
+
+import httpx
+from pydantic import BaseModel
+
+logger = logging.getLogger("digmind_sdk")
+
+
+class FunctionToolContext:
+    """Runtime context injected into every Function Tool's ``run(ctx)`` entry.
+
+    Attributes:
+        inputs: Validated input dict (parsed from tool.yaml's input schema).
+        logger: Structured logger scoped to this function tool execution.
+    """
+
+    def __init__(
+        self,
+        *,
+        inputs: dict[str, Any],
+        allowed_tools: list[str] | None = None,
+        api_url: str | None = None,
+        api_key: str | None = None,
+        tool_name: str = "unknown",
+        progress_callback: Any | None = None,
+        timeout: int = 120,
+        max_tool_calls: int = 50,
+    ):
+        self.inputs = inputs
+        self.logger = logging.getLogger(f"digmind_sdk.fn.{tool_name}")
+
+        self._allowed_tools = set(allowed_tools) if allowed_tools else None
+        self._api_url = api_url or os.environ.get("DIGMIND_API_URL", "http://localhost:8000")
+        self._api_key = api_key or os.environ.get("DIGMIND_API_KEY", "")
+        self._tool_name = tool_name
+        self._progress_cb = progress_callback
+        self._timeout = timeout
+        self._max_tool_calls = max_tool_calls
+
+        # Metrics
+        self._call_count = 0
+        self._call_log: list[dict[str, Any]] = []
+
+    # ──────────────────────────────────────────────────────────────
+    # Primary API: ctx.call(Model)
+    # ──────────────────────────────────────────────────────────────
+
+    def call(self, model: BaseModel) -> Any:
+        """Invoke a tool via its Pydantic Model (recommended).
+
+        The model class must be decorated with ``@tool_model("...")``
+        to bind it to a tool reference.  Pydantic validates the
+        arguments at construction time; this method serialises and
+        dispatches the call.
+
+        Args:
+            model: A ``@tool_model``-decorated Pydantic instance.
+
+        Returns:
+            Tool result (deserialized JSON).
+
+        Raises:
+            ValueError: If the model is not decorated with @tool_model.
+            ToolCallError: If the remote tool call fails.
+        """
+        tool_ref = getattr(model.__class__, "__tool_ref__", None)
+        if not tool_ref:
+            raise ValueError(
+                f"{model.__class__.__name__} is not a @tool_model. "
+                f"Decorate it with @tool_model('tool.ref') first."
+            )
+        return self.tool_call(tool_ref, **model.model_dump(exclude_none=True))
+
+    # ──────────────────────────────────────────────────────────────
+    # Fallback API: ctx.tool_call(name, **kwargs)
+    # ──────────────────────────────────────────────────────────────
+
+    def tool_call(self, tool_name: str, **kwargs: Any) -> Any:
+        """Invoke a tool by name (fallback for ad-hoc calls).
+
+        Subject to the ``required_tools`` whitelist defined in
+        ``tool.yaml``.
+
+        Args:
+            tool_name: Tool reference (e.g. ``"rss.list_feeds"``).
+            **kwargs: Tool arguments.
+
+        Returns:
+            Tool result (deserialized JSON).
+        """
+        # Whitelist check
+        if self._allowed_tools and tool_name not in self._allowed_tools:
+            raise PermissionError(
+                f"Tool '{tool_name}' is not in required_tools whitelist. "
+                f"Allowed tools: {sorted(self._allowed_tools)}"
+            )
+
+        # Rate limit
+        if self._call_count >= self._max_tool_calls:
+            raise RuntimeError(
+                f"Max tool calls ({self._max_tool_calls}) exceeded. "
+                f"Increase runtime.max_tool_calls in tool.yaml if needed."
+            )
+
+        self._call_count += 1
+        start = time.monotonic()
+
+        try:
+            result = self._http_call(tool_name, kwargs)
+            elapsed = time.monotonic() - start
+            self._call_log.append({
+                "tool": tool_name,
+                "elapsed_ms": round(elapsed * 1000),
+                "success": True,
+            })
+            return result
+        except Exception as e:
+            elapsed = time.monotonic() - start
+            self._call_log.append({
+                "tool": tool_name,
+                "elapsed_ms": round(elapsed * 1000),
+                "success": False,
+                "error": str(e),
+            })
+            raise
+
+    # ──────────────────────────────────────────────────────────────
+    # Parallel API: ctx.parallel_call([Model, Model, ...])
+    # ──────────────────────────────────────────────────────────────
+
+    def parallel_call(
+        self,
+        models: list[BaseModel],
+        *,
+        max_concurrency: int = 5,
+    ) -> list[Any]:
+        """Execute multiple tool calls in parallel.
+
+        Each model in the list must be a ``@tool_model``-decorated
+        Pydantic instance.  Results are returned in the same order
+        as the input list.
+
+        Args:
+            models: List of tool model instances.
+            max_concurrency: Max concurrent HTTP requests.
+
+        Returns:
+            Ordered list of results (or dicts with ``error`` key on failure).
+        """
+        results: list[Any] = [None] * len(models)
+
+        with ThreadPoolExecutor(max_workers=max_concurrency) as pool:
+            future_to_idx = {
+                pool.submit(self.call, m): i for i, m in enumerate(models)
+            }
+            for future in as_completed(future_to_idx):
+                idx = future_to_idx[future]
+                try:
+                    results[idx] = future.result()
+                except Exception as e:
+                    self.logger.warning(f"Parallel call [{idx}] failed: {e}")
+                    results[idx] = {"error": str(e)}
+
+        return results
+
+    # ──────────────────────────────────────────────────────────────
+    # Progress reporting
+    # ──────────────────────────────────────────────────────────────
+
+    def progress(self, fraction: float, message: str = "") -> None:
+        """Report execution progress (0.0 ~ 1.0).
+
+        Progress is surfaced in DAG visualisation and CLI output.
+
+        Args:
+            fraction: Progress fraction (0.0 to 1.0).
+            message: Optional human-readable status message.
+        """
+        clamped = max(0.0, min(1.0, fraction))
+        self.logger.info(f"[{clamped:.0%}] {message}")
+        if self._progress_cb:
+            try:
+                self._progress_cb(clamped, message)
+            except Exception:
+                pass  # Progress reporting is best-effort
+
+    # ──────────────────────────────────────────────────────────────
+    # Metrics
+    # ──────────────────────────────────────────────────────────────
+
+    def get_metrics(self) -> dict[str, Any]:
+        """Return execution metrics for benchmarking / diagnostics."""
+        total_ms = sum(c["elapsed_ms"] for c in self._call_log)
+        by_tool: dict[str, int] = {}
+        for c in self._call_log:
+            by_tool[c["tool"]] = by_tool.get(c["tool"], 0) + 1
+        errors = sum(1 for c in self._call_log if not c["success"])
+        return {
+            "total_calls": self._call_count,
+            "total_ms": total_ms,
+            "errors": errors,
+            "by_tool": by_tool,
+            "call_log": self._call_log,
+        }
+
+    # ──────────────────────────────────────────────────────────────
+    # Internal: HTTP transport
+    # ──────────────────────────────────────────────────────────────
+
+    def _http_call(self, tool_name: str, arguments: dict[str, Any]) -> Any:
+        """Execute a single tool call via ToolBridge HTTP API."""
+        url = f"{self._api_url}/api/v1/toolbridge/call"
+        headers = {"Authorization": f"Bearer {self._api_key}"}
+
+        payload = {
+            "tool_name": tool_name,
+            "arguments": arguments,
+        }
+
+        self.logger.debug(f"Calling {tool_name} → {url}")
+
+        with httpx.Client(timeout=self._timeout) as client:
+            resp = client.post(url, json=payload, headers=headers)
+
+        if resp.status_code != 200:
+            error_detail = ""
+            try:
+                error_detail = resp.json().get("detail", resp.text)
+            except Exception:
+                error_detail = resp.text
+            raise ToolCallError(
+                f"Tool '{tool_name}' failed (HTTP {resp.status_code}): {error_detail}"
+            )
+
+        data = resp.json()
+        return data.get("result", data)
+
+
+class ToolCallError(Exception):
+    """Raised when a remote tool call fails."""
+    pass

digmind_sdk-0.1.0/decorators.py

@@ -0,0 +1,32 @@
+"""
+tool_model decorator — Binds a Pydantic BaseModel to a tool reference.
+
+Usage:
+    from pydantic import BaseModel, Field
+    from digmind_sdk import tool_model
+
+    @tool_model("rss.list_feeds")
+    class ListFeeds(BaseModel):
+        source_ids: list[str] = Field(description="Source IDs to query")
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def tool_model(tool_ref: str):
+    """Bind a Pydantic Model class to a ToolBridge tool reference.
+
+    The decorated class gains a ``__tool_ref__`` attribute that
+    ``FunctionToolContext.call()`` uses to route the invocation.
+
+    Args:
+        tool_ref: Fully-qualified tool reference, e.g. ``"rss.list_feeds"``.
+    """
+
+    def decorator(cls: Any) -> Any:
+        cls.__tool_ref__ = tool_ref
+        return cls
+
+    return decorator

digmind_sdk-0.1.0/digmind_sdk.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: digmind-sdk
+Version: 0.1.0
+Summary: DigMind Function Tool SDK for Python
+Author: DigMind Team
+License: MIT
+Project-URL: Homepage, https://digmind.ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pydantic>=2.0.0
+
+# DigMind SDK
+
+**DigMind SDK** is the official Python library for developing **Function Tools** and orchestrating agent workflows within the [DigMind Platform](https://digmind.ai).
+
+## Installation
+
+```bash
+pip install digmind-sdk
+```
+
+## Creating a Function Tool
+
+Function Tools allow you to construct composite tools locally using Python and connect them securely to DigMind's execution engine via the `ToolBridge`.
+
+### Usage Example
+
+```python
+from pydantic import BaseModel
+from digmind_sdk import FunctionToolContext, tool_model
+
+# 1. Define the Pydantic schema and bind it to a platform Tool Reference
+@tool_model("rss.list_feeds")
+class ListFeeds(BaseModel):
+    source_ids: list[str]
+
+# 2. Implement the entry point function
+def run(ctx: FunctionToolContext) -> dict:
+    # Safely call the platform tools via context
+    ctx.progress(0.1, "Fetching RSS feeds...")
+    feeds = ctx.call(ListFeeds(source_ids=["tech-blog"]))
+    
+    # Process results locally...
+    ctx.progress(1.0, "Complete!")
+    return {"status": "success", "data": feeds}
+```
+
+## Features
+
+- **Pydantic Validation**: Ensure type-safety immediately before making network requests.
+- **Progress Tracking**: Send real-time partial completion updates back to the DigMind web UI.
+- **Parallel Dispatch**: Run multiple tool calls simultaneously (`ctx.parallel_call`) to drastically reduce overall execution latency.
+
+## Requirements
+
+- Python 3.11+
+- You must connect this SDK running instance to a valid DigMind platform context (normally provided automatically when executed dynamically within DigMind Sandbox environments).

digmind_sdk-0.1.0/digmind_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+__init__.py
+context.py
+decorators.py
+pyproject.toml
+testing.py
+./__init__.py
+./context.py
+./decorators.py
+./testing.py
+digmind_sdk.egg-info/PKG-INFO
+digmind_sdk.egg-info/SOURCES.txt
+digmind_sdk.egg-info/dependency_links.txt
+digmind_sdk.egg-info/requires.txt
+digmind_sdk.egg-info/top_level.txt

digmind_sdk-0.1.0/digmind_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

digmind_sdk-0.1.0/digmind_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.28.0
+pydantic>=2.0.0

digmind_sdk-0.1.0/digmind_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+digmind_sdk

digmind_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "digmind-sdk"
+version = "0.1.0"
+description = "DigMind Function Tool SDK for Python"
+readme = "README.md"
+authors = [
+    { name = "DigMind Team" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "httpx>=0.28.0",
+    "pydantic>=2.0.0"
+]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://digmind.ai"
+
+[tool.setuptools]
+package-dir = {"digmind_sdk" = "."}
+packages = ["digmind_sdk"]

digmind_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

digmind_sdk-0.1.0/testing.py

@@ -0,0 +1,186 @@
+"""
+MockContext — Test helper for Function Tools.
+
+Provides a drop-in replacement for FunctionToolContext that records
+tool calls and returns mock data instead of hitting the real API.
+
+Usage in tests/test_main.py:
+    from digmind_sdk.testing import MockContext
+    from _tools import ListFeeds, Fetch
+
+    def test_basic():
+        ctx = MockContext(inputs={"source_ids": ["s1"]})
+        ctx.mock(ListFeeds, return_value=[{"url": "https://a.com"}])
+        ctx.mock(Fetch, side_effect=[{"content": "hello"}])
+
+        from main import run
+        result = run(ctx)
+
+        assert ctx.call_count(ListFeeds) == 1
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+from unittest.mock import MagicMock
+
+from pydantic import BaseModel
+
+
+class MockContext:
+    """Test double for FunctionToolContext.
+
+    Records all tool calls and returns pre-configured mock data.
+    """
+
+    def __init__(
+        self,
+        inputs: dict[str, Any] | None = None,
+        allowed_tools: list[str] | None = None,
+    ):
+        self.inputs = inputs or {}
+        self.logger = logging.getLogger("digmind_sdk.test")
+
+        self._allowed_tools = set(allowed_tools) if allowed_tools else None
+        self._mocks: dict[str, _MockEntry] = {}  # tool_ref -> MockEntry
+        self._calls: dict[str, list[dict]] = {}  # tool_ref -> list of call records
+        self._progress_log: list[tuple[float, str]] = []
+
+    # ──────────────────────────────────────────────────────────────
+    #  Mock registration
+    # ──────────────────────────────────────────────────────────────
+
+    def mock(
+        self,
+        model_cls: type[BaseModel] | str,
+        *,
+        return_value: Any = None,
+        side_effect: Any = None,
+    ) -> None:
+        """Register a mock for a @tool_model class or tool name.
+
+        Args:
+            model_cls: A @tool_model-decorated class, or a tool_ref string.
+            return_value: Fixed return value for every call.
+            side_effect: List of values (popped per call) or callable.
+        """
+        tool_ref = self._resolve_ref(model_cls)
+        self._mocks[tool_ref] = _MockEntry(
+            return_value=return_value,
+            side_effect=side_effect,
+        )
+
+    # ──────────────────────────────────────────────────────────────
+    #  Same API as FunctionToolContext
+    # ──────────────────────────────────────────────────────────────
+
+    def call(self, model: BaseModel) -> Any:
+        """Mock version of ctx.call(Model)."""
+        tool_ref = getattr(model.__class__, "__tool_ref__", None)
+        if not tool_ref:
+            raise ValueError(
+                f"{model.__class__.__name__} is not a @tool_model"
+            )
+        args = model.model_dump(exclude_none=True)
+        return self._dispatch(tool_ref, args)
+
+    def tool_call(self, tool_name: str, **kwargs: Any) -> Any:
+        """Mock version of ctx.tool_call(name, **kwargs)."""
+        return self._dispatch(tool_name, kwargs)
+
+    def parallel_call(
+        self,
+        models: list[BaseModel],
+        *,
+        max_concurrency: int = 5,
+    ) -> list[Any]:
+        """Mock version of ctx.parallel_call([Model, ...])."""
+        return [self.call(m) for m in models]
+
+    def progress(self, fraction: float, message: str = "") -> None:
+        """Record progress call."""
+        self._progress_log.append((fraction, message))
+
+    # ──────────────────────────────────────────────────────────────
+    #  Assertions
+    # ──────────────────────────────────────────────────────────────
+
+    def call_count(self, model_cls: type[BaseModel] | str) -> int:
+        """Return number of times a tool was called."""
+        tool_ref = self._resolve_ref(model_cls)
+        return len(self._calls.get(tool_ref, []))
+
+    def call_args(self, model_cls: type[BaseModel] | str) -> list[dict]:
+        """Return list of argument dicts for each call to a tool."""
+        tool_ref = self._resolve_ref(model_cls)
+        return self._calls.get(tool_ref, [])
+
+    def get_metrics(self) -> dict[str, Any]:
+        """Return mock metrics (compatible with FunctionToolContext)."""
+        total = sum(len(v) for v in self._calls.values())
+        by_tool = {k: len(v) for k, v in self._calls.items()}
+        return {
+            "total_calls": total,
+            "total_ms": 0,
+            "errors": 0,
+            "by_tool": by_tool,
+            "call_log": [],
+        }
+
+    # ──────────────────────────────────────────────────────────────
+    #  Internal
+    # ──────────────────────────────────────────────────────────────
+
+    def _resolve_ref(self, model_cls_or_str: type[BaseModel] | str) -> str:
+        if isinstance(model_cls_or_str, str):
+            return model_cls_or_str
+        ref = getattr(model_cls_or_str, "__tool_ref__", None)
+        if not ref:
+            raise ValueError(
+                f"{model_cls_or_str.__name__} is not a @tool_model"
+            )
+        return ref
+
+    def _dispatch(self, tool_ref: str, args: dict) -> Any:
+        # Record the call
+        self._calls.setdefault(tool_ref, []).append(args)
+
+        # Find mock
+        entry = self._mocks.get(tool_ref)
+        if entry is None:
+            raise ValueError(
+                f"No mock registered for '{tool_ref}'. "
+                f"Call ctx.mock({tool_ref}, return_value=...) first."
+            )
+
+        return entry.next_value()
+
+
+class _MockEntry:
+    """Internal mock state for a single tool."""
+
+    def __init__(
+        self,
+        return_value: Any = None,
+        side_effect: Any = None,
+    ):
+        self._return_value = return_value
+        self._side_effect = list(side_effect) if isinstance(side_effect, (list, tuple)) else side_effect
+        self._call_index = 0
+
+    def next_value(self) -> Any:
+        if self._side_effect is not None:
+            if isinstance(self._side_effect, list):
+                if self._call_index >= len(self._side_effect):
+                    raise IndexError(
+                        f"side_effect exhausted after {self._call_index} calls"
+                    )
+                val = self._side_effect[self._call_index]
+                self._call_index += 1
+                return val
+            elif callable(self._side_effect):
+                return self._side_effect()
+            else:
+                return self._side_effect
+        return self._return_value