dacp 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

dacp/workflow_runtime.py

@@ -20,6 +20,7 @@ logger = logging.getLogger("dacp.workflow_runtime")
 
 class TaskStatus(Enum):
     """Task execution status."""
+
     PENDING = "pending"
     RUNNING = "running"
     COMPLETED = "completed"
@@ -30,6 +31,7 @@ class TaskStatus(Enum):
 @dataclass
 class TaskExecution:
     """Represents a task execution instance."""
+
     id: str
     workflow_id: str
     step_id: str
@@ -66,6 +68,7 @@ class TaskExecution:
 @dataclass
 class RegisteredAgent:
     """Represents a registered agent in the registry."""
+
     id: str
     agent_instance: Any
     spec_file: Optional[str] = None
@@ -88,24 +91,24 @@ class RegisteredAgent:
 class AgentRegistry:
     """Registry for managing agent instances."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.agents: Dict[str, RegisteredAgent] = {}
 
     def register_agent(
-        self, 
-        agent_id: str, 
-        agent_instance: Any, 
+        self,
+        agent_id: str,
+        agent_instance: Any,
         spec_file: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Register an agent instance."""
         registered_agent = RegisteredAgent(
             id=agent_id,
             agent_instance=agent_instance,
             spec_file=spec_file,
-            metadata=metadata or {}
+            metadata=metadata or {},
         )
-        
+
         self.agents[agent_id] = registered_agent
         logger.info(f"🤖 Agent '{agent_id}' registered in registry")
 
