flowtask-sdk 0.1.0__tar.gz

flowtask_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: flowtask-sdk
+Version: 0.1.0
+Summary: Python SDK for the FlowTask visual task manager API
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# FlowTask Python SDK
+
+A Python client for the FlowTask API — programmatically create projects, tasks, and dependency graphs.
+
+## Install
+
+```bash
+pip install -e sdk/python
+```
+
+Or from the SDK directory:
+
+```bash
+cd sdk/python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from flowtask import FlowTask
+
+# Connect with your API token (create one in the FlowTask UI → Key icon → API Tokens)
+ft = FlowTask(token="ft_your_token_here", base_url="http://localhost:3000")
+
+# Create a project
+project = ft.create_project("Sprint 1", color="#6366F1")
+
+# Create tasks
+design = project.create_task("Design System", color="#8B5CF6")
+build = project.create_task("Build Components", color="#3B82F6")
+test = project.create_task("Write Tests", color="#10B981")
+deploy = project.create_task("Deploy", color="#EF4444")
+
+# Create dependencies (diamond-shaped DAG)
+build.add_dependency(design)   # Design must be done before Build
+test.add_dependency(design)    # Design must be done before Test
+deploy.add_dependency(build)   # Build must be done before Deploy
+deploy.add_dependency(test)    # Test must be done before Deploy
+
+# See what's actionable right now
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Design System (the only task with no blockers)
+
+# Complete a task and see what unblocks
+design.complete()
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Build Components
+# → Write Tests
+```
+
+## API Reference
+
+### FlowTask Client
+
+```python
+ft = FlowTask(token="ft_...", base_url="https://your-app.railway.app")
+```
+
+### Projects
+
+```python
+# List all projects
+projects = ft.list_projects()
+
+# Create a project
+project = ft.create_project("Name", description="...", color="#6366F1")
+
+# Load full project (tasks + dependencies)
+tasks, dependencies = project.load()
+
+# Update
+project.update(name="New Name", color="#EF4444")
+
+# Delete
+project.delete()
+```
+
+### Tasks
+
+```python
+# Create a task in a project
+task = project.create_task(
+    "Task Title",
+    description="Details...",
+    color="#3B82F6",
+    due_date="2026-04-01T00:00:00Z",
+    assignee="Alice",
+)
+
+# Update fields
+task.update(title="New Title", description="Updated")
+
+# Change status
+task.set_status("in_progress")  # or "pending", "completed"
+task.complete()                  # shorthand for completed
+
+# Delete
+task.delete()
+```
+
+### Dependencies
+
+```python
+# Make task_b depend on task_a (task_a must be done first)
+task_b.add_dependency(task_a)
+
+# Or use the client directly
+dep = ft.create_dependency(
+    enabling_task_id=task_a.id,
+    dependent_task_id=task_b.id
+)
+
+# Remove a dependency
+ft.delete_dependency(dep.id)
+```
+
+### Tags
+
+```python
+# Create a tag
+tag = ft.create_tag("frontend", color="#3B82F6")
+
+# Assign to a task
+task.add_tag(tag.id)
+
+# Remove from a task
+task.remove_tag(tag.id)
+
+# List all tags
+tags = ft.list_tags()
+```
+
+### Smart Features
+
+```python
+# Get actionable tasks (all dependencies completed)
+actionable = ft.actual_tasks()
+for task in actionable:
+    print(f"[{task.project_id}] {task.title} — {task.status}")
+```
+
+## Error Handling
+
+```python
+from flowtask import FlowTask, CycleDetectedError, ValidationError, NotFoundError
+
+ft = FlowTask(token="ft_...")
+
+try:
+    ft.create_dependency(task_a.id, task_b.id)
+except CycleDetectedError as e:
+    print(f"Would create a cycle: {e.message}")
+except ValidationError as e:
+    print(f"Invalid input: {e.message}")
+except NotFoundError as e:
+    print(f"Not found: {e.message}")
+```
+
+## Example: Import Tasks from CSV
+
+```python
+import csv
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+project = ft.create_project("Imported Project")
+
+with open("tasks.csv") as f:
+    for row in csv.DictReader(f):
+        project.create_task(
+            title=row["title"],
+            description=row.get("description", ""),
+            color=row.get("color"),
+            due_date=row.get("due_date"),
+        )
+```
+
+## Example: Daily Standup Report
+
+```python
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+
+print("📋 What I can work on today:")
+for task in ft.actual_tasks():
+    due = f" (due {task.due_date[:10]})" if task.due_date else ""
+    print(f"  → {task.title}{due}")
+```

