erdo 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

erdo/invoke/client.py

@@ -53,7 +53,8 @@ class InvokeClient:
         messages: Optional[List[Dict[str, str]]] = None,
         parameters: Optional[Dict[str, Any]] = None,
         dataset_slugs: Optional[list] = None,
-        mode: Optional[str] = None,
+        mode: Optional[Union[str, Dict[str, Any]]] = None,
+        manual_mocks: Optional[Dict[str, Dict[str, Any]]] = None,
         stream: bool = False,
     ) -> Union[SSEClient, Dict[str, Any]]:
         """Invoke a bot via the backend orchestrator.
@@ -63,7 +64,8 @@ class InvokeClient:
             messages: Messages in format [{"role": "user", "content": "..."}]
             parameters: Parameters to pass to the bot
             dataset_slugs: Optional dataset slugs to include
-            mode: Invocation mode: "live" (default), "replay" (cached), or "mock" (synthetic)
+            mode: Invocation mode - string: "live|replay|manual" OR dict: {"mode": "replay", "refresh": true}
+            manual_mocks: Manual mock responses for mode="manual" (step_path -> mock response)
             stream: Whether to return SSE client for streaming (default: False)
 
         Returns:
@@ -94,10 +96,14 @@ class InvokeClient:
         if dataset_slugs:
             invoke_params["dataset_slugs"] = dataset_slugs
 
-        # Add mode if provided (live/replay/mock)
+        # Add mode if provided (live/replay/manual)
         if mode:
             invoke_params["mode"] = mode
 
+        # Add manual mocks if provided (for manual mode)
+        if manual_mocks:
+            invoke_params["manual_mocks"] = manual_mocks
+
         # Make the request - always stream to handle SSE
         response = requests.post(url, json=invoke_params, headers=headers, stream=True)
 

erdo/invoke/invoke.py

@@ -1,8 +1,9 @@
 """Main invoke functionality for running agents via the orchestrator."""
 
 import json
+import os
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from .client import InvokeClient
 
@@ -106,7 +107,8 @@ class Invoke:
         messages: Optional[List[Dict[str, str]]] = None,
         parameters: Optional[Dict[str, Any]] = None,
         dataset_slugs: Optional[list] = None,
-        mode: Optional[str] = None,
+        mode: Optional[Union[str, Dict[str, Any]]] = None,
+        manual_mocks: Optional[Dict[str, Dict[str, Any]]] = None,
         stream: bool = False,
         output_format: str = "events",
         verbose: bool = False,
@@ -118,7 +120,8 @@ class Invoke:
             messages: Messages in format [{"role": "user", "content": "..."}]
             parameters: Parameters to pass to the bot
             dataset_slugs: Dataset slugs to include (e.g. ["my-dataset"] or ["org.my-dataset"])
-            mode: Invocation mode: "live" (default), "replay" (cached), or "mock" (synthetic)
+            mode: Invocation mode - string: "live|replay|manual" OR dict: {"mode": "replay", "refresh": true}
+            manual_mocks: Manual mock responses for mode="manual" (step_path -> mock response)
             stream: Whether to stream events
             output_format: Output format: "events" (raw), "text" (formatted), "json" (summary)
             verbose: Show detailed steps (only for text format)
@@ -133,6 +136,7 @@ class Invoke:
                 parameters=parameters,
                 dataset_slugs=dataset_slugs,
                 mode=mode,
+                manual_mocks=manual_mocks,
                 stream=stream,
             )
 
@@ -145,16 +149,28 @@ class Invoke:
                 if not isinstance(response, dict):
                     # For formatted output, print as we stream
                     if output_format in ["text", "json"] and not self.print_events:
-                        from ..formatting import parse_invocation_events
-
                         bot_name_printed = False
                         completed_steps = set()
+                        step_names = {}  # Map to track step keys
+                        printed_content_ids = (
+                            set()
+                        )  # Track which message content we've printed
 
                         for event in response.events():
+                            if not event:
+                                continue
                             events.append(event)
 
-                            # Extract invocation ID and bot name from payload
+                            # Extract payload and metadata
                             payload = event.get("payload", {})
+                            metadata = event.get("metadata", {})
+                            status = (
+                                payload.get("status")
+                                if isinstance(payload, dict)
+                                else None
+                            )
+
+                            # Extract invocation ID and bot name from payload
                             if isinstance(payload, dict):
                                 if "invocation_id" in payload and not invocation_id:
                                     invocation_id = payload["invocation_id"]
@@ -165,39 +181,75 @@ class Invoke:
                                         print(
                                             f"Invocation ID: {invocation_id or 'N/A'}"
                                         )
-                                        if verbose:
-                                            print("\nSteps:")
+                                        print()  # Empty line before steps start
                                     bot_name_printed = True
 
-                            # Print steps as they complete (verbose mode)
+                            # Track and display step info (ONLY in verbose mode)
+                            # step_info events have both key and action_type in payload
+                            if (
+                                verbose
+                                and output_format == "text"
+                                and isinstance(payload, dict)
+                            ):
+                                if "key" in payload and "action_type" in payload:
+                                    # This is a step_info event - show "▸" here if visible
+                                    step_key = payload["key"]
+                                    action_type = payload["action_type"]
+                                    step_names[step_key] = action_type
+
+                                    # Show step start on step_info event if visible
+                                    if metadata.get("user_visibility") == "visible":
+                                        print(f"▸ {step_key} ({action_type})")
+
+                            # Handle step finished events (check status in payload)
+                            # We look for the most recent step from step_names (ONLY in verbose mode)
                             if (
                                 verbose
                                 and output_format == "text"
-                                and payload.get("status") == "step finished"
+                                and status == "step finished"
                             ):
-                                # Parse to get step info
-                                summary = parse_invocation_events(
-                                    events, bot_key, invocation_id
-                                )
-                                for step in summary.steps:
-                                    if step.key and step.key not in completed_steps:
-                                        print(f"  ✓ {step.key} ({step.action})")
-                                        completed_steps.add(step.key)
+                                if metadata.get("user_visibility") == "visible":
+                                    # Find the last step that we haven't marked complete yet
+                                    for step_key in reversed(list(step_names.keys())):
+                                        if step_key not in completed_steps:
+                                            print(f"✓ {step_key}")
+                                            completed_steps.add(step_key)
+                                            break
 
                             # Print message content as it streams
+                            # ONLY print if:
+                            # 1. user_visibility is "visible"
+                            # 2. Has message_content_id (actual message content, not fragments)
+                            # 3. content_type is "text" (not "json" or other types)
+                            # 4. Haven't already printed chunks for this content_id
                             if (
                                 output_format == "text"
                                 and isinstance(payload, str)
                                 and len(payload) > 0
+                                and isinstance(metadata, dict)
+                                and metadata.get("user_visibility") == "visible"
+                                and metadata.get(
+                                    "message_content_id"
+                                )  # Must be message content
+                                and metadata.get("content_type")
+                                == "text"  # Only plain text, not JSON
                             ):
-                                # Check if this is actual content (not JSON)
-                                if not payload.startswith(
-                                    "{"
-                                ) and not payload.startswith("["):
+                                content_id = metadata.get("message_content_id")
+                                # If this is a full message (long) and we've already printed chunks, skip
+                                if (
+                                    len(payload) > 20
+                                    and content_id in printed_content_ids
+                                ):
+                                    # This is a duplicate full message after streaming chunks
+                                    pass
+                                else:
                                     print(payload, end="", flush=True)
+                                    printed_content_ids.add(content_id)
                     else:
                         # For raw events or print_events mode, just collect
                         for event in response.events():
+                            if not event:
+                                continue
                             events.append(event)
 
                             if self.print_events:
@@ -341,7 +393,8 @@ def invoke(
     messages: Optional[List[Dict[str, str]]] = None,
     parameters: Optional[Dict[str, Any]] = None,
     datasets: Optional[list] = None,
-    mode: Optional[str] = None,
+    mode: Optional[Union[str, Dict[str, Any]]] = None,
+    manual_mocks: Optional[Dict[str, Dict[str, Any]]] = None,
     stream: bool = False,
     output_format: str = "events",
     verbose: bool = False,
@@ -355,7 +408,8 @@ def invoke(
         messages: Messages in format [{"role": "user", "content": "..."}]
         parameters: Parameters to pass to the bot
         datasets: Dataset slugs to include (e.g. ["my-dataset"] or ["org.my-dataset"])
-        mode: Invocation mode: "live" (default), "replay" (cached), or "mock" (synthetic)
+        mode: Invocation mode - string: "live|replay|manual" OR dict: {"mode": "replay", "refresh": true}
+        manual_mocks: Manual mock responses for mode="manual" (step_path -> mock response)
         stream: Whether to stream events
         output_format: Output format: "events" (raw), "text" (formatted), "json" (summary)
         verbose: Show detailed steps (only for text format)
@@ -368,31 +422,28 @@ def invoke(
     Example:
         >>> from erdo import invoke
         >>>
-        >>> # Default: raw events (backwards compatible)
-        >>> response = invoke("my_agent", messages=[...])
-        >>> print(response.result)  # {"events": [...]}
+        >>> # Simple replay mode
+        >>> response = invoke("my_agent", messages=[...], mode="replay")
         >>>
-        >>> # Formatted text output
-        >>> response = invoke("my_agent", messages=[...], output_format="text")
-        >>> print(response.result)
-        Bot: my agent
-        Invocation ID: abc-123
-        Result:
-        The answer is 4
+        >>> # Replay mode with refresh (bypass cache)
+        >>> response = invoke("my_agent", messages=[...], mode={"mode": "replay", "refresh": True})
         >>>
-        >>> # Formatted text with verbose steps
-        >>> response = invoke("my_agent", messages=[...], output_format="text", verbose=True)
-        >>>
-        >>> # JSON summary
-        >>> response = invoke("my_agent", messages=[...], output_format="json")
-        >>> print(response.result)  # {"bot_name": ..., "steps": [...], "result": ...}
+        >>> # Manual mode with mocks
+        >>> response = invoke("my_agent", messages=[...], mode="manual",
+        ...     manual_mocks={"llm.message": {"status": "success", "output": {"content": "Mocked"}}})
     """