@@ -138,7 +141,7 @@ class AgentRegistry:
 class TaskRegistry:
     """Registry for managing task executions."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.tasks: Dict[str, TaskExecution] = {}
         self.workflow_tasks: Dict[str, List[str]] = {}  # workflow_id -> task_ids
 
@@ -148,52 +151,54 @@ class TaskRegistry:
         step_id: str,
         agent_id: str,
         task_name: str,
-        input_data: Dict[str, Any]
+        input_data: Dict[str, Any],
     ) -> str:
         """Create a new task execution."""
         task_id = str(uuid.uuid4())
-        
+
         task = TaskExecution(
             id=task_id,
             workflow_id=workflow_id,
             step_id=step_id,
             agent_id=agent_id,
             task_name=task_name,
-            input_data=input_data
+            input_data=input_data,
         )
-        
+
         self.tasks[task_id] = task
-        
+
         # Add to workflow tasks
         if workflow_id not in self.workflow_tasks:
             self.workflow_tasks[workflow_id] = []
         self.workflow_tasks[workflow_id].append(task_id)
-        
-        logger.info(f"📋 Task '{task_id}' created for agent '{agent_id}' in workflow '{workflow_id}'")
+
+        logger.info(
+            f"📋 Task '{task_id}' created for agent '{agent_id}' in workflow '{workflow_id}'"
+        )
         return task_id
 
     def get_task(self, task_id: str) -> Optional[TaskExecution]:
         """Get a task by ID."""
         return self.tasks.get(task_id)
 
-    def update_task_status(self, task_id: str, status: TaskStatus, **kwargs) -> bool:
+    def update_task_status(self, task_id: str, status: TaskStatus, **kwargs: Any) -> bool:
         """Update task status and optional fields."""
         if task_id not in self.tasks:
             return False
-        
+
         task = self.tasks[task_id]
         task.status = status
-        
+
         # Update optional fields
         for key, value in kwargs.items():
             if hasattr(task, key):
                 setattr(task, key, value)
-        
+
         # Calculate duration if completed
         if status in [TaskStatus.COMPLETED, TaskStatus.FAILED] and task.started_at:
             task.completed_at = time.time()
             task.duration = task.completed_at - task.started_at
-        
+
         logger.info(f"📊 Task '{task_id}' status updated to {status.value}")
         return True
 
@@ -204,26 +209,26 @@ class TaskRegistry:
 
     def get_task_summary(self) -> Dict[str, Any]:
         """Get summary of all tasks."""
-        status_counts = {}
+        status_counts: Dict[str, int] = {}
         for task in self.tasks.values():
             status = task.status.value
             status_counts[status] = status_counts.get(status, 0) + 1
-        
+
         return {
             "total_tasks": len(self.tasks),
             "status_counts": status_counts,
-            "workflows": len(self.workflow_tasks)
+            "workflows": len(self.workflow_tasks),
         }
 
 
 class WorkflowRuntime:
     """DACP Workflow Runtime - Executes workflows from workflow.yaml"""
 
-    def __init__(self, orchestrator=None):
+    def __init__(self, orchestrator: Optional[Any] = None) -> None:
         self.orchestrator = orchestrator
         self.agent_registry = AgentRegistry()
         self.task_registry = TaskRegistry()
-        self.workflow_config = {}
+        self.workflow_config: Dict[str, Any] = {}
         self.active_workflows: Dict[str, Dict[str, Any]] = {}
 
     def load_workflow_config(self, config_path: str) -> None:
@@ -231,10 +236,10 @@ class WorkflowRuntime:
         config_file = Path(config_path)
         if not config_file.exists():
             raise FileNotFoundError(f"Workflow config file not found: {config_path}")
-        
-        with open(config_file, 'r') as f:
+
+        with open(config_file, "r") as f:
             self.workflow_config = yaml.safe_load(f)
-        
+
         logger.info(f"📁 Loaded workflow config from {config_path}")
         logger.info(f"📋 Found {len(self.workflow_config.get('workflows', {}))} workflows")
 
@@ -242,40 +247,42 @@ class WorkflowRuntime:
         """Register an agent instance based on workflow config."""
         # Find agent spec in config
         agent_spec = None
-        for agent_config in self.workflow_config.get('agents', []):
-            if agent_config['id'] == agent_id:
-                agent_spec = agent_config.get('spec')
+        for agent_config in self.workflow_config.get("agents", []):
+            if agent_config["id"] == agent_id:
+                agent_spec = agent_config.get("spec")
                 break
-        
+
         self.agent_registry.register_agent(
             agent_id=agent_id,
             agent_instance=agent_instance,
             spec_file=agent_spec,
-            metadata={"config_based": True}
+            metadata={"config_based": True},
         )
 
-    def execute_workflow(self, workflow_name: str, initial_input: Dict[str, Any] = None) -> str:
+    def execute_workflow(
+        self, workflow_name: str, initial_input: Optional[Dict[str, Any]] = None
+    ) -> str:
         """Execute a workflow by name."""
-        if workflow_name not in self.workflow_config.get('workflows', {}):
+        if workflow_name not in self.workflow_config.get("workflows", {}):
             raise ValueError(f"Workflow '{workflow_name}' not found in config")
-        
-        workflow_def = self.workflow_config['workflows'][workflow_name]
+
+        workflow_def = self.workflow_config["workflows"][workflow_name]
         workflow_id = str(uuid.uuid4())
-        
+
         logger.info(f"🚀 Starting workflow '{workflow_name}' with ID '{workflow_id}'")
-        
+
         # Initialize workflow state
         self.active_workflows[workflow_id] = {
             "name": workflow_name,
             "definition": workflow_def,
             "current_step": 0,
-            "context": initial_input or {},
-            "started_at": time.time()
+            "context": {"input": initial_input or {}},
+            "started_at": time.time(),
         }
-        
+
         # Execute first step
         self._execute_workflow_step(workflow_id, 0)
-        
+
         return workflow_id
 
     def _execute_workflow_step(self, workflow_id: str, step_index: int) -> None:
@@ -283,37 +290,37 @@ class WorkflowRuntime:
         if workflow_id not in self.active_workflows:
             logger.error(f"❌ Workflow '{workflow_id}' not found")
             return
-        
+
         workflow_state = self.active_workflows[workflow_id]
         workflow_def = workflow_state["definition"]
         steps = workflow_def.get("steps", [])
-        
+
         if step_index >= len(steps):
             logger.info(f"🏁 Workflow '{workflow_id}' completed")
             return
-        
+
         step = steps[step_index]
         step_id = f"step_{step_index}"
-        
+
         # Extract step configuration
         agent_id = step.get("agent")
         task_name = step.get("task")
         step_input = step.get("input", {})
-        
+
         # Resolve input data with context
         resolved_input = self._resolve_input_data(step_input, workflow_state["context"])
-        
+
         logger.info(f"📋 Executing step {step_index}: {agent_id}.{task_name}")
-        
+
         # Create task
         task_id = self.task_registry.create_task(
             workflow_id=workflow_id,
             step_id=step_id,
             agent_id=agent_id,
             task_name=task_name,
-            input_data=resolved_input
+            input_data=resolved_input,
         )
-        
+
         # Execute task
         self._execute_task(task_id, workflow_id, step_index)
 
@@ -323,88 +330,76 @@ class WorkflowRuntime:
         if not task:
             logger.error(f"❌ Task '{task_id}' not found")
             return
-        
+
         # Get agent instance
         agent = self.agent_registry.get_agent(task.agent_id)
         if not agent:
             self.task_registry.update_task_status(
-                task_id, TaskStatus.FAILED, 
-                error=f"Agent '{task.agent_id}' not found"
+                task_id, TaskStatus.FAILED, error=f"Agent '{task.agent_id}' not found"
             )
             return
-        
+
         # Update task status
-        self.task_registry.update_task_status(
-            task_id, TaskStatus.RUNNING, 
-            started_at=time.time()
-        )
-        
+        self.task_registry.update_task_status(task_id, TaskStatus.RUNNING, started_at=time.time())
+
         try:
             # Prepare message for agent
-            message = {
-                "task": task.task_name,
-                **task.input_data
-            }
-            
+            message = {"task": task.task_name, **task.input_data}
+
             logger.info(f"📨 Sending task '{task.task_name}' to agent '{task.agent_id}'")
-            
+
             # Execute via orchestrator or direct call
             if self.orchestrator:
                 result = self.orchestrator.send_message(task.agent_id, message)
             else:
                 result = agent.handle_message(message)
-            
+
             # Check for errors
             if isinstance(result, dict) and "error" in result:
                 self.task_registry.update_task_status(
-                    task_id, TaskStatus.FAILED,
-                    error=result["error"]
+                    task_id, TaskStatus.FAILED, error=result["error"]
                 )
                 logger.error(f"❌ Task '{task_id}' failed: {result['error']}")
                 return
-            
+
             # Task completed successfully
-            self.task_registry.update_task_status(
-                task_id, TaskStatus.COMPLETED,
-                output_data=result
-            )
-            
+            self.task_registry.update_task_status(task_id, TaskStatus.COMPLETED, output_data=result)
+
             logger.info(f"✅ Task '{task_id}' completed successfully")
-            
+
             # Continue workflow
             self._handle_task_completion(task_id, workflow_id, step_index, result)
-            
+
         except Exception as e:
-            self.task_registry.update_task_status(
-                task_id, TaskStatus.FAILED,
-                error=str(e)
-            )
+            self.task_registry.update_task_status(task_id, TaskStatus.FAILED, error=str(e))
             logger.error(f"❌ Task '{task_id}' failed with exception: {e}")
 
-    def _handle_task_completion(self, task_id: str, workflow_id: str, step_index: int, result: Dict[str, Any]) -> None:
+    def _handle_task_completion(
+        self, task_id: str, workflow_id: str, step_index: int, result: Dict[str, Any]
+    ) -> None:
         """Handle task completion and route to next step."""
         workflow_state = self.active_workflows[workflow_id]
         workflow_def = workflow_state["definition"]
         steps = workflow_def.get("steps", [])
-        
+
         if step_index >= len(steps):
             return
-        
+
         current_step = steps[step_index]
-        
+
         # Convert result to dictionary if it's a Pydantic model
-        if hasattr(result, 'model_dump'):
+        if hasattr(result, "model_dump"):
             result_dict = result.model_dump()
             logger.debug(f"🔧 Converted Pydantic model to dict: {result_dict}")
-        elif hasattr(result, 'dict'):
+        elif hasattr(result, "dict"):
             result_dict = result.dict()
             logger.debug(f"🔧 Converted Pydantic model to dict (legacy): {result_dict}")
         else:
             result_dict = result
-        
+
         # Update workflow context with result
         workflow_state["context"].update({"output": result_dict})
-        
+
         # Check for routing
         route_config = current_step.get("route_output_to")
         if route_config:
@@ -412,47 +407,90 @@ class WorkflowRuntime:
             next_agent_id = route_config.get("agent")
             next_task_name = route_config.get("task")
             input_mapping = route_config.get("input_mapping", {})
-            
+
             logger.debug(f"🔍 Input mapping: {input_mapping}")
             logger.debug(f"🔍 Available output data: {result_dict}")
-            
+
             # Resolve input mapping
-            next_input = self._resolve_input_mapping(input_mapping, result_dict, workflow_state["context"])
-            
+            next_input = self._resolve_input_mapping(
+                input_mapping, result_dict, workflow_state["context"]
+            )
+
             logger.info(f"🔄 Routing output to {next_agent_id}.{next_task_name}")
             logger.debug(f"🔍 Resolved input for next task: {next_input}")
-            
+
             # Create and execute next task
             next_task_id = self.task_registry.create_task(
                 workflow_id=workflow_id,
                 step_id=f"routed_step_{step_index}",
                 agent_id=next_agent_id,
                 task_name=next_task_name,
-                input_data=next_input
+                input_data=next_input,
             )
-            
+
             self._execute_task(next_task_id, workflow_id, step_index + 1)
         else:
             # Continue to next step
             self._execute_workflow_step(workflow_id, step_index + 1)
 
-    def _resolve_input_data(self, input_config: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+    def _resolve_input_data(
+        self, input_config: Dict[str, Any], context: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Resolve input data with context variables."""
         resolved = {}
         for key, value in input_config.items():
             if isinstance(value, str) and value.startswith("{{") and value.endswith("}}"):
                 # Template variable