flowtask_sdk-0.1.0/README.md

@@ -0,0 +1,192 @@
+# FlowTask Python SDK
+
+A Python client for the FlowTask API — programmatically create projects, tasks, and dependency graphs.
+
+## Install
+
+```bash
+pip install -e sdk/python
+```
+
+Or from the SDK directory:
+
+```bash
+cd sdk/python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from flowtask import FlowTask
+
+# Connect with your API token (create one in the FlowTask UI → Key icon → API Tokens)
+ft = FlowTask(token="ft_your_token_here", base_url="http://localhost:3000")
+
+# Create a project
+project = ft.create_project("Sprint 1", color="#6366F1")
+
+# Create tasks
+design = project.create_task("Design System", color="#8B5CF6")
+build = project.create_task("Build Components", color="#3B82F6")
+test = project.create_task("Write Tests", color="#10B981")
+deploy = project.create_task("Deploy", color="#EF4444")
+
+# Create dependencies (diamond-shaped DAG)
+build.add_dependency(design)   # Design must be done before Build
+test.add_dependency(design)    # Design must be done before Test
+deploy.add_dependency(build)   # Build must be done before Deploy
+deploy.add_dependency(test)    # Test must be done before Deploy
+
+# See what's actionable right now
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Design System (the only task with no blockers)
+
+# Complete a task and see what unblocks
+design.complete()
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Build Components
+# → Write Tests
+```
+
+## API Reference
+
+### FlowTask Client
+
+```python
+ft = FlowTask(token="ft_...", base_url="https://your-app.railway.app")
+```
+
+### Projects
+
+```python
+# List all projects
+projects = ft.list_projects()
+
+# Create a project
+project = ft.create_project("Name", description="...", color="#6366F1")
+
+# Load full project (tasks + dependencies)
+tasks, dependencies = project.load()
+
+# Update
+project.update(name="New Name", color="#EF4444")
+
+# Delete
+project.delete()
+```
+
+### Tasks
+
+```python
+# Create a task in a project
+task = project.create_task(
+    "Task Title",
+    description="Details...",
+    color="#3B82F6",
+    due_date="2026-04-01T00:00:00Z",
+    assignee="Alice",
+)
+
+# Update fields
+task.update(title="New Title", description="Updated")
+
+# Change status
+task.set_status("in_progress")  # or "pending", "completed"
+task.complete()                  # shorthand for completed
+
+# Delete
+task.delete()
+```
+
+### Dependencies
+
+```python
+# Make task_b depend on task_a (task_a must be done first)
+task_b.add_dependency(task_a)
+
+# Or use the client directly
+dep = ft.create_dependency(
+    enabling_task_id=task_a.id,
+    dependent_task_id=task_b.id
+)
+
+# Remove a dependency
+ft.delete_dependency(dep.id)
+```
+
+### Tags
+
+```python
+# Create a tag
+tag = ft.create_tag("frontend", color="#3B82F6")
+
+# Assign to a task
+task.add_tag(tag.id)
+
+# Remove from a task
+task.remove_tag(tag.id)
+
+# List all tags
+tags = ft.list_tags()
+```
+
+### Smart Features
+
+```python
+# Get actionable tasks (all dependencies completed)
+actionable = ft.actual_tasks()
+for task in actionable:
+    print(f"[{task.project_id}] {task.title} — {task.status}")
+```
+
+## Error Handling
+
+```python
+from flowtask import FlowTask, CycleDetectedError, ValidationError, NotFoundError
+
+ft = FlowTask(token="ft_...")
+
+try:
+    ft.create_dependency(task_a.id, task_b.id)
+except CycleDetectedError as e:
+    print(f"Would create a cycle: {e.message}")
+except ValidationError as e:
+    print(f"Invalid input: {e.message}")
+except NotFoundError as e:
+    print(f"Not found: {e.message}")
+```
+
+## Example: Import Tasks from CSV
+
+```python
+import csv
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+project = ft.create_project("Imported Project")
+
+with open("tasks.csv") as f:
+    for row in csv.DictReader(f):
+        project.create_task(
+            title=row["title"],
+            description=row.get("description", ""),
+            color=row.get("color"),
+            due_date=row.get("due_date"),
+        )
+```
+
+## Example: Daily Standup Report
+
+```python
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+
+print("📋 What I can work on today:")
+for task in ft.actual_tasks():
+    due = f" (due {task.due_date[:10]})" if task.due_date else ""
+    print(f"  → {task.title}{due}")
+```