+    # Check ERDO_REFRESH environment variable
+    # If set and mode is "replay" (string), convert to dict with refresh=True
+    if os.environ.get("ERDO_REFRESH") == "1" and mode == "replay":
+        mode = {"mode": "replay", "refresh": True}
+
     return invoke_by_key(
         bot_key=bot_key,
         messages=messages,
         parameters=parameters,
         dataset_slugs=datasets,
         mode=mode,
+        manual_mocks=manual_mocks,
         stream=stream,
         output_format=output_format,
         verbose=verbose,
@@ -404,7 +455,7 @@ def invoke(
 def invoke_agent(
     agent: Any,
     parameters: Optional[Dict[str, Any]] = None,
-    dataset_ids: Optional[list] = None,
+    dataset_slugs: Optional[list] = None,
     stream: bool = False,
     print_events: bool = False,
     **kwargs,
@@ -414,7 +465,7 @@ def invoke_agent(
     Args:
         agent: Agent instance with a 'key' attribute
         parameters: Parameters to pass to the agent
-        dataset_ids: Dataset IDs to include
+        dataset_slugs: Dataset slugs to include (e.g. ["my-dataset"] or ["org.my-dataset"])
         stream: Whether to stream events
         print_events: Whether to print events
         **kwargs: Additional arguments (endpoint, auth_token)
@@ -427,15 +478,16 @@ def invoke_agent(
         auth_token=kwargs.get("auth_token"),
         print_events=print_events,
     )
-    return invoke.invoke_agent(agent, parameters, dataset_ids, stream)
+    return invoke.invoke_agent(agent, parameters, dataset_slugs, stream)
 
 
 def invoke_by_key(
     bot_key: str,
     messages: Optional[List[Dict[str, str]]] = None,
     parameters: Optional[Dict[str, Any]] = None,
-    dataset_ids: Optional[list] = None,
-    mode: Optional[str] = None,
+    dataset_slugs: Optional[list] = None,
+    mode: Optional[Union[str, Dict[str, Any]]] = None,
+    manual_mocks: Optional[Dict[str, Dict[str, Any]]] = None,
     stream: bool = False,
     output_format: str = "events",
     verbose: bool = False,
@@ -448,8 +500,9 @@ def invoke_by_key(
         bot_key: Bot key (e.g., "erdo.data-analyzer")
         messages: Messages in format [{"role": "user", "content": "..."}]
         parameters: Parameters to pass to the bot
-        dataset_ids: Dataset IDs to include
-        mode: Invocation mode: "live" (default), "replay" (cached), or "mock" (synthetic)
+        dataset_slugs: Dataset slugs to include (e.g. ["my-dataset"] or ["org.my-dataset"])
+        mode: Invocation mode - string: "live|replay|manual" OR dict: {"mode": "replay", "refresh": true}
+        manual_mocks: Manual mock responses for mode="manual" (step_path -> mock response)
         stream: Whether to stream events
         output_format: Output format: "events" (raw), "text" (formatted), "json" (summary)
         verbose: Show detailed steps (only for text format)
@@ -465,5 +518,13 @@ def invoke_by_key(
         print_events=print_events,
     )
     return invoke.invoke_by_key(
-        bot_key, messages, parameters, dataset_ids, mode, stream, output_format, verbose
+        bot_key,
+        messages,
+        parameters,
+        dataset_slugs,
+        mode,
+        manual_mocks,
+        stream,
+        output_format,
+        verbose,
     )

erdo/types.py

@@ -10,7 +10,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union, cast
 
-from pydantic import BaseModel, Field, field_serializer
+from pydantic import BaseModel, Field, field_serializer, model_serializer
 
 from ._generated.types import (
     ExecutionModeType,
@@ -81,6 +81,11 @@ class PythonFile(BaseModel):
             "_type": "PythonFile",  # Marker to identify this as a file reference
         }
 
+    @model_serializer
+    def _serialize_model(self) -> Dict[str, Any]:
+        """Pydantic v2 serializer - always use our custom format."""
+        return self.to_dict()
+
     def resolve_content(self, base_path: Optional[str] = None) -> Dict[str, str]:
         """Resolve the file content for inclusion in code_files.
 
@@ -233,10 +238,21 @@ class StepMetadata(BaseModel):
     ui_content_type: Optional[str] = None
     user_output_visibility: OutputVisibility = OutputVisibility.VISIBLE
     bot_output_visibility: OutputVisibility = OutputVisibility.HIDDEN
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
     parameter_hydration_behaviour: Optional[ParameterHydrationBehaviour] = None
 
+    @field_serializer(
+        "running_message", "finished_message", mode="wrap", when_used="always"
+    )
+    def serialize_message_fields(
+        self, value: Optional[Union[str, TemplateString]], _info
+    ) -> Optional[str]:
+        """Convert TemplateString to str during serialization."""
+        if isinstance(value, TemplateString):
+            return str(value)
+        return value
+
 
 class Step(StepMetadata):
     """A single step in an agent workflow."""
@@ -315,6 +331,8 @@ class Step(StepMetadata):
                 params = action_obj.model_dump()
                 # Remove the redundant 'name' field since it's already known from action type
                 params.pop("name", None)
+                # Remove step_metadata - it's for Step config, not action parameters
+                params.pop("step_metadata", None)
                 # Map Python SDK field names to backend field names
                 if "json_data" in params:
                     params["json"] = params.pop("json_data")
@@ -331,6 +349,8 @@ class Step(StepMetadata):
                 params = action_dict_method()
                 # Remove the redundant 'name' field since it's already known from action type
                 params.pop("name", None)
+                # Remove step_metadata - it's for Step config, not action parameters
+                params.pop("step_metadata", None)
                 # Map Python SDK field names to backend field names
                 if "json_data" in params:
                     params["json"] = params.pop("json_data")
@@ -920,8 +940,8 @@ class Agent(BaseModel):
     description: Optional[str] = None
     persona: Optional[str] = None
     visibility: str = "public"
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
     version: str = "1.0"
     timeout: Optional[int] = None
     retry_attempts: int = 0
@@ -929,6 +949,17 @@ class Agent(BaseModel):
     steps: List[Step] = Field(default_factory=list)
     parameter_definitions: List["ParameterDefinition"] = Field(default_factory=list)
 
+    @field_serializer(
+        "running_message", "finished_message", mode="wrap", when_used="always"
+    )
+    def serialize_message_fields(
+        self, value: Optional[Union[str, TemplateString]], _info
+    ) -> Optional[str]:
+        """Convert TemplateString to str during serialization."""
+        if isinstance(value, TemplateString):
+            return str(value)
+        return value
+
     def step(
         self,
         action: Any,

{erdo-0.1.9.dist-info → erdo-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: erdo
-Version: 0.1.9
+Version: 0.1.11
 Summary: Python SDK for building workflow automation agents with Erdo
 Project-URL: Homepage, https://erdo.ai
 Project-URL: Documentation, https://docs.erdo.ai
@@ -316,18 +316,46 @@ else:
 
 ### Invocation Modes
 
-- **Live Mode** (default): Runs against real backend with LLM API
-- **Replay Mode**: Uses cached responses - free after first run (perfect for testing!)
-- **Mock Mode**: Returns synthetic responses - always free
+Control how bot actions are executed for testing and development:
+
+| Mode | Description | Cost |
+|------|-------------|------|
+| **live** | Execute with real API calls | $$$ per run |
+| **replay** | Cache responses, replay on subsequent runs | $$$ first run, FREE after |
+| **manual** | Use developer-provided mock responses | FREE always |
 
 ```python
-# Replay mode - free after first run
+# Live mode (default) - real API calls
+response = invoke("my-agent", messages=[...], mode="live")
+
+# Replay mode - cache after first run (recommended for testing!)
 response = invoke("my-agent", messages=[...], mode="replay")
 
-# Mock mode - always free
-response = invoke("my-agent", messages=[...], mode="mock")
+# Replay with refresh - bypass cache, get fresh response
+response = invoke("my-agent", messages=[...], mode={"mode": "replay", "refresh": True})
+
+# Manual mode - use mock responses
+response = invoke(
+    "my-agent",
+    messages=[...],
+    mode="manual",
+    manual_mocks={
+        "llm.message": {
+            "status": "success",
+            "output": {"content": "Mocked response"}
+        }
+    }
+)
 ```
 
+**Replay Mode Refresh:**
+The `refresh` parameter forces a fresh API call while staying in replay mode:
+- First run: Executes and caches the response
+- Subsequent runs: Uses cached response (free!)
+- With refresh: Bypasses cache, gets fresh response, updates cache
+
+Perfect for updating cached responses after bot changes without switching modes.
+
 ## Testing Agents
 
 Write fast, parallel agent tests using `agent_test_*` functions:
@@ -358,8 +386,17 @@ erdo agent-test tests/test_my_agent.py
 
 # Verbose output
 erdo agent-test tests/test_my_agent.py --verbose
+
+# Refresh cached responses (bypass cache for all replay mode tests)
+erdo agent-test tests/test_my_agent.py --refresh
 ```
 
+**Refresh Flag:**
+The `--refresh` flag forces all tests using `mode="replay"` to bypass cache and get fresh responses. Perfect for:
+- Updating cached responses after bot changes
+- Verifying tests with current LLM behavior
+- No code changes needed - just add the flag!
+
 ### Test Helpers
 
 The `erdo.test` module provides assertion helpers:

{erdo-0.1.9.dist-info → erdo-0.1.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-erdo/__init__.py,sha256=ko4ZhPHlSJpvrnK5BI04qfGycBN9WqYL5Nh6SGk-Ysc,1082
+erdo/__init__.py,sha256=57AWoaFi3nxED99SJKdJpD_lPNiZE1AerfSIld6-XFc,1137
 erdo/bot_permissions.py,sha256=NZSjjGURORpq3hRqv0tA0YvkxcTZ9MQqtmzrlmof29c,8261
 erdo/cli_entry.py,sha256=jz18bWz-D09rmkEvwLTAbcK1shHUqFCpiU7U7czEltY,2057
 erdo/formatting.py,sha256=jIfQlqk1oKratM8Fkrlq1rRsnergthbSQFCfeEd6rqY,8346
@@ -6,19 +6,19 @@ erdo/install_cli.py,sha256=jgRoSm-MIbLHW0Sr5m78q3htRwIh7JXo_wNmpVsiAcM,4454
 erdo/integrations.py,sha256=-xYBpjYmjhJtv_UnaIfBb46cJC4icLOx9P1kOf5lM-g,4219
 erdo/state.py,sha256=o89-SThDWYNjfwMZuDfier1Lx96_tLi5wYSth7dPI6I,14270
 erdo/template.py,sha256=gvlSpEN3whD4LEqY6ppeYYZuFeM9ndU68qzKP-ETRJ8,4641
-erdo/types.py,sha256=KQGaw42O-ltVUhZjv-MpiS6vrpMbMWkn3g1u2ZPkGlk,52564
+erdo/types.py,sha256=nI7YK8G6vnZqpZYELpjd_20NdKfW_cqddc7ipmRSKX8,53906
 erdo/_generated/__init__.py,sha256=jFLoVFeswecK5mGp4-MPWwnygol2dYIsEpnmm9gubHY,506
 erdo/_generated/internal.py,sha256=ghd1g_9WF0kXO2MkFIBxcuHuRF00SlOeT-mjJcfQNyM,1569
 erdo/_generated/internal_actions.py,sha256=dbZgHNF5RQhjyB8VAJ-4eaV2XUlqHKv99m-DtNNx7rI,2661
 erdo/_generated/parameters.py,sha256=QC-_75fQg_iFu-dvI9ce4yHP9UnFItDWe6sBfzfXaig,472
 erdo/_generated/secrets.py,sha256=F2xBkFsiYXOJnZ5Tcrc9uiaakyirHlKFkYCFxZKANtw,454
 erdo/_generated/template_functions.py,sha256=mgFqsXxL36dMNptzDaGvNEjoA76nFf4k9ZRz-J4Ozdc,1174
-erdo/_generated/types.py,sha256=heiWWVNnCDqO8a99emh1XTtqRHIQEHKugWUoJUKq5Og,81094
+erdo/_generated/types.py,sha256=ecQN1OnrYQhoJ3Fk1eO3YDFycO9cTpYxiAg-3DkG5_0,129612
 erdo/_generated/actions/__init__.py,sha256=L5YKDEe1RikpvtkWxmTAThVLa-HxGfur3kcO-S7RB_w,1223
 erdo/_generated/actions/analysis.py,sha256=xuDxpd4NiS4bW_JAAQEhQa4Impmq_sBfSaUt3SYhf0g,5483
-erdo/_generated/actions/bot.py,sha256=5rQxG2GgU8V_sjLN6QIMTPZN5e5omURRLUppuNQegXM,6291
-erdo/_generated/actions/codeexec.py,sha256=31cZWnFHSAsYeu_y_gLlhcoKVpSl-C701OvilKb_qo4,6698
-erdo/_generated/actions/llm.py,sha256=HvCXnnUadJnM4P3zrcQ2KIWyhqACAX4x0zw6VO6N3XI,5142
+erdo/_generated/actions/bot.py,sha256=VhDIgtHCcUDovDyXT14ow8qntKxe73KhOvN6FO3c454,6456
+erdo/_generated/actions/codeexec.py,sha256=hwi46L1b7VLuRyq4kJVkTbv3aictP0ZLufdM4h5Kl_c,8076
+erdo/_generated/actions/llm.py,sha256=CnAdNU-Ei3P_N6LSuvyuPzFvN8Zl-C6B6L7rgefPiAo,5282
 erdo/_generated/actions/memory.py,sha256=cSzlVrR2tMobaO4VBGtRPmBv5NGpUHq36nAG3yQQFVg,16321
 erdo/_generated/actions/pdfextractor.py,sha256=UQ10OQ3K3FNKkqx18aG67Xbqd3GjB0nNh7DA6mpNs2g,3535
 erdo/_generated/actions/resource_definitions.py,sha256=0vzElFygA__fUYhgUOlcmyhkGwqLCNnxiPYcW6c3sDk,10787
@@ -32,8 +32,8 @@ erdo/conditions/__init__.py,sha256=xN7MS1aj4lh65CrE-94yFQXnQV8v8VjdEXMzPLTK0CU,3
 erdo/config/__init__.py,sha256=lROKyMtaH5cMiF1RcIRA2NLR1Sp8AKWx4brcPT1Vwy8,147
 erdo/config/config.py,sha256=BSerQVQdbbp1KuARpIuKp6bM1M4Cqr-Bsf0nQJJTND8,4279
 erdo/invoke/__init__.py,sha256=QhMBmUR8OXuyFS8fbNntjpRd7LNeKlV8Y8x6qSjgQ0I,249
-erdo/invoke/client.py,sha256=bLQNlyRnXpAIJA9SXUn4kOIwWC4wXq5_hmjH262YBzA,8181
-erdo/invoke/invoke.py,sha256=FEWOcPupyB9TaNtBv3p6HmXXjtr8Wt16MvQTQi1-o6o,17585
+erdo/invoke/client.py,sha256=NNuZRQGvLFDENMCub4xLzEpihFYdc6PauKyA99pncsk,8523
+erdo/invoke/invoke.py,sha256=1bYjUPCIrk7dNoe7f5fV19UgBo0rp_dGdePVQiLIa0M,21368
 erdo/sync/__init__.py,sha256=f-7-9cYngOiLrTDAng3JxMC86JIE6jFk6-Vjz_dMybs,311
 erdo/sync/client.py,sha256=LrcyrsapuyrqmuPh-UwbocL7WUhHZ9zkDItXzon_AUs,3022
 erdo/sync/extractor.py,sha256=iAIlRJqHr4e69XYnir2mZ6F6cUjnXp0P_EKsG1jdDLc,17217
@@ -41,8 +41,8 @@ erdo/sync/sync.py,sha256=KzuChW5ramY8rX6QM3emRda928A09CQzFLmLJ5PLztg,10421
 erdo/test/__init__.py,sha256=_OevGagFDTykFcYzA__FARXiS5kgT9tK90r_0TmyGQQ,1114
 erdo/test/evaluate.py,sha256=-6vX6ynW8ICYaoXZLl-xdzAALvx1aSl1CurIRkgSJ0s,7730
 erdo/test/runner.py,sha256=vZR9PLKT2nDMzHyPm_jniGSA9eddGk4p1dQq0h1dRms,7299
-erdo-0.1.9.dist-info/METADATA,sha256=qAdRD4ihgYYp_1_0Rxoxk-0A2Phl5UIkQ_X2ZJrHRIA,11403
-erdo-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erdo-0.1.9.dist-info/entry_points.txt,sha256=KFGSp8-6IE3-8dSr-3Djqye3IdEY65Y4E8fABoFUCHg,45
-erdo-0.1.9.dist-info/licenses/LICENSE,sha256=9pdgUAuBAumY5tewMdJnx2Ozj8dS6gGKsSiY-SVInu4,1034
-erdo-0.1.9.dist-info/RECORD,,
+erdo-0.1.11.dist-info/METADATA,sha256=V4rWLmAuZOYGC-l9vfaIrricXSfEe0Hl32ajPJZv3ZI,12712
+erdo-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erdo-0.1.11.dist-info/entry_points.txt,sha256=KFGSp8-6IE3-8dSr-3Djqye3IdEY65Y4E8fABoFUCHg,45
+erdo-0.1.11.dist-info/licenses/LICENSE,sha256=9pdgUAuBAumY5tewMdJnx2Ozj8dS6gGKsSiY-SVInu4,1034
+erdo-0.1.11.dist-info/RECORD,,