loom-core 0.2.0__tar.gz → 1.0.0__tar.gz

{loom_core-0.2.0 → loom_core-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-core
-Version: 0.2.0
+Version: 1.0.0
 Summary: Durable workflow orchestration engine for Python
 Home-page: https://github.com/satadeep3927/loom
 Author: Satadeep Dasgupta
@@ -23,7 +23,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiosqlite>=0.19.0
 Requires-Dist: click>=8.0.0
-Requires-Dist: rich>=13.0.0
+Requires-Dist: rich>=14.3.1
+Requires-Dist: fastapi[standard]>=0.95.0
+Requires-Dist: uvicorn[standard]>=0.22.0
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

{loom_core-0.2.0 → loom_core-1.0.0}/loom/__init__.py

@@ -25,6 +25,10 @@ from loom.database.db import Database
 from loom.decorators.activity import activity
 from loom.decorators.workflow import step, workflow
 
+# Import web module and app for uvicorn compatibility
+from loom import web
+from loom.web.main import app
+
 __version__ = "0.1.0"
 
 __all__ = [
@@ -40,6 +44,9 @@ __all__ = [
     # Functions
     "start_worker",
     "run_once",
+    # Web
+    "web",
+    "app",
     # Version
     "__version__",
 ]

loom_core-1.0.0/loom/__main__.py

@@ -0,0 +1,9 @@
+"""Loom package main entry point.
+
+Enables running loom as a module: python -m loom
+"""
+
+from .cli.cli import cli
+
+if __name__ == "__main__":
+    cli()

{loom_core-0.2.0 → loom_core-1.0.0}/loom/cli/cli.py

@@ -70,6 +70,63 @@ def worker(workers: int, poll_interval: float):
         pass
 
 
+@cli.command()
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    help="Host to bind to",
+    show_default=True,
+)
+@click.option(
+    "--port",
+    default=8000,
+    type=int,
+    help="Port to bind to",
+    show_default=True,
+)
+@click.option(
+    "--reload",
+    is_flag=True,
+    help="Enable auto-reload for development",
+)
+def web(host: str, port: int, reload: bool):
+    """Start the Loom web dashboard.
+
+    Launches a FastAPI-based web interface for monitoring and managing
+    workflows, tasks, events, and logs with real-time Server-Sent Events.
+
+    Examples:
+        loom web                       # Start on 127.0.0.1:8000
+        loom web --host 0.0.0.0        # Bind to all interfaces
+        loom web --port 3000           # Use port 3000
+        loom web --reload              # Enable auto-reload for development
+    """
+    try:
+        import uvicorn
+
+        console.print("[bold green]Starting Loom web dashboard...[/bold green]")
+        console.print(f"[blue]Dashboard: http://{host}:{port}[/blue]")
+        console.print(f"[blue]API docs: http://{host}:{port}/docs[/blue]")
+        console.print(f"[blue]ReDoc: http://{host}:{port}/redoc[/blue]")
+
+        uvicorn.run(
+            "loom.web.main:app",
+            host=host,
+            port=port,
+            reload=reload,
+            log_level="info",
+            access_log=not reload,  # Reduce noise in dev mode
+        )
+    except ImportError:
+        console.print("[red]FastAPI and uvicorn are required for web dashboard[/red]")
+        console.print(
+            "[yellow]Install with: pip install 'loom[web]' or pip install fastapi uvicorn[standard][/yellow]"
+        )
+        sys.exit(1)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Web server stopped[/yellow]")
+
+
 @cli.command()
 def init():
     """Initialize the Loom database and migrations.

{loom_core-0.2.0 → loom_core-1.0.0}/loom/common/errors.py

@@ -22,7 +22,7 @@ class WorkerCancelledError(Exception):
     pass
 
 
-class StopReplay(Exception):
+class StopReplay(Exception):  # noqa: N818
     """
     Exception used to signal that workflow replay should stop.
 

{loom_core-0.2.0 → loom_core-1.0.0}/loom/core/context.py

@@ -86,7 +86,7 @@ class WorkflowContext(Generic[InputT, StateT]):
 
     def _skip_step_events(self) -> None:
         """Skip over STEP_START and STEP_END events during replay.
-        
+
         These are internal workflow management events that don't affect
         the deterministic execution logic.
         """
@@ -117,6 +117,7 @@ class WorkflowContext(Generic[InputT, StateT]):
         """
         # We're replaying if we haven't consumed all the original events yet
         return self.cursor < self._original_history_length
+
     def is_at_end_of_history(self) -> bool:
         """Check if we've consumed all events in history.
 
@@ -211,7 +212,7 @@ class WorkflowContext(Generic[InputT, StateT]):
 
         # Skip any step events first
         self._skip_step_events()
-        
+
         scheduled_event = self._match_event("TIMER_SCHEDULED")
 
         if scheduled_event:

loom_core-1.0.0/loom/core/graph.py

@@ -0,0 +1,360 @@
+import ast
+import inspect
+from typing import Dict, List, Any, Optional
+
+from ..schemas.graph import WorkflowDefinitionGraph, GraphNode, GraphEdge
+from .workflow import Workflow
+
+
+class WorkflowAnalyzer:
+    """Analyzes workflow definitions to extract structure and dependencies."""
+    
+    @staticmethod
+    def analyze_workflow_definition(workflow_class: type[Workflow]) -> WorkflowDefinitionGraph:
+        """Analyze workflow class to generate definition graph.
+        
+        Args:
+            workflow_class: The workflow class to analyze
+            
+        Returns:
+            WorkflowDefinitionGraph: Graph representation of the workflow structure
+        """
+        graph = WorkflowDefinitionGraph(
+            nodes=[],
+            edges=[],
+            metadata={
+                "workflow_name": getattr(workflow_class, "_workflow_name", workflow_class.__name__),
+                "workflow_version": getattr(workflow_class, "_workflow_version", "1.0.0"),
+                "workflow_description": getattr(workflow_class, "_workflow_description", ""),
+            }
+        )
+        
+        # Get compiled workflow to extract step information
+        try:
+            workflow_instance = workflow_class()
+            compiled = workflow_instance._compile_instance()
+        except Exception as e:
+            raise ValueError(f"Failed to compile workflow {workflow_class.__name__}: {e}")
+        
+        previous_step_id = None
+        
+        # Analyze each step
+        for step_info in compiled.steps:
+            step_id = f"step_{step_info['name']}"
+            
+            # Add step node
+            step_node = GraphNode(
+                id=step_id,
+                type="step",
+                label=step_info["name"],
+                metadata={
+                    "description": step_info["description"],
+                    "function": step_info["fn"]
+                }
+            )
+            graph.nodes.append(step_node)
+            
+            # Add sequence edge from previous step
+            if previous_step_id:
+                sequence_edge = GraphEdge(**{
+                    "from": previous_step_id,
+                    "to": step_id,
+                    "type": "sequence",
+                    "label": "then"
+                })
+                graph.edges.append(sequence_edge)
+            
+            # Analyze step method for dependencies
+            step_method = getattr(workflow_instance, step_info["fn"])
+            dependencies = WorkflowAnalyzer._analyze_step_dependencies(step_method)
+            
+            # Add activity nodes and edges
+            for activity_name in dependencies.get("activities", []):
+                activity_id = f"activity_{activity_name}_{step_info['name']}"
+                activity_node = GraphNode(
+                    id=activity_id,
+                    type="activity",
+                    label=activity_name,
+                    metadata={"called_from_step": step_info["name"]}
+                )
+                graph.nodes.append(activity_node)
+                
+                activity_edge = GraphEdge(**{
+                    "from": step_id,
+                    "to": activity_id,
+                    "type": "calls",
+                    "label": "executes"
+                })
+                graph.edges.append(activity_edge)
+            
+            # Add timer nodes
+            for i, timer_info in enumerate(dependencies.get("timers", [])):
+                timer_id = f"timer_{step_info['name']}_{i}"
+                timer_node = GraphNode(
+                    id=timer_id,
+                    type="timer",
+                    label=f"Sleep {timer_info}",
+                    metadata={"step": step_info["name"]}
+                )
+                graph.nodes.append(timer_node)
+                
+                timer_edge = GraphEdge(**{
+                    "from": step_id,
+                    "to": timer_id,
+                    "type": "waits",
+                    "label": "pauses for"
+                })
+                graph.edges.append(timer_edge)
+            
+            # Add state dependency edges
+            for state_key in dependencies.get("state_reads", []):
+                state_id = f"state_{state_key}"
+                
+                # Add state node if not exists
+                if not any(n.id == state_id for n in graph.nodes):
+                    state_node = GraphNode(
+                        id=state_id,
+                        type="state",
+                        label=f"state.{state_key}",
+                        metadata={"key": state_key}
+                    )
+                    graph.nodes.append(state_node)
+                
+                read_edge = GraphEdge(**{
+                    "from": state_id,
+                    "to": step_id,
+                    "type": "reads",
+                    "label": "reads"
+                })
+                graph.edges.append(read_edge)
+            
+            for state_key in dependencies.get("state_writes", []):
+                state_id = f"state_{state_key}"
+                
+                # Add state node if not exists  
+                if not any(n.id == state_id for n in graph.nodes):
+                    state_node = GraphNode(
+                        id=state_id,
+                        type="state",
+                        label=f"state.{state_key}",
+                        metadata={"key": state_key}
+                    )
+                    graph.nodes.append(state_node)
+                    
+                write_edge = GraphEdge(**{
+                    "from": step_id,
+                    "to": state_id,
+                    "type": "writes",
+                    "label": "updates"
+                })
+                graph.edges.append(write_edge)
+            
+            previous_step_id = step_id
+        
+        return graph
+    
+    @staticmethod
+    def _analyze_step_dependencies(method) -> Dict[str, List[str]]:
+        """Analyze step method source code to find dependencies.
+        
+        Args:
+            method: The step method to analyze
+            
+        Returns:
+            Dict containing lists of activities, timers, state reads/writes
+        """
+        dependencies = {
+            "activities": [],
+            "timers": [],
+            "state_reads": [],
+            "state_writes": []
+        }
+        
+        try:
+            # Get source code and parse AST
+            source = inspect.getsource(method)
+            
+            # Remove common indentation to make it parseable
+            import textwrap
+            source = textwrap.dedent(source)
+            
+            # Remove decorators - find the first 'async def' or 'def' line
+            lines = source.split('\n')
+            def_line_idx = None
+            for i, line in enumerate(lines):
+                if 'def ' in line and ('async def' in line or line.strip().startswith('def')):
+                    def_line_idx = i
+                    break
+            
+            if def_line_idx is not None:
+                # Keep only the function definition and body
+                source = '\n'.join(lines[def_line_idx:])
+            
+            tree = ast.parse(source)
+            
+            class DependencyVisitor(ast.NodeVisitor):
+                def visit_Call(self, node):
+                    # Only handle non-awaited calls here
+                    # Look for ctx.state.get() calls (non-awaited)
+                    if (isinstance(node.func, ast.Attribute) and
+                        isinstance(node.func.value, ast.Attribute) and
+                        isinstance(node.func.value.value, ast.Name) and
+                        node.func.value.value.id == "ctx" and
+                        node.func.value.attr == "state" and
+                        node.func.attr == "get"):
+                        
+                        # Extract state key from first argument
+                        if (node.args and isinstance(node.args[0], ast.Constant)):
+                            state_key = node.args[0].value
+                            dependencies["state_reads"].append(state_key)
+                    
+                    self.generic_visit(node)
+                    
+                def visit_Await(self, node):
+                    # Handle await ctx.activity(), await ctx.sleep(), await ctx.state.set()
+                    if isinstance(node.value, ast.Call):
+                        call_node = node.value
+                        
+                        # Check for await ctx.activity() 
+                        if (isinstance(call_node.func, ast.Attribute) and
+                            isinstance(call_node.func.value, ast.Name) and
+                            call_node.func.value.id == "ctx" and
+                            call_node.func.attr == "activity"):
+                            
+                            if call_node.args and isinstance(call_node.args[0], ast.Name):
+                                activity_name = call_node.args[0].id
+                                dependencies["activities"].append(activity_name)
+                        
+                        # Check for await ctx.sleep()
+                        elif (isinstance(call_node.func, ast.Attribute) and
+                              isinstance(call_node.func.value, ast.Name) and
+                              call_node.func.value.id == "ctx" and
+                              call_node.func.attr == "sleep"):
+                            dependencies["timers"].append("sleep")
+                        
+                        # Check for await ctx.state.set()
+                        elif (isinstance(call_node.func, ast.Attribute) and
+                              isinstance(call_node.func.value, ast.Attribute) and
+                              isinstance(call_node.func.value.value, ast.Name) and
+                              call_node.func.value.value.id == "ctx" and
+                              call_node.func.value.attr == "state" and
+                              call_node.func.attr == "set"):
+                            
+                            if (call_node.args and isinstance(call_node.args[0], ast.Constant)):
+                                state_key = call_node.args[0].value
+                                dependencies["state_writes"].append(state_key)
+                        
+                        # Check for await ctx.state.update()
+                        elif (isinstance(call_node.func, ast.Attribute) and
+                              isinstance(call_node.func.value, ast.Attribute) and
+                              isinstance(call_node.func.value.value, ast.Name) and
+                              call_node.func.value.value.id == "ctx" and
+                              call_node.func.value.attr == "state" and
+                              call_node.func.attr == "update"):
+                            dependencies["state_writes"].append("bulk_update")
+                    
+                    self.generic_visit(node)
+                    
+                def visit_Attribute(self, node):
+                    # Look for ctx.state.get('key') reads (non-await calls)  
+                    if (isinstance(node.value, ast.Attribute) and
+                        isinstance(node.value.value, ast.Name) and
+                        node.value.value.id == "ctx" and
+                        node.value.attr == "state" and
+                        node.attr == "get"):
+                        
+                        # This is a ctx.state.get access - we need to find the parent call
+                        # For now, we'll skip this complex case
+                        pass
+                    
+                    self.generic_visit(node)
+            
+            visitor = DependencyVisitor()
+            visitor.visit(tree)
+            
+        except Exception as e:
+            # If source analysis fails, return empty dependencies
+            print(f"Warning: Could not analyze step method: {e}")
+        
+        return dependencies
+
+
+def generate_mermaid_graph(graph: WorkflowDefinitionGraph) -> str:
+    """Generate Mermaid diagram from definition graph.
+    
+    Args:
+        graph: The workflow definition graph
+        
+    Returns:
+        String containing Mermaid diagram syntax
+    """
+    lines = ["graph TD"]
+    
+    # Add nodes with appropriate shapes
+    for node in graph.nodes:
+        if node.type == "step":
+            lines.append(f'    {node.id}["{node.label}"]')
+        elif node.type == "activity":
+            lines.append(f'    {node.id}("{node.label}")')
+        elif node.type == "timer":
+            lines.append(f'    {node.id}[["{node.label}"]]')
+        elif node.type == "state":
+            lines.append(f'    {node.id}{{{node.label}}}')
+    
+    # Add edges with appropriate styles
+    for edge in graph.edges:
+        if edge.type == "sequence":
+            lines.append(f'    {edge.from_node} --> {edge.to_node}')
+        elif edge.type == "calls":
+            lines.append(f'    {edge.from_node} --> {edge.to_node}')
+        elif edge.type == "reads":
+            lines.append(f'    {edge.from_node} -.-> {edge.to_node}')
+        elif edge.type == "writes":
+            lines.append(f'    {edge.from_node} --> {edge.to_node}')
+        elif edge.type == "waits":
+            lines.append(f'    {edge.from_node} -.-> {edge.to_node}')
+    
+    return "\n".join(lines)
+
+
+def generate_graphviz_dot(graph: WorkflowDefinitionGraph) -> str:
+    """Generate GraphViz DOT format from definition graph.
+    
+    Args:
+        graph: The workflow definition graph
+        
+    Returns:
+        String containing DOT format graph
+    """
+    lines = [
+        "digraph workflow {",
+        "  rankdir=TD;",
+        "  node [fontname=\"Arial\"]"
+    ]
+    
+    # Add nodes with shapes and colors
+    for node in graph.nodes:
+        if node.type == "step":
+            lines.append(f'  {node.id} [label="{node.label}" shape=box style=filled fillcolor=lightblue];')
+        elif node.type == "activity":
+            lines.append(f'  {node.id} [label="{node.label}" shape=ellipse style=filled fillcolor=lightgreen];')
+        elif node.type == "timer":
+            lines.append(f'  {node.id} [label="{node.label}" shape=diamond style=filled fillcolor=lightyellow];')
+        elif node.type == "state":
+            lines.append(f'  {node.id} [label="{node.label}" shape=hexagon style=filled fillcolor=lightcoral];')
+    
+    # Add edges with styles
+    for edge in graph.edges:
+        if edge.type == "sequence":
+            lines.append(f'  {edge.from_node} -> {edge.to_node} [style=solid];')
+        elif edge.type == "calls":
+            lines.append(f'  {edge.from_node} -> {edge.to_node} [style=solid];')
+        elif edge.type == "reads":
+            lines.append(f'  {edge.from_node} -> {edge.to_node} [style=dashed];')
+        elif edge.type == "writes":
+            lines.append(f'  {edge.from_node} -> {edge.to_node} [style=solid];')
+        elif edge.type == "waits":
+            lines.append(f'  {edge.from_node} -> {edge.to_node} [style=dotted];')
+    
+    lines.append("}")
+    return "\n".join(lines)

{loom_core-0.2.0 → loom_core-1.0.0}/loom/database/db.py

@@ -346,7 +346,11 @@ class Database(Generic[InputT, StateT]):
         )
 
     async def workflow_failed(
-        self, workflow_id: str, error: str, task_id: str|None = None, task_kind: str|None = None
+        self,
+        workflow_id: str,
+        error: str,
+        task_id: str | None = None,
+        task_kind: str | None = None,
     ) -> None:
         """Mark a workflow as failed due to an unhandled exception.
 
@@ -436,9 +440,10 @@ class Database(Generic[InputT, StateT]):
             INSERT INTO events (workflow_id, type, payload)
             VALUES (?, 'WORKFLOW_COMPLETED', ?)
             """,