-                var_path = value[2:-2].strip()
-                resolved[key] = self._get_nested_value(context, var_path)
+                template_content = value[2:-2].strip()
+                
+                # Handle default values (e.g., "input.branch | default('main')")
+                if " | default(" in template_content:
+                    var_path, default_part = template_content.split(" | default(", 1)
+                    var_path = var_path.strip()
+                    default_value = default_part.rstrip(")").strip("'\"")
+                    
+                    result = self._resolve_template_path(context, var_path)
+                    resolved[key] = result if result is not None else default_value
+                else:
+                    # Simple template variable
+                    resolved[key] = self._resolve_template_path(context, template_content)
+            elif isinstance(value, dict):
+                # Recursively resolve nested dictionaries
+                resolved[key] = self._resolve_input_data(value, context)
             else:
                 resolved[key] = value
         return resolved
 
-    def _resolve_input_mapping(self, mapping: Dict[str, str], output: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+    def _resolve_template_path(self, context: Dict[str, Any], path: str) -> Any:
+        """Resolve template path including steps.* references."""
+        if path.startswith("steps."):
+            # Handle steps.step_name.output.field syntax
+            parts = path.split(".")
+            if len(parts) >= 4 and parts[2] == "output":
+                step_name = parts[1]
+                field_path = ".".join(parts[3:])
+                
+                # Look for step output in context
+                if "output" in context and isinstance(context["output"], dict):
+                    return self._get_nested_value(context["output"], field_path)
+                return None
+            else:
+                return None
+        else:
+            # Regular context path
+            return self._get_nested_value(context, path)
+
+    def _resolve_input_mapping(
+        self, mapping: Dict[str, str], output: Dict[str, Any], context: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Resolve input mapping with output and context."""
         resolved = {}
         for target_key, source_template in mapping.items():
-            if isinstance(source_template, str) and source_template.startswith("{{") and source_template.endswith("}}"):
+            if (
+                isinstance(source_template, str)
+                and source_template.startswith("{{")
+                and source_template.endswith("}}")
+            ):
                 var_path = source_template[2:-2].strip()
                 if var_path.startswith("output."):
                     # From current output
@@ -467,7 +505,7 @@ class WorkflowRuntime:
 
     def _get_nested_value(self, data: Dict[str, Any], path: str) -> Any:
         """Get nested value from dictionary using dot notation."""
-        keys = path.split('.')
+        keys = path.split(".")
         current = data
         for key in keys:
             if isinstance(current, dict) and key in current:
@@ -480,17 +518,17 @@ class WorkflowRuntime:
         """Get workflow execution status."""
         if workflow_id not in self.active_workflows:
             return None
-        
+
         workflow_state = self.active_workflows[workflow_id]
         tasks = self.task_registry.get_workflow_tasks(workflow_id)
-        
+
         return {
             "workflow_id": workflow_id,
             "name": workflow_state["name"],
             "current_step": workflow_state["current_step"],
             "started_at": workflow_state["started_at"],
             "context": workflow_state["context"],
-            "tasks": [task.to_dict() for task in tasks]
+            "tasks": [task.to_dict() for task in tasks],
         }
 
     def get_runtime_status(self) -> Dict[str, Any]:
@@ -498,11 +536,11 @@ class WorkflowRuntime:
         return {
             "agents": {
                 "registered": len(self.agent_registry.agents),
-                "agents": [agent.to_dict() for agent in self.agent_registry.agents.values()]
+                "agents": [agent.to_dict() for agent in self.agent_registry.agents.values()],
             },
             "tasks": self.task_registry.get_task_summary(),
             "workflows": {
                 "active": len(self.active_workflows),
-                "configured": len(self.workflow_config.get('workflows', {}))
-            }
-        } 
+                "configured": len(self.workflow_config.get("workflows", {})),
+            },
+        }

{dacp-0.3.3.dist-info → dacp-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dacp
-Version: 0.3.3
+Version: 0.3.4
 Summary: Declarative Agent Communication Protocol - A protocol for managing LLM/agent communications and tool function calls
 Author-email: Andrew Whitehouse <andrew.whitehouse@example.com>
 License: MIT
@@ -26,20 +26,25 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
 Requires-Dist: pyyaml>=5.4.0
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.18.0; extra == "anthropic"
 Provides-Extra: local
 Requires-Dist: requests>=2.25.0; extra == "local"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.104.0; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.24.0; extra == "api"
 Provides-Extra: all
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: anthropic>=0.18.0; extra == "all"
+Requires-Dist: fastapi>=0.104.0; extra == "all"
+Requires-Dist: uvicorn[standard]>=0.24.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=22.0.0; extra == "dev"
-Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: types-requests>=2.25.0; extra == "dev"
 Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"

dacp-0.3.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+dacp/__init__.py,sha256=UjSEhLapHynmUbNCV6fRazgXVS7HYfPGdR30iJG3m44,2224
+dacp/api.py,sha256=p771UaXbIzhkJMtPi-SKtbyFZAiWJy1tUES-iSvEFyU,11736
+dacp/cli.py,sha256=VesLS41TmskfvijqNzn9QnS8urFrOlLN6txauNhe38w,9449
+dacp/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp/intelligence.py,sha256=63dQDug_WvSuHxlsAR4lOMtf7UGmtU74j5wFRJnmv9c,9526
+dacp/json_parser.py,sha256=QGeoXIYZfHQvDYmo1awCxfTLx7jJj7qpjsmDtXMxK1A,8076
+dacp/llm.py,sha256=K78QefD3LCOBTrsNHtfRs-UzcHNYCJNxcJ28HGirwfU,1064
+dacp/logging_config.py,sha256=Gfxfk_t8m8gyciS9stAUGYANrYmKQ9F_XjgOyUATuhY,3895
+dacp/main.py,sha256=YReioZotkURiYMuMLVf_-hPzVPSpqA5Esgwz7D36DhE,229
+dacp/orchestrator.py,sha256=k-yrnGiz-Rtts4HphIVIwhULIE-dvQNzBD_bhuQndZ0,9679
+dacp/protocol.py,sha256=DVhLTdyDVlAu8ETSEX8trPeycKfMeirHwcWQ8-BY7eA,1026
+dacp/tools.py,sha256=YXK4MzL3Aahsnj26NveDLdEDO1ZkPxrwZpD1JfALS10,2846
+dacp/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp/workflow.py,sha256=ikrJhci9119Xb9fe0R3LMscmY4rtTjy9QE9pbJYFh3w,14481
+dacp/workflow_runtime.py,sha256=JijfgcYz3xnXP3GePciuWszG7SK3Dp7BSTeN0c5H86Y,19876
+dacp-0.3.4.dist-info/licenses/LICENSE,sha256=tb5kgUYRypHqAy8wlrJUBSYI5l1SBmawSYHmCC-MVW0,1074
+dacp-0.3.4.dist-info/METADATA,sha256=ojeVx0qWxHJQN_HuJC_ne2T02L9tH8JDUG01TwD4W9c,25970
+dacp-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dacp-0.3.4.dist-info/entry_points.txt,sha256=-4RWvAkDznguXlMyDO0ZReOkSplbuCYLXu5IX8RIiCg,39
+dacp-0.3.4.dist-info/top_level.txt,sha256=Qxy0cy5jl7ttTQoGFlY9LXB6CbSvsekJ2y0P8I7L1zA,5
+dacp-0.3.4.dist-info/RECORD,,

dacp-0.3.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dacp = dacp.cli:main

dacp-0.3.3.dist-info/RECORD

@@ -1,18 +0,0 @@
-dacp/__init__.py,sha256=VnIaZHQutoNLVmtCRV1sMk3oAjf4HtF42kiXmuJ21Tw,2224
-dacp/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dacp/intelligence.py,sha256=z8RqRYXKKKDd9MCm1KLBNQ3DJ9Zl4ZntbjFcaqtuv9s,9713
-dacp/json_parser.py,sha256=qQ3zWlhaiyQUyDRUQPHaqkwAd29uM2zlGflsPKeamB4,8245
-dacp/llm.py,sha256=K78QefD3LCOBTrsNHtfRs-UzcHNYCJNxcJ28HGirwfU,1064
-dacp/logging_config.py,sha256=g5iMe9mloZag4oFQ9FQrRTikDTCI-XxeTGX0Y1KXVMw,3927
-dacp/main.py,sha256=YReioZotkURiYMuMLVf_-hPzVPSpqA5Esgwz7D36DhE,229
-dacp/orchestrator.py,sha256=fTOlWz95Xs1W1OxsRht3zyLyU5UnrLXBAFOfkqCB17k,9915
-dacp/protocol.py,sha256=DVhLTdyDVlAu8ETSEX8trPeycKfMeirHwcWQ8-BY7eA,1026
-dacp/tools.py,sha256=wfuUQ12UVvyMLUcDA4GGxwwzQJ-k4ftWbewg7qwNQGg,2872
-dacp/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dacp/workflow.py,sha256=AzuKGUiKnifEHsAO9b7p3OB4I-gb0tKWIco15clv-Wg,14322
-dacp/workflow_runtime.py,sha256=X8PWlYvMUD36gGRGsKKKvVCEcJMGeKfzIg4JMB8iEMA,18596
-dacp-0.3.3.dist-info/licenses/LICENSE,sha256=tb5kgUYRypHqAy8wlrJUBSYI5l1SBmawSYHmCC-MVW0,1074
-dacp-0.3.3.dist-info/METADATA,sha256=4tu9_DW7z2iiB9MHMKEgFylPXx-NLgPGMprrpElBn6M,25756
-dacp-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dacp-0.3.3.dist-info/top_level.txt,sha256=Qxy0cy5jl7ttTQoGFlY9LXB6CbSvsekJ2y0P8I7L1zA,5
-dacp-0.3.3.dist-info/RECORD,,