flowtask_sdk-0.1.0/flowtask/__init__.py

@@ -0,0 +1,17 @@
+from .client import FlowTask
+from .models import Project, Task, Dependency, Tag
+from .exceptions import FlowTaskError, AuthenticationError, ValidationError, NotFoundError, CycleDetectedError
+
+__version__ = "0.1.0"
+__all__ = [
+    "FlowTask",
+    "Project",
+    "Task",
+    "Dependency",
+    "Tag",
+    "FlowTaskError",
+    "AuthenticationError",
+    "ValidationError",
+    "NotFoundError",
+    "CycleDetectedError",
+]

flowtask_sdk-0.1.0/flowtask/client.py

@@ -0,0 +1,217 @@
+"""FlowTask Python SDK — programmatic access to the FlowTask API."""
+
+from __future__ import annotations
+
+from typing import Optional
+import requests as _requests
+
+from .models import Project, Task, Dependency, Tag
+from .exceptions import (
+    FlowTaskError,
+    AuthenticationError,
+    ValidationError,
+    NotFoundError,
+    CycleDetectedError,
+)
+
+ERROR_MAP = {
+    "UNAUTHORIZED": AuthenticationError,
+    "VALIDATION_ERROR": ValidationError,
+    "NOT_FOUND": NotFoundError,
+    "CYCLE_DETECTED": CycleDetectedError,
+    "FORBIDDEN": AuthenticationError,
+    "CONFLICT": ValidationError,
+}
+
+
+class FlowTask:
+    """Client for the FlowTask API.
+
+    Usage:
+        ft = FlowTask(token="ft_your_token", base_url="https://your-app.railway.app")
+
+        # Create a project
+        project = ft.create_project("Sprint 1", color="#6366F1")
+
+        # Create tasks
+        design = project.create_task("Design", color="#8B5CF6")
+        build = project.create_task("Build", color="#3B82F6")
+
+        # Create dependency: Design must be done before Build
+        build.add_dependency(design)
+
+        # See what's actionable
+        for task in ft.actual_tasks():
+            print(f"→ {task.title}")
+    """
+
+    def __init__(self, token: str, base_url: str = "http://localhost:3000"):
+        self.base_url = base_url.rstrip("/")
+        self._session = _requests.Session()
+        self._session.headers.update(
+            {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            }
+        )
+
+    def _request(self, method: str, path: str, json: dict = None) -> dict:
+        url = f"{self.base_url}/api{path}"
+        resp = self._session.request(method, url, json=json)
+        data = resp.json()
+
+        if not resp.ok:
+            error_data = data.get("error", {})
+            code = error_data.get("code", "UNKNOWN")
+            message = error_data.get("message", "Unknown error")
+            exc_class = ERROR_MAP.get(code, FlowTaskError)
+            raise exc_class(message=message, code=code, status=resp.status_code)
+
+        return data.get("data", data)
+
+    # ─── Projects ──────────────────────────────────────
+
+    def list_projects(self) -> list[Project]:
+        """List all projects."""
+        data = self._request("GET", "/projects")
+        return [Project.from_dict(p, client=self) for p in data]
+
+    def create_project(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        color: Optional[str] = None,
+    ) -> Project:
+        """Create a new project."""
+        body = {"name": name}
+        if description is not None:
+            body["description"] = description
+        if color is not None:
+            body["color"] = color
+        data = self._request("POST", "/projects", json=body)
+        return Project.from_dict(data, client=self)
+
+    def get_project(self, project_id: str) -> Project:
+        """Get a project by ID."""
+        data = self._request("GET", f"/projects/{project_id}")
+        return Project.from_dict(data.get("project", data), client=self)
+
+    def get_project_full(self, project_id: str) -> tuple[list[Task], list[Dependency]]:
+        """Load a project's full data: tasks and dependencies."""
+        data = self._request("GET", f"/projects/{project_id}")
+        tasks = [Task.from_dict(t, client=self) for t in data.get("tasks", [])]
+        deps = [Dependency.from_dict(d) for d in data.get("dependencies", [])]
+        return tasks, deps
+
+    def update_project(self, project_id: str, **kwargs) -> Project:
+        """Update a project. Accepts: name, description, color."""
+        body = {}
+        for key in ("name", "description", "color"):
+            if key in kwargs:
+                body[key] = kwargs[key]
+        data = self._request("PUT", f"/projects/{project_id}", json=body)
+        return Project.from_dict(data, client=self)
+
+    def delete_project(self, project_id: str) -> None:
+        """Delete a project and all its tasks."""
+        self._request("DELETE", f"/projects/{project_id}")
+
+    # ─── Tasks ─────────────────────────────────────────
+
+    def create_task(
+        self,
+        project_id: str,
+        title: str,
+        description: Optional[str] = None,
+        color: Optional[str] = None,
+        due_date: Optional[str] = None,
+        assignee: Optional[str] = None,
+        position_x: Optional[float] = None,
+        position_y: Optional[float] = None,
+    ) -> Task:
+        """Create a task in a project."""
+        body: dict = {"title": title}
+        if description is not None:
+            body["description"] = description
+        if color is not None:
+            body["color"] = color
+        if due_date is not None:
+            body["dueDate"] = due_date
+        if assignee is not None:
+            body["assignee"] = assignee
+        if position_x is not None:
+            body["positionX"] = position_x
+        if position_y is not None:
+            body["positionY"] = position_y
+        data = self._request("POST", f"/projects/{project_id}/tasks", json=body)
+        return Task.from_dict(data, client=self)
+
+    def update_task(self, task_id: str, **kwargs) -> Task:
+        """Update a task. Accepts: title, description, status, color, due_date, assignee."""
+        key_map = {"due_date": "dueDate", "position_x": "positionX", "position_y": "positionY", "sort_order": "sortOrder"}
+        body = {}
+        for key, value in kwargs.items():
+            api_key = key_map.get(key, key)
+            body[api_key] = value
+        data = self._request("PUT", f"/tasks/{task_id}", json=body)
+        return Task.from_dict(data, client=self)
+
+    def set_task_status(self, task_id: str, status: str) -> Task:
+        """Set a task's status: 'pending', 'in_progress', or 'completed'."""
+        data = self._request("PATCH", f"/tasks/{task_id}/status", json={"status": status})
+        return Task.from_dict(data, client=self)
+
+    def delete_task(self, task_id: str) -> None:
+        """Delete a task and its dependencies."""
+        self._request("DELETE", f"/tasks/{task_id}")
+
+    # ─── Dependencies ──────────────────────────────────
+
+    def create_dependency(self, enabling_task_id: str, dependent_task_id: str) -> Dependency:
+        """Create a dependency: enabling_task must be done before dependent_task.
+
+        Raises CycleDetectedError if this would create a circular dependency.
+        """
+        data = self._request(
+            "POST",
+            "/dependencies",
+            json={
+                "enablingTaskId": enabling_task_id,
+                "dependentTaskId": dependent_task_id,
+            },
+        )
+        return Dependency.from_dict(data)
+
+    def delete_dependency(self, dependency_id: str) -> None:
+        """Remove a dependency."""
+        self._request("DELETE", f"/dependencies/{dependency_id}")
+
+    # ─── Tags ──────────────────────────────────────────
+
+    def list_tags(self) -> list[Tag]:
+        """List all tags."""
+        data = self._request("GET", "/tags")
+        return [Tag.from_dict(t) for t in data]
+
+    def create_tag(self, name: str, color: Optional[str] = None) -> Tag:
+        """Create a tag."""
+        body: dict = {"name": name}
+        if color is not None:
+            body["color"] = color
+        data = self._request("POST", "/tags", json=body)
+        return Tag.from_dict(data)
+
+    def assign_tag(self, task_id: str, tag_id: str) -> None:
+        """Assign a tag to a task."""
+        self._request("POST", f"/tasks/{task_id}/tags/{tag_id}", json={})
+
+    def remove_tag(self, task_id: str, tag_id: str) -> None:
+        """Remove a tag from a task."""
+        self._request("DELETE", f"/tasks/{task_id}/tags/{tag_id}")
+
+    # ─── Smart Features ────────────────────────────────
+
+    def actual_tasks(self) -> list[Task]:
+        """Get actionable tasks — tasks where all dependencies are completed."""
+        data = self._request("GET", "/actual-tasks")
+        return [Task.from_dict(t, client=self) for t in data]