-            (workflow_id, json.dumps({
-                "completed_at": datetime.now(timezone.utc).isoformat()
-            })),
+            (
+                workflow_id,
+                json.dumps({"completed_at": datetime.now(timezone.utc).isoformat()}),
+            ),
         )
 
         # Update workflow status

loom_core-1.0.0/loom/schemas/graph.py

@@ -0,0 +1,168 @@
+from typing import Dict, List, Any
+from pydantic import BaseModel, Field
+
+
+class GraphNode(BaseModel):
+    """Represents a node in the workflow definition graph."""
+    
+    id: str = Field(
+        ...,
+        description="Unique identifier for the node",
+        examples=["step_process_payment", "activity_send_email", "state_user_id"]
+    )
+    type: str = Field(
+        ...,
+        description="Type of the node",
+        examples=["step", "activity", "timer", "state"]
+    )
+    label: str = Field(
+        ...,
+        description="Display label for the node",
+        examples=["Process Payment", "send_email", "Sleep 5s", "state.user_id"]
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional metadata about the node",
+        examples=[
+            {"description": "Processes user payment", "function": "process_payment_step"},
+            {"retry_count": 3, "timeout_seconds": 30},
+            {"key": "user_id", "type": "string"}
+        ]
+    )
+
+
+class GraphEdge(BaseModel):
+    """Represents an edge (connection) in the workflow definition graph."""
+    
+    from_node: str = Field(
+        ...,
+        alias="from",
+        description="Source node ID",
+        examples=["step_validate_input", "state_user_data"]
+    )
+    to_node: str = Field(
+        ..., 
+        alias="to",
+        description="Target node ID",
+        examples=["step_process_payment", "activity_send_notification"]
+    )
+    type: str = Field(
+        ...,
+        description="Type of relationship",
+        examples=["sequence", "calls", "reads", "writes", "waits"]
+    )
+    label: str = Field(
+        default="",
+        description="Display label for the edge",
+        examples=["then", "executes", "reads", "updates", "pauses for"]
+    )
+
+
+class WorkflowDefinitionGraph(BaseModel):
+    """Complete workflow definition graph structure."""
+    
+    nodes: List[GraphNode] = Field(
+        ...,
+        description="List of nodes in the graph"
+    )
+    edges: List[GraphEdge] = Field(
+        ...,
+        description="List of edges connecting the nodes"
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Workflow-level metadata",
+        examples=[
+            {
+                "workflow_name": "OrderProcessingWorkflow",
+                "workflow_version": "1.2.0",
+                "workflow_description": "Processes customer orders with payment and shipping"
+            }
+        ]
+    )
+    
+    class Config:
+        json_encoders = {
+            # Add any custom encoders if needed
+        }
+        json_schema_extra = {
+            "examples": [
+                {
+                    "nodes": [
+                        {
+                            "id": "step_validate_order",
+                            "type": "step", 
+                            "label": "Validate Order",
+                            "metadata": {
+                                "description": "Validates order data and inventory",
+                                "function": "validate_order_step"
+                            }
+                        },
+                        {
+                            "id": "activity_check_inventory",
+                            "type": "activity",
+                            "label": "check_inventory",
+                            "metadata": {
+                                "called_from_step": "validate_order",
+                                "retry_count": 3
+                            }
+                        },
+                        {
+                            "id": "state_order_valid",
+                            "type": "state", 
+                            "label": "state.order_valid",
+                            "metadata": {
+                                "key": "order_valid"
+                            }
+                        }
+                    ],
+                    "edges": [
+                        {
+                            "from": "step_validate_order",
+                            "to": "activity_check_inventory", 
+                            "type": "calls",
+                            "label": "executes"
+                        },
+                        {
+                            "from": "step_validate_order",
+                            "to": "state_order_valid",
+                            "type": "writes",
+                            "label": "updates"
+                        }
+                    ],
+                    "metadata": {
+                        "workflow_name": "OrderProcessingWorkflow",
+                        "workflow_version": "1.0.0",
+                        "workflow_description": "Handles order processing with validation and payment"
+                    }
+                }
+            ]
+        }
+
+
+class GraphFormat(BaseModel):
+    """Supported graph output formats."""
+    
+    format: str = Field(
+        ...,
+        description="Output format for the graph",
+        examples=["mermaid", "dot", "json"]
+    )
+    
+
+class GraphResponse(BaseModel):
+    """Response containing the generated graph."""
+    
+    format: str = Field(
+        ...,
+        description="Format of the generated graph",
+        examples=["mermaid", "dot", "json"]
+    )
+    content: str = Field(
+        ...,
+        description="Generated graph content in the specified format"
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional metadata about the graph generation"
+    )

