noclick 0.1.0__tar.gz

noclick-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: noclick
+Version: 0.1.0
+Summary: Python SDK for NoClick workflow automation
+License: BUSL-1.1
+Project-URL: Homepage, https://docs.noclick.com/sdk/overview
+Project-URL: Documentation, https://docs.noclick.com/sdk/external-apps
+Project-URL: Repository, https://github.com/noclickapp/noclick
+Keywords: noclick,workflow,automation,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: python-socketio[asyncio_client]>=5.0
+Requires-Dist: aiohttp>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# noclick-sdk
+
+Python SDK for [NoClick](https://noclick.com) workflow automation. Build external applications that interact with NoClick workflows — read node outputs, trigger execution, manage state, and work with files and datasets.
+
+## Installation
+
+```bash
+pip install noclick
+```
+
+## Quick Start
+
+```python
+import asyncio
+from noclick import NoClickSDK
+
+async def main():
+    sdk = NoClickSDK(
+        url="https://api.noclick.io",
+        api_key="nk_live_...",
+        workflow_id="your-workflow-id",
+    )
+    await sdk.connect()
+
+    # List nodes
+    nodes = await sdk.nodes.list()
+    for node in nodes:
+        print(f"{node['label']} ({node['type']})")
+
+    # Read node output
+    output = await sdk.nodes.get_output("gmail-node-id")
+
+    # Run a node and get results
+    results = await sdk.execution.run_nodes_and_get_output(
+        ["data-fetcher"], ["formatter"]
+    )
+
+    # State management
+    await sdk.state.set("counter", 42)
+    val = await sdk.state.get("counter")
+
+    # Dataset CRUD
+    ds_id = await sdk.dataset.create("My Data")
+    await sdk.dataset.append_rows(ds_id, [{"name": "Alice", "score": 95}])
+
+    await sdk.disconnect()
+
+asyncio.run(main())
+```
+
+## API
+
+| Namespace | Methods |
+|-----------|---------|
+| `sdk.nodes` | `get_output`, `get_config`, `list` |
+| `sdk.execution` | `run_nodes_and_get_output`, `run_nodes_in_background`, `on_node_output`, `on_node_state` |
+| `sdk.state` | `get`, `set`, `delete`, `update`, `keys` |
+| `sdk.auth` | `list_credentials`, `has_credential`, `create_credential` |
+| `sdk.resources` | `upload`, `get_url`, `remove`, `list` |
+| `sdk.dataset` | `create`, `list`, `get_rows`, `append_rows`, `update_row`, `delete_rows` |
+| `sdk.workflow` | `get_info` |
+
+## Documentation
+
+Full documentation at [docs.noclick.com/sdk](https://docs.noclick.com/sdk/overview).
+
+## License
+
+[Business Source License 1.1](../LICENSE) — free to use with NoClick, converts to Apache 2.0 after 4 years.

noclick-0.1.0/README.md

@@ -0,0 +1,69 @@
+# noclick-sdk
+
+Python SDK for [NoClick](https://noclick.com) workflow automation. Build external applications that interact with NoClick workflows — read node outputs, trigger execution, manage state, and work with files and datasets.
+
+## Installation
+
+```bash
+pip install noclick
+```
+
+## Quick Start
+
+```python
+import asyncio
+from noclick import NoClickSDK
+
+async def main():
+    sdk = NoClickSDK(
+        url="https://api.noclick.io",
+        api_key="nk_live_...",
+        workflow_id="your-workflow-id",
+    )
+    await sdk.connect()
+
+    # List nodes
+    nodes = await sdk.nodes.list()
+    for node in nodes:
+        print(f"{node['label']} ({node['type']})")
+
+    # Read node output
+    output = await sdk.nodes.get_output("gmail-node-id")
+
+    # Run a node and get results
+    results = await sdk.execution.run_nodes_and_get_output(
+        ["data-fetcher"], ["formatter"]
+    )
+
+    # State management
+    await sdk.state.set("counter", 42)
+    val = await sdk.state.get("counter")
+
+    # Dataset CRUD
+    ds_id = await sdk.dataset.create("My Data")
+    await sdk.dataset.append_rows(ds_id, [{"name": "Alice", "score": 95}])
+
+    await sdk.disconnect()
+
+asyncio.run(main())
+```
+
+## API
+
+| Namespace | Methods |
+|-----------|---------|
+| `sdk.nodes` | `get_output`, `get_config`, `list` |
+| `sdk.execution` | `run_nodes_and_get_output`, `run_nodes_in_background`, `on_node_output`, `on_node_state` |
+| `sdk.state` | `get`, `set`, `delete`, `update`, `keys` |
+| `sdk.auth` | `list_credentials`, `has_credential`, `create_credential` |
+| `sdk.resources` | `upload`, `get_url`, `remove`, `list` |
+| `sdk.dataset` | `create`, `list`, `get_rows`, `append_rows`, `update_row`, `delete_rows` |
+| `sdk.workflow` | `get_info` |
+
+## Documentation
+
+Full documentation at [docs.noclick.com/sdk](https://docs.noclick.com/sdk/overview).
+
+## License
+
+[Business Source License 1.1](../LICENSE) — free to use with NoClick, converts to Apache 2.0 after 4 years.

noclick-0.1.0/noclick/__init__.py

@@ -0,0 +1,38 @@
+"""
+@noclick/sdk — Python SDK for NoClick workflow automation.
+
+Usage:
+    import asyncio
+    from noclick import NoClickSDK
+
+    async def main():
+        sdk = NoClickSDK(
+            url="http://localhost:8005",
+            api_key="nk_live_...",
+            workflow_id="..."
+        )
+        await sdk.connect()
+
+        # Read node output
+        output = await sdk.nodes.get_output("node-id")
+
+        # Run nodes
+        await sdk.execution.run_nodes_in_background(["node-id"])
+
+        # State CRUD
+        await sdk.state.set("counter", 42)
+        val = await sdk.state.get("counter")
+
+        # Dataset CRUD
+        resource_id = await sdk.dataset.create("My Data")
+        await sdk.dataset.append_rows(resource_id, [{"name": "Alice"}])
+
+        await sdk.disconnect()
+
+    asyncio.run(main())
+"""
+
+from noclick.client import NoClickSDK
+
+__all__ = ["NoClickSDK"]
+__version__ = "0.1.0"

noclick-0.1.0/noclick/client.py

@@ -0,0 +1,140 @@
+"""
+Main SDK client. Connects to NoClick backend via Socket.IO.
+"""
+
+import asyncio
+import json
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+import socketio
+
+from noclick.namespaces import (
+    NodesNamespace,
+    ExecutionNamespace,
+    StateNamespace,
+    AuthNamespace,
+    ResourcesNamespace,
+    DatasetNamespace,
+    WorkflowNamespace,
+)
+
+logger = logging.getLogger("noclick")
+
+DEFAULT_TIMEOUT = 30.0
+
+
+class NoClickSDK:
+    """
+    NoClick SDK client for Python.
+
+    Connects to the NoClick backend via Socket.IO using an API key.
+    Provides namespaced access to nodes, execution, state, auth, resources, and dataset APIs.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        api_key: str,
+        workflow_id: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ):
+        self.url = url
+        self.api_key = api_key
+        self.workflow_id = workflow_id
+        self.timeout = timeout
+
+        self._sio = socketio.AsyncClient(reconnection=True, reconnection_attempts=5)
+        self._pending: Dict[str, asyncio.Future] = {}
+        self._event_handlers: Dict[str, List[Any]] = {}
+
+        # Register response handler
+        self._sio.on("response", self._handle_response)
+        self._sio.on("workflow:node:output", self._handle_node_output)
+        self._sio.on("workflow:node:state", self._handle_node_state)
+        self._sio.on("workflow:complete", self._handle_workflow_complete)
+
+        # Namespaces
+        self.nodes = NodesNamespace(self)
+        self.execution = ExecutionNamespace(self)
+        self.state = StateNamespace(self)
+        self.auth = AuthNamespace(self)
+        self.resources = ResourcesNamespace(self)
+        self.dataset = DatasetNamespace(self)
+        self.workflow = WorkflowNamespace(self)
+
+    async def connect(self) -> None:
+        """Connect to the NoClick backend."""
+        logger.info(f"Connecting to {self.url}...")
+        await self._sio.connect(
+            self.url,
+            auth={"api_key": self.api_key},
+            transports=["websocket"],
+        )
+        logger.info("Connected")
+
+    async def disconnect(self) -> None:
+        """Disconnect from the backend."""
+        await self._sio.disconnect()
+        logger.info("Disconnected")
+
+    async def send_event(self, event: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Send a socket event and wait for a response.
+
+        Uses request_id correlation to match request → response.
+        """
+        request_id = f"py-{uuid.uuid4().hex[:12]}"
+        data["request_id"] = request_id
+
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending[request_id] = future
+
+        await self._sio.emit(event, data)
+
+        try:
+            result = await asyncio.wait_for(future, timeout=self.timeout)
+            return result
+        except asyncio.TimeoutError:
+            self._pending.pop(request_id, None)
+            raise TimeoutError(f"Request '{event}' timed out after {self.timeout}s")
+
+    async def send_event_no_wait(self, event: str, data: Dict[str, Any]) -> None:
+        """Send a socket event without waiting for a response."""
+        request_id = f"py-{uuid.uuid4().hex[:12]}"
+        data["request_id"] = request_id
+        await self._sio.emit(event, data)
+
+    def on_event(self, event: str, handler) -> None:
+        """Subscribe to push events."""
+        if event not in self._event_handlers:
+            self._event_handlers[event] = []
+        self._event_handlers[event].append(handler)
+
+    def _handle_response(self, data: Any) -> None:
+        """Handle response events, resolving pending futures."""
+        if not isinstance(data, dict):
+            return
+        request_id = data.get("request_id")
+        if not request_id:
+            return
+        future = self._pending.pop(request_id, None)
+        if future and not future.done():
+            if data.get("error"):
+                future.set_exception(Exception(str(data["error"])))
+            else:
+                future.set_result(data.get("data", data))
+
+    def _handle_node_output(self, data: Any) -> None:
+        for handler in self._event_handlers.get("node:output", []):
+            handler(data.get("node_id"), data.get("output"))
+
+    def _handle_node_state(self, data: Any) -> None:
+        for handler in self._event_handlers.get("node:state", []):
+            handler(data.get("node_id"), data.get("state"))
+
+    def _handle_workflow_complete(self, data: Any) -> None:
+        for handler in self._event_handlers.get("workflow:complete", []):
+            handler(data)

noclick-0.1.0/noclick/namespaces.py

@@ -0,0 +1,345 @@
+"""
+SDK namespace classes — thin wrappers that map to socket events.
+Each method mirrors the TypeScript SDK API.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from noclick.client import NoClickSDK
+
+
+class NodesNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def get_output(self, node_id: str) -> Any:
+        """Read a node's last output."""
+        resp = await self._sdk.send_event("workflow:get_node_outputs", {
+            "workflow_id": self._sdk.workflow_id,
+            "node_ids": [node_id],
+        })
+        outputs = resp.get("outputs", {})
+        node_output = outputs.get(node_id, {})
+        return node_output.get("output")
+
+    async def get_config(self, node_id: str) -> Dict[str, Any]:
+        """Read a node's config."""
+        resp = await self._sdk.send_event("workflow:get", {
+            "workflow_id": self._sdk.workflow_id,
+        })
+        workflow_data = resp.get("workflow", {}).get("workflow_data", {})
+        for node in workflow_data.get("nodes", []):
+            if node.get("id") == node_id:
+                return node.get("config", {})
+        raise ValueError(f"Node not found: {node_id}")
+
+    async def list(self) -> List[Dict[str, Any]]:
+        """List all nodes in the workflow."""
+        resp = await self._sdk.send_event("workflow:get", {
+            "workflow_id": self._sdk.workflow_id,
+        })
+        workflow_data = resp.get("workflow", {}).get("workflow_data", {})
+        return [
+            {
+                "id": n.get("id"),
+                "type": n.get("type"),
+                "label": n.get("config", {}).get("label", n.get("type", "")),
+                "hasOutput": False,  # Would need separate output check
+            }
+            for n in workflow_data.get("nodes", [])
+        ]
+
+
+class ExecutionNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def run_nodes_in_background(self, node_ids: List[str]) -> None:
+        """Run nodes without waiting for output."""
+        await self._sdk.send_event_no_wait("workflow:execute", {
+            "workflow_id": self._sdk.workflow_id,
+            "start_node_id": node_ids[0] if node_ids else None,
+        })
+
+    async def run_nodes_and_get_output(
+        self, run_nodes: List[str], target_nodes: List[str], timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """Run nodes and wait for target outputs."""
+        import asyncio
+
+        # Start execution
+        await self._sdk.send_event_no_wait("workflow:execute", {
+            "workflow_id": self._sdk.workflow_id,
+            "start_node_id": run_nodes[0] if run_nodes else None,
+        })
+
+        # Collect outputs via node:output events
+        results: Dict[str, Any] = {}
+        remaining = set(target_nodes)
+        done_event = asyncio.Event()
+
+        def on_output(node_id: str, output: Any):
+            if node_id in remaining:
+                results[node_id] = output
+                remaining.discard(node_id)
+                if not remaining:
+                    done_event.set()
+
+        self._sdk.on_event("node:output", on_output)
+        try:
+            await asyncio.wait_for(done_event.wait(), timeout=timeout or self._sdk.timeout)
+        finally:
+            if on_output in self._sdk._event_handlers.get("node:output", []):
+                self._sdk._event_handlers["node:output"].remove(on_output)
+
+        return results
+
+    def stop(self) -> None:
+        """Stop the current execution."""
+        # Fire and forget
+        import asyncio
+        asyncio.create_task(self._sdk.send_event_no_wait("workflow:stop", {
+            "workflow_id": self._sdk.workflow_id,
+        }))
+
+    def on_node_state(self, node_id: str, handler: Callable) -> None:
+        """Subscribe to a node's state changes."""
+        def filtered_handler(nid: str, state: str):
+            if nid == node_id:
+                handler(state)
+        self._sdk.on_event("node:state", filtered_handler)
+
+    def on_node_output(self, node_id: str, handler: Callable) -> None:
+        """Subscribe to a node's output changes."""
+        def filtered_handler(nid: str, output: Any):
+            if nid == node_id:
+                handler(output)
+        self._sdk.on_event("node:output", filtered_handler)
+
+
+class StateNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def get(self, key: str, node_id: Optional[str] = None) -> Any:
+        """Read a state value."""
+        resp = await self._sdk.send_event("workflow:load_node_state", {
+            "workflow_id": self._sdk.workflow_id,
+            "node_id": node_id,  # Handler resolves state-manager if None
+            "key": key,
+        })
+        return resp.get("state", {}).get(key)
+
+    async def set(self, key: str, value: Any, node_id: Optional[str] = None) -> None:
+        """Set a state value."""
+        await self._sdk.send_event("workflow:save_node_state", {
+            "workflow_id": self._sdk.workflow_id,
+            "node_id": node_id,
+            "state": {key: value},
+        })
+
+    async def delete(self, key: str, node_id: Optional[str] = None) -> None:
+        """Delete a state key."""
+        # Read current, remove key, write back
+        current = await self.get(key, node_id)
+        if current is not None:
+            await self._sdk.send_event("workflow:save_node_state", {
+                "workflow_id": self._sdk.workflow_id,
+                "node_id": node_id,
+                "state": {key: None},  # Convention: None = delete
+            })
+
+    async def update(self, key: str, updater: Callable, node_id: Optional[str] = None) -> None:
+        """Update a state value with a function."""
+        current = await self.get(key, node_id)
+        new_value = updater(current)
+        await self.set(key, new_value, node_id)
+
+    async def keys(self, node_id: Optional[str] = None) -> List[str]:
+        """List available state keys."""
+        resp = await self._sdk.send_event("workflow:load_node_state", {
+            "workflow_id": self._sdk.workflow_id,
+            "node_id": node_id,
+        })
+        state_data = resp.get("state", {})
+        return list(state_data.keys()) if isinstance(state_data, dict) else []
+
+
+class AuthNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def list_credentials(self) -> List[Dict[str, str]]:
+        """List available credentials."""
+        resp = await self._sdk.send_event("credential:list", {})
+        return [
+            {"id": c["id"], "type": c.get("credential_type", ""), "name": c.get("name", "")}
+            for c in resp.get("credentials", [])
+        ]
+
+    async def has_credential(self, credential_type: str) -> bool:
+        """Check if a credential of the given type exists."""
+        creds = await self.list_credentials()
+        return any(c["type"] == credential_type for c in creds)
+
+    async def create_credential(
+        self, credential_type: str, data: Dict[str, Any], name: Optional[str] = None
+    ) -> Dict[str, str]:
+        """Create a non-OAuth credential (API key, token, etc)."""
+        resp = await self._sdk.send_event("credential:create", {
+            "name": name or credential_type,
+            "credential_type": credential_type,
+            "credential_data": data,
+            "metadata": {},
+        })
+        cred = resp.get("credential", {})
+        return {"id": cred.get("id", ""), "type": credential_type, "name": cred.get("name", "")}
+
+
+class ResourcesNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def upload(self, name: str, mime_type: str, size_bytes: int, resource_type: str = "file"):
+        """Create a resource and get a presigned upload URL."""
+        create_resp = await self._sdk.send_event("resource:create", {
+            "workflow_id": self._sdk.workflow_id,
+            "resource_type": resource_type,
+            "name": name,
+            "mime_type": mime_type,
+            "size_bytes": size_bytes,
+        })
+        resource = create_resp.get("resource", {})
+        resource_id = resource.get("id")
+        if not resource_id:
+            raise ValueError("Failed to create resource")
+
+        upload_resp = await self._sdk.send_event("resource:upload_url", {
+            "resource_id": resource_id,
+            "filename": name,
+            "content_type": mime_type,
+        })
+        return {
+            "resource_id": resource_id,
+            "upload_url": upload_resp.get("upload_url", ""),
+        }
+
+    async def get_url(self, resource_id: str) -> str:
+        """Get a presigned download URL."""
+        resp = await self._sdk.send_event("resource:download_url", {
+            "resource_id": resource_id,
+        })
+        return resp.get("download_url", "")
+
+    async def remove(self, resource_id: str) -> None:
+        """Delete a resource."""
+        await self._sdk.send_event("resource:delete", {
+            "resource_id": resource_id,
+        })
+
+    async def list(self, resource_type: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List resources in the workflow."""
+        resp = await self._sdk.send_event("resource:list", {
+            "workflow_id": self._sdk.workflow_id,
+            "resource_type": resource_type,
+        })
+        return [
+            {
+                "id": r.get("id"),
+                "name": r.get("name"),
+                "resource_type": r.get("resource_type"),
+                "mime_type": r.get("mime_type"),
+                "size_bytes": r.get("size_bytes"),
+            }
+            for r in resp.get("resources", [])
+        ]
+
+
+class DatasetNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def create(self, name: str) -> str:
+        """Create a new dataset. Returns resource_id."""
+        resp = await self._sdk.send_event("resource:create", {
+            "workflow_id": self._sdk.workflow_id,
+            "resource_type": "dataset",
+            "name": name,
+        })
+        resource = resp.get("resource", {})
+        resource_id = resource.get("id")
+        if not resource_id:
+            raise ValueError("Failed to create dataset")
+        return resource_id
+
+    async def list(self) -> List[Dict[str, Any]]:
+        """List all datasets in the workflow."""
+        resp = await self._sdk.send_event("resource:list", {
+            "workflow_id": self._sdk.workflow_id,
+            "resource_type": "dataset",
+        })
+        return [
+            {
+                "id": r.get("id"),
+                "name": r.get("name"),
+                "row_count": r.get("metadata", {}).get("row_count", 0),
+            }
+            for r in resp.get("resources", [])
+        ]
+
+    async def get_rows(
+        self, resource_id: str, limit: int = 100, offset: int = 0
+    ) -> Dict[str, Any]:
+        """Get paginated rows from a dataset."""
+        resp = await self._sdk.send_event("resource:dataset:rows", {
+            "resource_id": resource_id,
+            "limit": limit,
+            "offset": offset,
+        })
+        return {
+            "rows": resp.get("rows", []),
+            "total_count": resp.get("total_count", 0),
+        }
+
+    async def append_rows(self, resource_id: str, rows: List[Dict[str, Any]]) -> int:
+        """Append rows to a dataset. Returns inserted count."""
+        resp = await self._sdk.send_event("resource:dataset:append", {
+            "resource_id": resource_id,
+            "rows": rows,
+        })
+        return resp.get("inserted_count", 0)
+
+    async def update_row(self, resource_id: str, row_id: str, data: Dict[str, Any]) -> None:
+        """Update a single row."""
+        await self._sdk.send_event("resource:dataset:update_row", {
+            "resource_id": resource_id,
+            "row_id": row_id,
+            "data": data,
+        })
+
+    async def delete_rows(self, resource_id: str, row_ids: List[str]) -> int:
+        """Delete rows. Returns deleted count."""
+        resp = await self._sdk.send_event("resource:dataset:delete_rows", {
+            "resource_id": resource_id,
+            "row_ids": row_ids,
+        })
+        return resp.get("deleted_count", 0)
+
+
+class WorkflowNamespace:
+    def __init__(self, sdk: "NoClickSDK"):
+        self._sdk = sdk
+
+    async def get_info(self) -> Dict[str, Any]:
+        """Get workflow info."""
+        resp = await self._sdk.send_event("workflow:get", {
+            "workflow_id": self._sdk.workflow_id,
+        })
+        wf = resp.get("workflow", {})
+        nodes = wf.get("workflow_data", {}).get("nodes", [])
+        return {
+            "id": wf.get("id", ""),
+            "name": wf.get("name", ""),
+            "node_count": len(nodes),
+        }

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

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: noclick
+Version: 0.1.0
+Summary: Python SDK for NoClick workflow automation
+License: BUSL-1.1
+Project-URL: Homepage, https://docs.noclick.com/sdk/overview
+Project-URL: Documentation, https://docs.noclick.com/sdk/external-apps
+Project-URL: Repository, https://github.com/noclickapp/noclick
+Keywords: noclick,workflow,automation,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: python-socketio[asyncio_client]>=5.0
+Requires-Dist: aiohttp>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# noclick-sdk
+
+Python SDK for [NoClick](https://noclick.com) workflow automation. Build external applications that interact with NoClick workflows — read node outputs, trigger execution, manage state, and work with files and datasets.
+
+## Installation
+
+```bash
+pip install noclick
+```
+
+## Quick Start
+
+```python
+import asyncio
+from noclick import NoClickSDK
+
+async def main():
+    sdk = NoClickSDK(
+        url="https://api.noclick.io",
+        api_key="nk_live_...",
+        workflow_id="your-workflow-id",
+    )
+    await sdk.connect()
+
+    # List nodes
+    nodes = await sdk.nodes.list()
+    for node in nodes:
+        print(f"{node['label']} ({node['type']})")
+
+    # Read node output
+    output = await sdk.nodes.get_output("gmail-node-id")
+
+    # Run a node and get results
+    results = await sdk.execution.run_nodes_and_get_output(
+        ["data-fetcher"], ["formatter"]
+    )
+
+    # State management
+    await sdk.state.set("counter", 42)
+    val = await sdk.state.get("counter")
+
+    # Dataset CRUD
+    ds_id = await sdk.dataset.create("My Data")
+    await sdk.dataset.append_rows(ds_id, [{"name": "Alice", "score": 95}])
+
+    await sdk.disconnect()
+
+asyncio.run(main())
+```
+
+## API
+
+| Namespace | Methods |
+|-----------|---------|
+| `sdk.nodes` | `get_output`, `get_config`, `list` |
+| `sdk.execution` | `run_nodes_and_get_output`, `run_nodes_in_background`, `on_node_output`, `on_node_state` |
+| `sdk.state` | `get`, `set`, `delete`, `update`, `keys` |
+| `sdk.auth` | `list_credentials`, `has_credential`, `create_credential` |
+| `sdk.resources` | `upload`, `get_url`, `remove`, `list` |
+| `sdk.dataset` | `create`, `list`, `get_rows`, `append_rows`, `update_row`, `delete_rows` |
+| `sdk.workflow` | `get_info` |
+
+## Documentation
+
+Full documentation at [docs.noclick.com/sdk](https://docs.noclick.com/sdk/overview).
+
+## License
+
+[Business Source License 1.1](../LICENSE) — free to use with NoClick, converts to Apache 2.0 after 4 years.

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+noclick/__init__.py
+noclick/client.py
+noclick/namespaces.py
+noclick.egg-info/PKG-INFO
+noclick.egg-info/SOURCES.txt
+noclick.egg-info/dependency_links.txt
+noclick.egg-info/requires.txt
+noclick.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,6 @@
+python-socketio[asyncio_client]>=5.0
+aiohttp>=3.0
+
+[dev]
+pytest
+pytest-asyncio

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

@@ -0,0 +1 @@
+noclick

noclick-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "noclick"
+version = "0.1.0"
+description = "Python SDK for NoClick workflow automation"
+readme = "README.md"
+license = {text = "BUSL-1.1"}
+requires-python = ">=3.10"
+keywords = ["noclick", "workflow", "automation", "sdk"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "python-socketio[asyncio_client]>=5.0",
+    "aiohttp>=3.0",
+]
+
+[project.urls]
+Homepage = "https://docs.noclick.com/sdk/overview"
+Documentation = "https://docs.noclick.com/sdk/external-apps"
+Repository = "https://github.com/noclickapp/noclick"
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio"]
+
+[tool.setuptools.packages.find]
+include = ["noclick*"]

noclick-0.1.0/setup.cfg

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