flowtask_sdk-0.1.0/flowtask/exceptions.py

@@ -0,0 +1,28 @@
+class FlowTaskError(Exception):
+    """Base exception for FlowTask SDK."""
+
+    def __init__(self, message: str, code: str = "UNKNOWN", status: int = 500):
+        self.message = message
+        self.code = code
+        self.status = status
+        super().__init__(message)
+
+
+class AuthenticationError(FlowTaskError):
+    """Raised when authentication fails (invalid or missing token)."""
+    pass
+
+
+class ValidationError(FlowTaskError):
+    """Raised when input validation fails."""
+    pass
+
+
+class NotFoundError(FlowTaskError):
+    """Raised when a resource is not found."""
+    pass
+
+
+class CycleDetectedError(FlowTaskError):
+    """Raised when creating a dependency would form a cycle."""
+    pass

flowtask_sdk-0.1.0/flowtask/models.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import FlowTask
+
+
+@dataclass
+class Tag:
+    id: str
+    name: str
+    color: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Tag:
+        return cls(id=data["id"], name=data["name"], color=data["color"])
+
+
+@dataclass
+class Dependency:
+    id: str
+    enabling_task_id: str
+    dependent_task_id: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Dependency:
+        return cls(
+            id=data["id"],
+            enabling_task_id=data["enablingTaskId"],
+            dependent_task_id=data["dependentTaskId"],
+        )
+
+
+@dataclass
+class Task:
+    id: str
+    title: str
+    status: str
+    description: Optional[str] = None
+    color: Optional[str] = None
+    due_date: Optional[str] = None
+    assignee: Optional[str] = None
+    position_x: float = 0
+    position_y: float = 0
+    sort_order: int = 0
+    project_id: str = ""
+    tags: list[Tag] = field(default_factory=list)
+    created_at: str = ""
+    updated_at: str = ""
+    _client: Optional[FlowTask] = field(default=None, repr=False)
+
+    @classmethod
+    def from_dict(cls, data: dict, client: Optional[FlowTask] = None) -> Task:
+        return cls(
+            id=data["id"],
+            title=data["title"],
+            status=data["status"],
+            description=data.get("description"),
+            color=data.get("color"),
+            due_date=data.get("dueDate"),
+            assignee=data.get("assignee"),
+            position_x=data.get("positionX", 0),
+            position_y=data.get("positionY", 0),
+            sort_order=data.get("sortOrder", 0),
+            project_id=data.get("projectId", ""),
+            tags=[Tag.from_dict(t) for t in data.get("tags", [])],
+            created_at=data.get("createdAt", ""),
+            updated_at=data.get("updatedAt", ""),
+            _client=client,
+        )
+
+    def update(self, **kwargs) -> Task:
+        """Update this task's fields. Returns the updated task."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        return self._client.update_task(self.id, **kwargs)
+
+    def set_status(self, status: str) -> Task:
+        """Set task status: 'pending', 'in_progress', or 'completed'."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        return self._client.set_task_status(self.id, status)
+
+    def complete(self) -> Task:
+        """Mark this task as completed."""
+        return self.set_status("completed")
+
+    def delete(self) -> None:
+        """Delete this task."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        self._client.delete_task(self.id)
+
+    def add_dependency(self, depends_on: Task) -> Dependency:
+        """Make this task depend on another task (depends_on must be done first)."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        return self._client.create_dependency(depends_on.id, self.id)
+
+    def add_tag(self, tag_id: str) -> None:
+        """Assign a tag to this task."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        self._client.assign_tag(self.id, tag_id)
+
+    def remove_tag(self, tag_id: str) -> None:
+        """Remove a tag from this task."""
+        if not self._client:
+            raise RuntimeError("Task not bound to a client")
+        self._client.remove_tag(self.id, tag_id)
+
+
+@dataclass
+class Project:
+    id: str
+    name: str
+    description: Optional[str] = None
+    color: str = "#6366F1"
+    sort_order: int = 0
+    task_count: int = 0
+    created_at: str = ""
+    updated_at: str = ""
+    _client: Optional[FlowTask] = field(default=None, repr=False)
+
+    @classmethod
+    def from_dict(cls, data: dict, client: Optional[FlowTask] = None) -> Project:
+        count = data.get("_count", {})
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            description=data.get("description"),
+            color=data.get("color", "#6366F1"),
+            sort_order=data.get("sortOrder", 0),
+            task_count=count.get("tasks", 0) if isinstance(count, dict) else 0,
+            created_at=data.get("createdAt", ""),
+            updated_at=data.get("updatedAt", ""),
+            _client=client,
+        )
+
+    def create_task(self, title: str, **kwargs) -> Task:
+        """Create a new task in this project."""
+        if not self._client:
+            raise RuntimeError("Project not bound to a client")
+        return self._client.create_task(self.id, title, **kwargs)
+
+    def load(self) -> tuple[list[Task], list[Dependency]]:
+        """Load all tasks and dependencies for this project."""
+        if not self._client:
+            raise RuntimeError("Project not bound to a client")
+        return self._client.get_project_full(self.id)
+
+    def update(self, **kwargs) -> Project:
+        """Update this project's fields."""
+        if not self._client:
+            raise RuntimeError("Project not bound to a client")
+        return self._client.update_project(self.id, **kwargs)
+
+    def delete(self) -> None:
+        """Delete this project and all its tasks."""
+        if not self._client:
+            raise RuntimeError("Project not bound to a client")
+        self._client.delete_project(self.id)

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

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: flowtask-sdk
+Version: 0.1.0
+Summary: Python SDK for the FlowTask visual task manager API
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# FlowTask Python SDK
+
+A Python client for the FlowTask API — programmatically create projects, tasks, and dependency graphs.
+
+## Install
+
+```bash
+pip install -e sdk/python
+```
+
+Or from the SDK directory:
+
+```bash
+cd sdk/python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from flowtask import FlowTask
+
+# Connect with your API token (create one in the FlowTask UI → Key icon → API Tokens)
+ft = FlowTask(token="ft_your_token_here", base_url="http://localhost:3000")
+
+# Create a project
+project = ft.create_project("Sprint 1", color="#6366F1")
+
+# Create tasks
+design = project.create_task("Design System", color="#8B5CF6")
+build = project.create_task("Build Components", color="#3B82F6")
+test = project.create_task("Write Tests", color="#10B981")
+deploy = project.create_task("Deploy", color="#EF4444")
+
+# Create dependencies (diamond-shaped DAG)
+build.add_dependency(design)   # Design must be done before Build
+test.add_dependency(design)    # Design must be done before Test
+deploy.add_dependency(build)   # Build must be done before Deploy
+deploy.add_dependency(test)    # Test must be done before Deploy
+
+# See what's actionable right now
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Design System (the only task with no blockers)
+
+# Complete a task and see what unblocks
+design.complete()
+for task in ft.actual_tasks():
+    print(f"→ {task.title}")
+# → Build Components
+# → Write Tests
+```
+
+## API Reference
+
+### FlowTask Client
+
+```python
+ft = FlowTask(token="ft_...", base_url="https://your-app.railway.app")
+```
+
+### Projects
+
+```python
+# List all projects
+projects = ft.list_projects()
+
+# Create a project
+project = ft.create_project("Name", description="...", color="#6366F1")
+
+# Load full project (tasks + dependencies)
+tasks, dependencies = project.load()
+
+# Update
+project.update(name="New Name", color="#EF4444")
+
+# Delete
+project.delete()
+```
+
+### Tasks
+
+```python
+# Create a task in a project
+task = project.create_task(
+    "Task Title",
+    description="Details...",
+    color="#3B82F6",
+    due_date="2026-04-01T00:00:00Z",
+    assignee="Alice",
+)
+
+# Update fields
+task.update(title="New Title", description="Updated")
+
+# Change status
+task.set_status("in_progress")  # or "pending", "completed"
+task.complete()                  # shorthand for completed
+
+# Delete
+task.delete()
+```
+
+### Dependencies
+
+```python
+# Make task_b depend on task_a (task_a must be done first)
+task_b.add_dependency(task_a)
+
+# Or use the client directly
+dep = ft.create_dependency(
+    enabling_task_id=task_a.id,
+    dependent_task_id=task_b.id
+)
+
+# Remove a dependency
+ft.delete_dependency(dep.id)
+```
+
+### Tags
+
+```python
+# Create a tag
+tag = ft.create_tag("frontend", color="#3B82F6")
+
+# Assign to a task
+task.add_tag(tag.id)
+
+# Remove from a task
+task.remove_tag(tag.id)
+
+# List all tags
+tags = ft.list_tags()
+```
+
+### Smart Features
+
+```python
+# Get actionable tasks (all dependencies completed)
+actionable = ft.actual_tasks()
+for task in actionable:
+    print(f"[{task.project_id}] {task.title} — {task.status}")
+```
+
+## Error Handling
+
+```python
+from flowtask import FlowTask, CycleDetectedError, ValidationError, NotFoundError
+
+ft = FlowTask(token="ft_...")
+
+try:
+    ft.create_dependency(task_a.id, task_b.id)
+except CycleDetectedError as e:
+    print(f"Would create a cycle: {e.message}")
+except ValidationError as e:
+    print(f"Invalid input: {e.message}")
+except NotFoundError as e:
+    print(f"Not found: {e.message}")
+```
+
+## Example: Import Tasks from CSV
+
+```python
+import csv
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+project = ft.create_project("Imported Project")
+
+with open("tasks.csv") as f:
+    for row in csv.DictReader(f):
+        project.create_task(
+            title=row["title"],
+            description=row.get("description", ""),
+            color=row.get("color"),
+            due_date=row.get("due_date"),
+        )
+```
+
+## Example: Daily Standup Report
+
+```python
+from flowtask import FlowTask
+
+ft = FlowTask(token="ft_...", base_url="http://localhost:3000")
+
+print("📋 What I can work on today:")
+for task in ft.actual_tasks():
+    due = f" (due {task.due_date[:10]})" if task.due_date else ""
+    print(f"  → {task.title}{due}")
+```

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+flowtask/__init__.py
+flowtask/client.py
+flowtask/exceptions.py
+flowtask/models.py
+flowtask_sdk.egg-info/PKG-INFO
+flowtask_sdk.egg-info/SOURCES.txt
+flowtask_sdk.egg-info/dependency_links.txt
+flowtask_sdk.egg-info/requires.txt
+flowtask_sdk.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+requests>=2.28.0
+
+[dev]
+pytest>=7.0

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

@@ -0,0 +1 @@
+flowtask

flowtask_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flowtask-sdk"
+version = "0.1.0"
+description = "Python SDK for the FlowTask visual task manager API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]

flowtask_sdk-0.1.0/setup.cfg

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