{loom_core-0.2.0 → loom_core-1.0.0}/loom_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-core
-Version: 0.2.0
+Version: 1.0.0
 Summary: Durable workflow orchestration engine for Python
 Home-page: https://github.com/satadeep3927/loom
 Author: Satadeep Dasgupta
@@ -23,7 +23,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiosqlite>=0.19.0
 Requires-Dist: click>=8.0.0
-Requires-Dist: rich>=13.0.0
+Requires-Dist: rich>=14.3.1
+Requires-Dist: fastapi[standard]>=0.95.0
+Requires-Dist: uvicorn[standard]>=0.22.0
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

{loom_core-0.2.0 → loom_core-1.0.0}/loom_core.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ README.md
 pyproject.toml
 setup.py
 loom/__init__.py
+loom/__main__.py
 loom/cli/__init__.py
 loom/cli/cli.py
 loom/common/activity.py
@@ -15,6 +16,7 @@ loom/core/__init__.py
 loom/core/compiled.py
 loom/core/context.py
 loom/core/engine.py
+loom/core/graph.py
 loom/core/handle.py
 loom/core/logger.py
 loom/core/runner.py
@@ -46,6 +48,7 @@ loom/schemas/__init__.py
 loom/schemas/activity.py
 loom/schemas/database.py
 loom/schemas/events.py
