splox 0.2.3__tar.gz → 0.2.4__tar.gz

{splox-0.2.3 → splox-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splox
-Version: 0.2.3
+Version: 0.2.4
 Summary: Official Python SDK for the Splox API — run workflows, manage chats, and monitor execution
 Project-URL: Homepage, https://splox.io
 Project-URL: Documentation, https://docs.splox.io

{splox-0.2.3 → splox-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "splox"
-version = "0.2.3"
+version = "0.2.4"
 description = "Official Python SDK for the Splox API — run workflows, manage chats, and monitor execution"
 readme = "README.md"
 license = "MIT"

{splox-0.2.3 → splox-0.2.4}/src/splox/__init__.py

@@ -4,8 +4,11 @@ from splox._client import AsyncSploxClient, SploxClient
 from splox._ids import decode_id, encode_id
 from splox._models import (
     ContentPart,
-    Edge,
-    EntryNodesResponse,
+    GraphEdge,
+    GraphEdgeInput,
+    GraphNode,
+    GraphNodeInput,
+    GraphPosition,
     Interaction,
     InteractionPage,
     InteractionResponse,
@@ -17,12 +20,10 @@ from splox._models import (
     MCPServerToolsResponse,
     Message,
     MessagePage,
-    Node,
     NodeExecution,
     Output,
     OutputPage,
     PageInfo,
-    Pagination,
     RunEvent,
     RunEventPage,
     RunFailure,
@@ -32,12 +33,11 @@ from splox._models import (
     RunUsage,
     SSEEvent,
     Workflow,
-    WorkflowFull,
-    WorkflowListResponse,
+    WorkflowGraph,
+    WorkflowGraphUpdate,
+    WorkflowPage,
     WorkflowRequest,
     WorkflowRequestFile,
-    WorkflowVersion,
-    WorkflowVersionListResponse,
     TERMINAL_RUN_STATUSES,
 )
 from splox._mcp import generate_connection_token, generate_connection_link
@@ -69,30 +69,31 @@ __all__ = [
     "TERMINAL_RUN_STATUSES",
     "encode_id",
     "decode_id",
-    # v1 resources (workflows CRUD, chats, billing, memory, MCP, LLM)
-    "Edge",
+    # v2 workflows (graph API)
+    "Workflow",
+    "WorkflowPage",
+    "WorkflowGraph",
+    "WorkflowGraphUpdate",
+    "GraphPosition",
+    "GraphNode",
+    "GraphEdge",
+    "GraphNodeInput",
+    "GraphEdgeInput",
+    # v1 resources (MCP, legacy stream events)
     "MCPCatalogItem",
     "MCPCatalogListResponse",
     "MCPConnection",
     "MCPConnectionListResponse",
     "MCPServerToolOption",
     "MCPServerToolsResponse",
-    "Node",
     "NodeExecution",
-    "Pagination",
     "SSEEvent",
-    "EntryNodesResponse",
-    "Workflow",
-    "WorkflowFull",
-    "WorkflowListResponse",
     "WorkflowRequest",
     "WorkflowRequestFile",
-    "WorkflowVersion",
-    "WorkflowVersionListResponse",
     "generate_connection_token",
     "generate_connection_link",
     "notify",
     "async_notify",
 ]
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{splox-0.2.3 → splox-0.2.4}/src/splox/_client.py

@@ -5,14 +5,12 @@ from __future__ import annotations
 import os
 from typing import Optional, Any
 
-from splox._resources import (
-    AsyncWorkflows,
-    Workflows,
-)
+from splox._resources import async_notify, notify
 from splox._interactions import AsyncInteractions, Interactions
 from splox._mcp import AsyncMCP, MCP
 from splox._runs import AsyncRuns, Runs
 from splox._transport import DEFAULT_TIMEOUT, AsyncTransport, SyncTransport
+from splox._workflows import AsyncWorkflows, Workflows
 
 
 class SploxClient:

{splox-0.2.3 → splox-0.2.4}/src/splox/_models.py

@@ -101,206 +101,6 @@ class NodeExecution:
         )
 
 
-@dataclass
-class Pagination:
-    """Cursor-based pagination info."""
-
-    limit: int
-    next_cursor: Optional[str] = None
-    has_more: bool = False
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> Pagination:
-        return cls(
-            limit=data["limit"],
-            next_cursor=data.get("next_cursor"),
-            has_more=data.get("has_more", False),
-        )
-
-
-# --- Workflow / Version / Node / Edge models ---
-
-
-@dataclass
-class WorkflowVersion:
-    """Represents a specific version of a workflow."""
-
-    id: str
-    workflow_id: str
-    version_number: int
-    name: str
-    status: str
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-    description: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> WorkflowVersion:
-        return cls(
-            id=data["id"],
-            workflow_id=data["workflow_id"],
-            version_number=data["version_number"],
-            name=data["name"],
-            status=data["status"],
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
-            description=data.get("description"),
-            metadata=data.get("metadata"),
-        )
-
-
-@dataclass
-class Workflow:
-    """Represents a workflow."""
-
-    id: str
-    user_id: str
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-    latest_version: Optional[WorkflowVersion] = None
-    is_public: Optional[bool] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> Workflow:
-        lv = None
-        if data.get("latest_version"):
-            lv = WorkflowVersion.from_dict(data["latest_version"])
-        return cls(
-            id=data["id"],
-            user_id=data["user_id"],
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
-            latest_version=lv,
-            is_public=data.get("is_public"),
-        )
-
-
-@dataclass
-class Node:
-    """Represents a node in a workflow."""
-
-    id: str
-    workflow_version_id: str
-    node_type: str
-    label: str
-    pos_x: Optional[float] = None
-    pos_y: Optional[float] = None
-    parent_id: Optional[str] = None
-    extent: Optional[str] = None
-    data: Optional[Dict[str, Any]] = None
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> Node:
-        return cls(
-            id=data["id"],
-            workflow_version_id=data["workflow_version_id"],
-            node_type=data["node_type"],
-            label=data["label"],
-            pos_x=data.get("pos_x"),
-            pos_y=data.get("pos_y"),
-            parent_id=data.get("parent_id"),
-            extent=data.get("extent"),
-            data=data.get("data"),
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
-        )
-
-
-@dataclass
-class Edge:
-    """Represents an edge (connection) between nodes."""
-
-    id: str
-    workflow_version_id: str
-    source: str
-    target: str
-    edge_type: str
-    source_handle: Optional[str] = None
-    data: Optional[Dict[str, Any]] = None
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> Edge:
-        return cls(
-            id=data["id"],
-            workflow_version_id=data["workflow_version_id"],
-            source=data["source"],
-            target=data["target"],
-            edge_type=data["edge_type"],
-            source_handle=data.get("source_handle"),
-            data=data.get("data"),
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
-        )
-
-
-@dataclass
-class WorkflowFull:
-    """Full workflow with version, nodes, and edges."""
-
-    workflow: Workflow
-    workflow_version: WorkflowVersion
-    nodes: List[Node] = field(default_factory=list)
-    edges: List[Edge] = field(default_factory=list)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> WorkflowFull:
-        return cls(
-            workflow=Workflow.from_dict(data["workflow"]),
-            workflow_version=WorkflowVersion.from_dict(data["workflow_version"]),
-            nodes=[Node.from_dict(n) for n in (data.get("nodes") or [])],
-            edges=[Edge.from_dict(e) for e in (data.get("edges") or [])],
-        )
-
-
-# --- Response wrappers ---
-
-
-@dataclass
-class WorkflowListResponse:
-    """Response from listing workflows."""
-
-    workflows: List[Workflow]
-    pagination: Pagination
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> WorkflowListResponse:
-        return cls(
-            workflows=[Workflow.from_dict(w) for w in (data.get("workflows") or [])],
-            pagination=Pagination.from_dict(data["pagination"]),
-        )
-
-
-@dataclass
-class EntryNodesResponse:
-    """Response from getting entry nodes."""
-
-    nodes: List[Node]
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> EntryNodesResponse:
-        return cls(
-            nodes=[Node.from_dict(n) for n in (data.get("nodes") or [])],
-        )
-
-
-@dataclass
-class WorkflowVersionListResponse:
-    """Response from listing workflow versions."""
-
-    versions: List[WorkflowVersion]
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> WorkflowVersionListResponse:
-        return cls(
-            versions=[WorkflowVersion.from_dict(v) for v in (data.get("versions") or [])],
-        )
-
-
 @dataclass
 class SSEEvent:
     """A single Server-Sent Event from a listen stream.
@@ -981,3 +781,197 @@ class InteractionPage:
             data=[Interaction.from_dict(i) for i in (raw.get("data") or [])],
             page=PageInfo.from_dict(raw.get("page") or {}),
         )
+
+
+# ---------------------------------------------------------------------------
+# v2 workflows (graph API)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Workflow:
+    """A v2 workflow (management surface; graphs live on versions)."""
+
+    id: str
+    name: str
+    description: str = ""
+    created_at: str = ""
+    updated_at: str = ""
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> Workflow:
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            description=data.get("description") or "",
+            created_at=data.get("created_at", ""),
+            updated_at=data.get("updated_at", ""),
+        )
+
+
+@dataclass
+class WorkflowPage:
+    """One page of workflows (newest first)."""
+
+    data: List[Workflow]
+    page: PageInfo
+
+    @classmethod
+    def from_dict(cls, raw: Dict[str, Any]) -> WorkflowPage:
+        return cls(
+            data=[Workflow.from_dict(w) for w in (raw.get("data") or [])],
+            page=PageInfo.from_dict(raw.get("page") or {}),
+        )
+
+
+@dataclass
+class GraphPosition:
+    """Canvas position of a graph node."""
+
+    x: float = 0.0
+    y: float = 0.0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> GraphPosition:
+        return cls(x=data.get("x", 0.0), y=data.get("y", 0.0))
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"x": self.x, "y": self.y}
+
+
+@dataclass
+class GraphNode:
+    """A node of a workflow version's graph.
+
+    ``id`` is the server-assigned node UUID (graph-local, not an API resource
+    id); ``data`` is the raw node configuration document exactly as stored.
+    """
+
+    id: str
+    type: str
+    label: str = ""
+    position: GraphPosition = field(default_factory=GraphPosition)
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> GraphNode:
+        return cls(
+            id=data["id"],
+            type=data["type"],
+            label=data.get("label", ""),
+            position=GraphPosition.from_dict(data.get("position") or {}),
+            data=data.get("data") or {},
+        )
+
+
+@dataclass
+class GraphEdge:
+    """An edge of a workflow version's graph.
+
+    ``edge_type``: ``parallel`` edges drive execution flow; ``tool`` edges
+    attach tool / sub-agent nodes to an agent; ``error`` edges route
+    failures.
+    """
+
+    id: str
+    source: str
+    target: str
+    edge_type: str
+    source_handle: Optional[str] = None
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> GraphEdge:
+        return cls(
+            id=data["id"],
+            source=data["source"],
+            target=data["target"],
+            edge_type=data["edge_type"],
+            source_handle=data.get("source_handle"),
+            data=data.get("data") or {},
+        )
+
+
+@dataclass
+class WorkflowGraph:
+    """The graph of a workflow's presented (active) version."""
+
+    workflow_version: str
+    nodes: List[GraphNode] = field(default_factory=list)
+    edges: List[GraphEdge] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> WorkflowGraph:
+        return cls(
+            workflow_version=data["workflow_version"],
+            nodes=[GraphNode.from_dict(n) for n in (data.get("nodes") or [])],
+            edges=[GraphEdge.from_dict(e) for e in (data.get("edges") or [])],
+        )
+
+
+@dataclass
+class GraphNodeInput:
+    """Node input for ``workflows.set_graph``.
+
+    ``id`` is a client-chosen key, unique within the request; edges reference
+    nodes by these keys. ``data`` omitted means the server defaults for the
+    node type.
+    """
+
+    type: str
+    id: Optional[str] = None
+    label: Optional[str] = None
+    position: Optional[GraphPosition] = None
+    data: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"type": self.type}
+        if self.id is not None:
+            d["id"] = self.id
+        if self.label is not None:
+            d["label"] = self.label
+        if self.position is not None:
+            d["position"] = self.position.to_dict()
+        if self.data is not None:
+            d["data"] = self.data
+        return d
+
+
+@dataclass
+class GraphEdgeInput:
+    """Edge input for ``workflows.set_graph``.
+
+    ``source``/``target`` are client node keys (``nodes[].id``). ``edge_type``
+    defaults to ``tool`` when the target is a tool node, else ``parallel``.
+    """
+
+    source: str
+    target: str
+    edge_type: Optional[str] = None
+    source_handle: Optional[str] = None
+    data: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"source": self.source, "target": self.target}
+        if self.edge_type is not None:
+            d["edge_type"] = self.edge_type
+        if self.source_handle is not None:
+            d["source_handle"] = self.source_handle
+        if self.data is not None:
+            d["data"] = self.data
+        return d
+
+
+@dataclass
+class WorkflowGraphUpdate:
+    """Result of ``workflows.set_graph``: the new version and node id map."""
+
+    workflow_version: str
+    node_ids: Dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> WorkflowGraphUpdate:
+        return cls(
+            workflow_version=data["workflow_version"],
+            node_ids=data.get("node_ids") or {},
+        )

splox-0.2.4/src/splox/_resources.py

@@ -0,0 +1,42 @@
+"""Webhook notification helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def notify(webhook_url: str, data: Any) -> None:
+    """POST data to a webhook URL as JSON.
+
+    Args:
+        webhook_url: The URL to POST to.
+        data: Any JSON-serialisable payload.
+    """
+    import urllib.request, json as _json
+    body = _json.dumps(data).encode()
+    req = urllib.request.Request(
+        webhook_url,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=10):
+        pass
+
+
+async def async_notify(webhook_url: str, data: Any) -> None:
+    """Async POST data to a webhook URL as JSON.
+
+    Args:
+        webhook_url: The URL to POST to.
+        data: Any JSON-serialisable payload.
+    """
+    import json as _json
+    try:
+        import aiohttp
+        async with aiohttp.ClientSession() as session:
+            await session.post(webhook_url, json=data, timeout=aiohttp.ClientTimeout(total=10))
+    except ImportError:
+        import asyncio
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, notify, webhook_url, data)