+loom/schemas/graph.py
 loom/schemas/tasks.py
 loom/schemas/workflow.py
 loom_core.egg-info/PKG-INFO

{loom_core-0.2.0 → loom_core-1.0.0}/loom_core.egg-info/requires.txt

@@ -1,6 +1,9 @@
 aiosqlite>=0.19.0
 click>=8.0.0
-rich>=13.0.0
+rich>=14.3.1
+fastapi[standard]>=0.95.0
+uvicorn[standard]>=0.22.0
+pydantic>=2.0.0
 
 [dev]
 pytest>=7.0.0

{loom_core-0.2.0 → loom_core-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loom-core"
-version = "0.2.0"
+version = "1.0.0"
 description = "Durable workflow orchestration engine for Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,7 +26,10 @@ classifiers = [
 dependencies = [
     "aiosqlite>=0.19.0",
     "click>=8.0.0",
-    "rich>=13.0.0",
+    "rich>=14.3.1",
+    "fastapi[standard]>=0.95.0",
+    "uvicorn[standard]>=0.22.0",
+    "pydantic>=2.0.0",
 ]
 
 [project.optional-dependencies]
@@ -83,6 +86,6 @@ addopts = "-v --cov=loom --cov-report=term-missing"
 [tool.ruff]
 line-length = 88
 target-version = "py312"
-select = ["E", "F", "I", "N", "W"]
-ignore = ["E501"]
+lint.select = ["E", "F", "I", "N", "W"]
+lint.ignore = ["E501", "F405"]
 exclude = ["tests", "examples", "__pycache__"]