fairchild 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

fairchild/__init__.py

@@ -1,11 +1,9 @@
 from fairchild.task import task
 from fairchild.job import Job
-from fairchild.record import Record
 from fairchild.fairchild import Fairchild
 
 __all__ = [
     "task",
     "Job",
-    "Record",
     "Fairchild",
 ]

fairchild/cli.py

@@ -162,19 +162,11 @@ async def _run_workers(queue_config: dict[str, int]):
 @cli.command()
 @click.option("--host", "-h", default="127.0.0.1", help="Host to bind to")
 @click.option("--port", "-p", default=4000, help="Port to bind to")
-@click.option(
-    "--import",
-    "-i",
-    "imports",
-    multiple=True,
-    help='Module to import for task registration, e.g., "myapp.tasks"',
-)
-def ui(host: str, port: int, imports: tuple[str, ...]):
-    """Start the web UI dashboard."""
-    # Import task modules
-    for module_path in imports:
-        import_module(module_path)
+def ui(host: str, port: int):
+    """Start the web UI dashboard.
 
+    The UI reads task definitions from active workers, so no --import is needed.
+    """
     click.echo(f"Starting Fairchild UI at http://{host}:{port}")
     asyncio.run(_run_ui(host, port))
 

fairchild/db/migrations/005_add_worker_tasks.sql

@@ -0,0 +1,3 @@
+-- Add tasks column to workers table
+-- Workers publish their registered tasks (with schemas) on startup
+ALTER TABLE fairchild_workers ADD COLUMN IF NOT EXISTS tasks JSONB DEFAULT '[]';

fairchild/db/migrations/006_rename_recorded_to_result.sql

@@ -0,0 +1,2 @@
+-- Rename recorded column to result
+ALTER TABLE fairchild_jobs RENAME COLUMN recorded TO result;

fairchild/task.py

@@ -15,6 +15,52 @@ def get_task(name: str) -> "Task":
     return _task_registry[name]
 
 
+def get_task_schemas() -> list[dict]:
+    """Get schemas for all registered tasks.
+
+    Returns a list of task info dicts suitable for storing in the database.
+    """
+    tasks = []
+    for name, task in sorted(_task_registry.items()):
+        sig = inspect.signature(task.fn)
+        params = []
+        for param_name, param in sig.parameters.items():
+            if param_name in ("job", "workflow"):
+                continue
+
+            param_info = {"name": param_name}
+
+            if param.annotation != inspect.Parameter.empty:
+                try:
+                    param_info["type"] = param.annotation.__name__
+                except AttributeError:
+                    param_info["type"] = str(param.annotation)
+
+            if param.default != inspect.Parameter.empty:
+                param_info["default"] = param.default
+                param_info["required"] = False
+            else:
+                param_info["required"] = True
+
+            params.append(param_info)
+
+        docstring = inspect.getdoc(task.fn)
+
+        tasks.append(
+            {
+                "name": name,
+                "queue": task.queue,
+                "priority": task.priority,
+                "max_attempts": task.max_attempts,
+                "tags": task.tags,
+                "params": params,
+                "docstring": docstring,
+            }
+        )
+
+    return tasks
+
+
 def task(
     queue: str = "default",
     max_attempts: int = 3,
@@ -28,7 +74,7 @@ def task(
     Usage:
         @task(queue="default")
         def my_task(item_id: int):
-            return Record({"result": item_id * 2})
+            return {"result": item_id * 2}
 
         # Enqueue
         my_task.enqueue(item_id=42)
@@ -151,13 +197,7 @@ class Task:
             return Future(job_id=job_id)
 
         # Not inside a task - execute directly
-        from fairchild.record import Record
-
-        result = self.fn(*args, **kwargs)
-        # Unwrap Record so local runs behave like resolved futures
-        if isinstance(result, Record):
-            return result.value
-        return result
+        return self.fn(*args, **kwargs)
 
     def _serialize_args(self, kwargs: dict[str, Any]) -> dict[str, Any]:
         """Serialize arguments, converting Futures to their job IDs."""

fairchild/templates/dashboard.html

@@ -255,6 +255,16 @@
       .job-link:hover {
         text-decoration: underline;
       }
+      .task-args {
+        font-family: "SF Mono", Monaco, monospace;
+        font-size: 0.75rem;
+        color: var(--text-dim);
+        margin-top: 0.25rem;
+        max-width: 300px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
 
       .queues {
         display: grid;
@@ -354,13 +364,6 @@
         font-weight: 500;
       }
 
-      #workflows-table tbody tr {
-        cursor: pointer;
-      }
-      #workflows-table tbody tr:hover {
-        background: var(--bg-hover);
-      }
-
       /* Enqueue Modal */
       .modal-overlay {
         display: none;
@@ -1214,23 +1217,10 @@
         }
       }
 
-      async function fetchWorkflows() {
-        const res = await fetch("/api/workflows");
-        const workflows = await res.json();
-
-        const tbody = document.querySelector("#workflows-table tbody");
-        tbody.innerHTML = workflows
-          .map(
-            (wf) => `
-                <tr onclick="window.location='/workflows/${wf.workflow_id}'">
-                    <td>${wf.workflow_name || wf.workflow_id.slice(0, 8)}</td>
-                    <td>${wf.completed}/${wf.total_jobs} completed</td>
-                    <td class="mono">${formatTime(wf.started_at)}</td>
-                    <td class="mono">${wf.finished_at ? formatTime(wf.finished_at) : "-"}</td>
-                </tr>
-            `,
-          )
-          .join("");
+      function formatArgs(args) {
+        if (!args || Object.keys(args).length === 0) return "";
+        const str = typeof args === "string" ? args : JSON.stringify(args);
+        return str.length > 50 ? str.slice(0, 50) + "..." : str;
       }
 
       async function fetchJobs(state = "") {
@@ -1240,18 +1230,26 @@
 
         const tbody = document.querySelector("#jobs-table tbody");
         tbody.innerHTML = jobs
-          .map(
-            (job) => `
+          .map((job) => {
+            const argsDisplay = formatArgs(job.args);
+            const argsTitle =
+              typeof job.args === "string"
+                ? job.args
+                : JSON.stringify(job.args);
+            const argsHtml = argsDisplay
+              ? `<div class="task-args" title="${argsTitle.replace(/"/g, "&quot;")}">${argsDisplay}</div>`
+              : "";
+            return `
                 <tr>
                     <td class="mono"><a href="/jobs/${job.id}" class="job-link">${job.id}</a></td>
-                    <td class="truncate">${job.task_name}</td>
+                    <td>${job.task_name}${argsHtml}</td>
                     <td>${job.queue}</td>
                     <td><span class="badge ${job.state}">${job.state}</span></td>
                     <td>${job.attempt}/${job.max_attempts}</td>
                     <td class="mono">${formatTime(job.inserted_at)}</td>
                 </tr>
-            `,
-          )
+              `;
+          })
           .join("");
       }
 
@@ -1462,7 +1460,6 @@
           fetchStats(),
           fetchQueues(),
           fetchWorkers(currentWorkerState),
-          fetchWorkflows(),
           fetchJobs(currentState),
           fetchTimeseries(),
         ]);
@@ -1484,14 +1481,17 @@
       }, 1000);
 
       // Enqueue modal
-      let tasksLoaded = false;
       let taskRegistry = {};
 
       async function loadTasks() {
-        if (tasksLoaded) return;
         const res = await fetch("/api/tasks");
         const tasks = await res.json();
         const select = document.getElementById("enqueue-task");
+
+        // Clear existing options except the placeholder
+        select.innerHTML = '<option value="">Select a task...</option>';
+        taskRegistry = {};
+
         tasks.forEach((task) => {
           taskRegistry[task.name] = task;
           const option = document.createElement("option");
@@ -1499,7 +1499,6 @@
           option.textContent = `${task.name} (queue: ${task.queue})`;
           select.appendChild(option);
         });
-        tasksLoaded = true;
       }
 
       function onTaskSelected() {

fairchild/templates/job.html

@@ -392,6 +392,64 @@
         border-radius: 4px;
       }
 
+      /* Task Summary Stats */
+      .task-summary {
+        margin-bottom: 1rem;
+        overflow-x: auto;
+      }
+      .task-summary table {
+        width: 100%;
+        border-collapse: collapse;
+        font-size: 0.8125rem;
+      }
+      .task-summary th,
+      .task-summary td {
+        padding: 0.5rem 0.75rem;
+        text-align: left;
+        border-bottom: 1px solid var(--border-color);
+      }
+      .task-summary th {
+        background: var(--bg-secondary);
+        color: var(--text-muted);
+        font-weight: 500;
+        text-transform: uppercase;
+        font-size: 0.6875rem;
+      }
+      .task-summary td {
+        color: var(--text-secondary);
+      }
+      .task-summary .task-name {
+        font-family: "SF Mono", Monaco, monospace;
+        font-weight: 500;
+        color: var(--text-primary);
+      }
+      .task-summary .stat-cell {
+        text-align: center;
+        min-width: 80px;
+      }
+      .task-summary .stat-cell .count {
+        font-weight: 600;
+      }
+      .task-summary .stat-cell .pct {
+        color: var(--text-dim);
+        font-size: 0.75rem;
+        margin-left: 0.25rem;
+      }
+      .task-summary .total-row {
+        font-weight: 600;
+        background: var(--bg-secondary);
+      }
+      .task-summary .total-row td {
+        border-bottom: none;
+      }
+      .task-summary .timing-cell {
+        white-space: nowrap;
+      }
+      .task-summary .timing-range {
+        color: var(--text-dim);
+        font-size: 0.7rem;
+      }
+
       #family-table {
         width: 100%;
         border-collapse: collapse;
@@ -522,6 +580,9 @@
           </div>
           <div id="dag-flow"></div>
         </div>
+        <div class="task-summary" id="task-summary" style="margin-top: 16px">
+          <!-- Populated by JS -->
+        </div>
         <table id="family-table" style="margin-top: 16px">
           <thead>
             <tr>
@@ -755,10 +816,10 @@
         );
 
         // Result
-        if (job.recorded !== null && job.recorded !== undefined) {
+        if (job.result !== null && job.result !== undefined) {
           document.getElementById("result-card").style.display = "block";
           document.getElementById("result-block").textContent = formatJson(
-            job.recorded,
+            job.result,
           );
         }
 
@@ -815,10 +876,21 @@
 
           familyData = await res.json();
 
-          // Only show DAG if there's more than one job in the family
-          if (familyData.jobs && familyData.jobs.length > 1) {
+          // Find the current job in the family
+          const currentJob = familyData.jobs.find((j) => j.id === jobId);
+
+          // Only show family view if:
+          // 1. Current job is the root (no parent_id) AND has children
+          // 2. Don't show for child jobs - they should just see their own info
+          const isRoot = currentJob && !currentJob.parent_id;
+          const hasChildren = familyData.jobs.some(
+            (j) => j.parent_id === jobId,
+          );
+
+          if (isRoot && familyData.jobs.length > 1) {
             document.getElementById("family-card").style.display = "block";
             renderDAG(familyData.jobs);
+            renderTaskSummary(familyData.jobs);
             renderFamilyTable(familyData.jobs);
           }
         } catch (err) {
@@ -1190,6 +1262,149 @@
         );
       }
 
+      function renderTaskSummary(jobs) {
+        const container = document.getElementById("task-summary");
+        const allStates = [
+          "completed",
+          "running",
+          "available",
+          "scheduled",
+          "failed",
+          "discarded",
+        ];
+        const stateLabels = {
+          completed: "Done",
+          running: "Run",
+          available: "Avail",
+          scheduled: "Sched",
+          failed: "Fail",
+          discarded: "Disc",
+        };
+
+        function fmtDur(ms) {
+          if (ms < 1000) return Math.round(ms) + "ms";
+          if (ms < 60000) return (ms / 1000).toFixed(1) + "s";
+          if (ms < 3600000) return (ms / 60000).toFixed(1) + "m";
+          return (ms / 3600000).toFixed(1) + "h";
+        }
+
+        const taskStats = {};
+        let totals = { total: 0, durations: [] };
+        allStates.forEach((s) => (totals[s] = 0));
+
+        jobs.forEach((job) => {
+          const taskName = job.task_name;
+          if (!taskStats[taskName]) {
+            taskStats[taskName] = { total: 0, durations: [] };
+            allStates.forEach((s) => (taskStats[taskName][s] = 0));
+          }
+          taskStats[taskName].total++;
+          taskStats[taskName][job.state] =
+            (taskStats[taskName][job.state] || 0) + 1;
+          totals.total++;
+          totals[job.state] = (totals[job.state] || 0) + 1;
+
+          // Include timing for completed, failed, and discarded jobs
+          if (
+            ["completed", "failed", "discarded"].includes(job.state) &&
+            job.attempted_at &&
+            job.completed_at
+          ) {
+            const duration =
+              new Date(job.completed_at) - new Date(job.attempted_at);
+            taskStats[taskName].durations.push(duration);
+            totals.durations.push(duration);
+          }
+        });
+
+        // Show all state columns for consistency
+        const states = allStates;
+
+        function calcDurationStats(durations) {
+          if (durations.length === 0) return null;
+          const sorted = durations.slice().sort((a, b) => a - b);
+          const sum = sorted.reduce((a, b) => a + b, 0);
+          const p95Index = Math.floor(sorted.length * 0.95);
+          return {
+            avg: sum / sorted.length,
+            p95: sorted[Math.min(p95Index, sorted.length - 1)],
+          };
+        }
+
+        const taskNames = Object.keys(taskStats).sort();
+        const headerCells = states
+          .map((s) => `<th class="stat-cell">${stateLabels[s]}</th>`)
+          .join("");
+
+        const rows = taskNames
+          .map((taskName) => {
+            const stats = taskStats[taskName];
+            const shortName = taskName.split(".").pop();
+            const ds = calcDurationStats(stats.durations);
+
+            const statCells = states
+              .map((s) => {
+                const count = stats[s] || 0;
+                if (count === 0) return `<td class="stat-cell">-</td>`;
+                const pct =
+                  stats.total > 0 ? Math.round((count / stats.total) * 100) : 0;
+                return `<td class="stat-cell"><span class="count">${count}</span><span class="pct">(${pct}%)</span></td>`;
+              })
+              .join("");
+
+            const timing = ds
+              ? `${fmtDur(ds.avg)}<span class="timing-range"> (${fmtDur(ds.p95)})</span>`
+              : "-";
+
+            return `<tr>
+            <td class="task-name" title="${taskName}">${shortName}</td>
+            <td class="stat-cell">${stats.total}</td>
+            ${statCells}
+            <td class="stat-cell timing-cell">${timing}</td>
+          </tr>`;
+          })
+          .join("");
+
+        const tds = calcDurationStats(totals.durations);
+        const totalCells = states
+          .map((s) => {
+            const count = totals[s] || 0;
+            if (count === 0) return `<td class="stat-cell">-</td>`;
+            const pct =
+              totals.total > 0 ? Math.round((count / totals.total) * 100) : 0;
+            return `<td class="stat-cell"><span class="count">${count}</span><span class="pct">(${pct}%)</span></td>`;
+          })
+          .join("");
+
+        const totalTiming = tds
+          ? `${fmtDur(tds.avg)}<span class="timing-range"> (${fmtDur(tds.p95)})</span>`
+          : "-";
+
+        const totalRow = `<tr class="total-row">
+          <td>Total</td>
+          <td class="stat-cell">${totals.total}</td>
+          ${totalCells}
+          <td class="stat-cell timing-cell">${totalTiming}</td>
+        </tr>`;
+
+        container.innerHTML = `
+          <table>
+            <thead>
+              <tr>
+                <th>Task</th>
+                <th class="stat-cell">#</th>
+                ${headerCells}
+                <th class="stat-cell">Avg (p95)</th>
+              </tr>
+            </thead>
+            <tbody>
+              ${rows}
+              ${totalRow}
+            </tbody>
+          </table>
+        `;
+      }
+
       function renderFamilyTable(jobs) {
         const tbody = document.querySelector("#family-table tbody");
 
@@ -1214,13 +1429,15 @@
             }
 
             let result = "-";
-            if (job.recorded !== null && job.recorded !== undefined) {
-              const recorded =
-                typeof job.recorded === "string"
-                  ? job.recorded
-                  : JSON.stringify(job.recorded);
+            if (job.result !== null && job.result !== undefined) {
+              const resultStr =
+                typeof job.result === "string"
+                  ? job.result
+                  : JSON.stringify(job.result);
               result =
-                recorded.length > 30 ? recorded.slice(0, 30) + "..." : recorded;
+                resultStr.length > 30
+                  ? resultStr.slice(0, 30) + "..."
+                  : resultStr;
             }
 
             return `

fairchild/ui.py

@@ -96,52 +96,32 @@ async def api_queues(request: web.Request) -> web.Response:
 
 
 async def api_tasks(request: web.Request) -> web.Response:
-    """Get list of registered tasks with parameter info."""
-    import inspect
-    from fairchild.task import _task_registry
+    """Get list of registered tasks from active workers."""
+    fairchild: Fairchild = request.app[_fairchild_key]
+
+    # Get tasks from workers that have heartbeated recently (alive)
+    query = """
+        SELECT tasks FROM fairchild_workers
+        WHERE last_heartbeat_at > now() - interval '30 seconds'
+          AND state != 'stopped'
+    """
+    rows = await fairchild._pool.fetch(query)
 
+    # Aggregate unique tasks from all workers
+    seen = set()
     tasks = []
-    for name, task in sorted(_task_registry.items()):
-        # Extract parameter info from function signature
-        sig = inspect.signature(task.fn)
-        params = []
-        for param_name, param in sig.parameters.items():
-            # Skip special injected parameters
-            if param_name in ("job", "workflow"):
-                continue
-
-            param_info = {"name": param_name}
-
-            # Add type annotation if present
-            if param.annotation != inspect.Parameter.empty:
-                try:
-                    param_info["type"] = param.annotation.__name__
-                except AttributeError:
-                    param_info["type"] = str(param.annotation)
-
-            # Add default value if present
-            if param.default != inspect.Parameter.empty:
-                param_info["default"] = param.default
-                param_info["required"] = False
-            else:
-                param_info["required"] = True
-
-            params.append(param_info)
-
-        # Get docstring
-        docstring = inspect.getdoc(task.fn)
-
-        tasks.append(
-            {
-                "name": name,
-                "queue": task.queue,
-                "priority": task.priority,
-                "max_attempts": task.max_attempts,
-                "tags": task.tags,
-                "params": params,
-                "docstring": docstring,
-            }
-        )
+    for row in rows:
+        worker_tasks = row["tasks"] or []
+        # Handle case where tasks is a JSON string (asyncpg returns jsonb as parsed, but just in case)
+        if isinstance(worker_tasks, str):
+            worker_tasks = json.loads(worker_tasks)
+        for task in worker_tasks:
+            if task["name"] not in seen:
+                seen.add(task["name"])
+                tasks.append(task)
+
+    # Sort by name
+    tasks.sort(key=lambda t: t["name"])
 
     return web.json_response(tasks)
 
@@ -179,7 +159,7 @@ async def api_jobs(request: web.Request) -> web.Response:
             parent_id, deps,
             state, priority, scheduled_at,
             attempted_at, completed_at, attempt, max_attempts,
-            recorded, errors, tags,
+            result, errors, tags,
             inserted_at, updated_at
         FROM fairchild_jobs
         {where}
@@ -234,8 +214,8 @@ async def api_enqueue_job(request: web.Request) -> web.Response:
             "scheduled_at": "ISO8601"
         }
     """
-    from datetime import datetime
-    from fairchild.task import get_task
+    from datetime import datetime, timezone
+    from fairchild.job import Job, JobState
 
     fairchild: Fairchild = request.app[_fairchild_key]
 
@@ -249,10 +229,27 @@ async def api_enqueue_job(request: web.Request) -> web.Response:
     if not task_name:
         return web.json_response({"error": "Missing required field: task"}, status=400)
 
-    # Look up the task
-    try:
-        task = get_task(task_name)
-    except ValueError:
+    # Look up the task from active workers
+    query = """
+        SELECT tasks FROM fairchild_workers
+        WHERE last_heartbeat_at > now() - interval '30 seconds'
+          AND state != 'stopped'
+    """
+    rows = await fairchild._pool.fetch(query)
+
+    task_info = None
+    for row in rows:
+        worker_tasks = row["tasks"] or []
+        if isinstance(worker_tasks, str):
+            worker_tasks = json.loads(worker_tasks)
+        for t in worker_tasks:
+            if t["name"] == task_name:
+                task_info = t
+                break
+        if task_info:
+            break
+
+    if not task_info:
         return web.json_response({"error": f"Unknown task: {task_name}"}, status=404)
 
     # Parse optional fields
@@ -278,14 +275,21 @@ async def api_enqueue_job(request: web.Request) -> web.Response:
                 {"error": "scheduled_at must be a valid ISO8601 datetime"}, status=400
             )
 
-    # Enqueue the job
+    # Create and insert the job directly using task info from workers
+    now = datetime.now(timezone.utc)
+    job = Job(
+        task_name=task_name,
+        queue=task_info["queue"],
+        args=args,
+        priority=priority if priority is not None else task_info["priority"],
+        max_attempts=task_info["max_attempts"],
+        tags=task_info.get("tags", []),
+        scheduled_at=scheduled_at or now,
+        state=JobState.AVAILABLE if scheduled_at is None else JobState.SCHEDULED,
+    )
+
     try:
-        job = await fairchild.enqueue(
-            task=task,
-            args=args,
-            priority=priority,
-            scheduled_at=scheduled_at,
-        )
+        await fairchild._insert_job(job)
     except Exception as e:
         return web.json_response({"error": f"Failed to enqueue job: {e}"}, status=500)
 
@@ -312,7 +316,7 @@ async def api_job_detail(request: web.Request) -> web.Response:
             parent_id, deps,
             state, priority, scheduled_at,
             attempted_at, completed_at, attempt, max_attempts,
-            recorded, errors, tags,
+            result, errors, tags,
             inserted_at, updated_at
         FROM fairchild_jobs
         WHERE id = $1
@@ -378,15 +382,15 @@ async def api_job_family(request: web.Request) -> web.Response:
     # Get all descendants from the root
     family_query = """
         WITH RECURSIVE family AS (
-            SELECT id, task_name, parent_id, state, deps, recorded,
-                   attempted_at, completed_at, attempt, max_attempts
+            SELECT id, task_name, parent_id, state, deps, result,
+                   attempted_at, completed_at, updated_at, attempt, max_attempts
             FROM fairchild_jobs
             WHERE id = $1
 
             UNION ALL
 
-            SELECT j.id, j.task_name, j.parent_id, j.state, j.deps, j.recorded,
-                   j.attempted_at, j.completed_at, j.attempt, j.max_attempts
+            SELECT j.id, j.task_name, j.parent_id, j.state, j.deps, j.result,
+                   j.attempted_at, j.completed_at, j.updated_at, j.attempt, j.max_attempts
             FROM fairchild_jobs j
             INNER JOIN family f ON j.parent_id = f.id
         )
@@ -405,6 +409,7 @@ async def api_job_family(request: web.Request) -> web.Response:
         job["completed_at"] = (
             job["completed_at"].isoformat() if job["completed_at"] else None
         )
+        job["updated_at"] = job["updated_at"].isoformat() if job["updated_at"] else None
         jobs.append(job)
 
     return web.json_response({"root_id": str(root_id), "jobs": jobs})

fairchild/worker.py

@@ -10,8 +10,7 @@ from uuid import uuid4
 from fairchild.context import set_current_job, get_pending_children
 from fairchild.fairchild import Fairchild
 from fairchild.job import Job, JobState
-from fairchild.record import Record
-from fairchild.task import get_task
+from fairchild.task import get_task, get_task_schemas
 
 
 class Worker:
@@ -120,9 +119,9 @@ class Worker:
                 # Check if this is a future marker
                 if "__future__" in obj and len(obj) == 1:
                     job_id = obj["__future__"]
-                    # Fetch the recorded result from the completed job
+                    # Fetch the result from the completed job
                     query = """
-                        SELECT recorded FROM fairchild_jobs
+                        SELECT result FROM fairchild_jobs
                         WHERE id = $1 AND state = 'completed'
                     """
                     from uuid import UUID
@@ -180,19 +179,23 @@ class Worker:
             for child_job in pending_children:
                 await self.fairchild._insert_job(child_job)
 
-            # Handle Record() return values
-            recorded_value = None
-            if isinstance(result, Record):
-                recorded_value = result.value
+            # Try to capture the return value as JSON
+            result_value = None
+            if result is not None:
+                try:
+                    json.dumps(result)  # Test if serializable
+                    result_value = result
+                except (TypeError, ValueError):
+                    pass  # Not JSON-serializable, skip
 
             # Check if this job spawned children - if so, wait for them
             has_children = len(pending_children) > 0
             if has_children:
                 # Keep job in running state, it will be completed when children finish
-                await self._mark_waiting_for_children(job, recorded_value)
+                await self._mark_waiting_for_children(job, result_value)
                 print(f"[{self.name}] Job {job.id} waiting for children to complete")
             else:
-                await self._complete_job(job, recorded_value)
+                await self._complete_job(job, result_value)
                 print(f"[{self.name}] Completed job {job.id}")
 
         except Exception as e:
@@ -214,19 +217,19 @@ class Worker:
                     f"[{self.name}] Job {job.id} failed (attempt {job.attempt}/{job.max_attempts}): {e}"
                 )
 
-    async def _complete_job(self, job: Job, recorded: Any | None):
+    async def _complete_job(self, job: Job, result: Any | None):
         """Mark a job as completed."""
         query = """
             UPDATE fairchild_jobs
             SET state = 'completed',
                 completed_at = now(),
-                recorded = $2,
+                result = $2,
                 updated_at = now()
             WHERE id = $1
         """
 
-        recorded_json = json.dumps(recorded) if recorded is not None else None
-        await self.fairchild._pool.execute(query, job.id, recorded_json)
+        result_json = json.dumps(result) if result is not None else None
+        await self.fairchild._pool.execute(query, job.id, result_json)
 
         # Check if this completion unblocks jobs waiting on this one
         await self._check_child_deps(job)
@@ -246,17 +249,17 @@ class Worker:
         """
         return await self.fairchild._pool.fetchval(query, job.id)
 
-    async def _mark_waiting_for_children(self, job: Job, recorded: Any | None):
+    async def _mark_waiting_for_children(self, job: Job, result: Any | None):
         """Mark a job as waiting for children (stays in running state but stores result)."""
-        # Store the recorded value so we can use it when completing later
+        # Store the result value so we can use it when completing later
         query = """
             UPDATE fairchild_jobs
-            SET recorded = $2,
+            SET result = $2,
                 updated_at = now()
             WHERE id = $1
         """
-        recorded_json = json.dumps(recorded) if recorded is not None else None
-        await self.fairchild._pool.execute(query, job.id, recorded_json)
+        result_json = json.dumps(result) if result is not None else None
+        await self.fairchild._pool.execute(query, job.id, result_json)
 
     async def _check_parent_completion(self, parent_id):
         """Check if a parent job can be completed (all children done)."""
@@ -326,6 +329,7 @@ class Worker:
                 UPDATE fairchild_jobs
                 SET state = $2,
                     errors = errors || $3::jsonb,
+                    completed_at = now(),
                     updated_at = now()
                 WHERE id = $1
             """
@@ -338,7 +342,7 @@ class Worker:
         else:
             query = """
                 UPDATE fairchild_jobs
-                SET state = $2, updated_at = now()
+                SET state = $2, completed_at = now(), updated_at = now()
                 WHERE id = $1
             """
             await self.fairchild._pool.execute(query, job.id, new_state)
@@ -398,26 +402,30 @@ class WorkerPool:
     async def _register(self):
         """Register this worker pool in the database."""
         query = """
-            INSERT INTO fairchild_workers (id, hostname, pid, queues, state)
-            VALUES ($1, $2, $3, $4::jsonb, 'running')
+            INSERT INTO fairchild_workers (id, hostname, pid, queues, tasks, state)
+            VALUES ($1, $2, $3, $4::jsonb, $5::jsonb, 'running')
             ON CONFLICT (id) DO UPDATE SET
                 hostname = EXCLUDED.hostname,
                 pid = EXCLUDED.pid,
                 queues = EXCLUDED.queues,
+                tasks = EXCLUDED.tasks,
                 state = 'running',
                 last_heartbeat_at = now()
         """
         # asyncpg requires JSON as a string for jsonb columns
         import json as json_module
 
+        tasks = get_task_schemas()
         await self.fairchild._pool.execute(
             query,
             self.id,
             self.hostname,
             self.pid,
             json_module.dumps(self.queue_config),
+            json_module.dumps(tasks),
         )
         print(f"Registered worker pool {self.id} ({self.hostname}:{self.pid})")
+        print(f"  Tasks: {[t['name'] for t in tasks]}")
 
     async def _heartbeat_loop(self):
         """Periodically send heartbeats and check for pause state."""

{fairchild-0.0.4.dist-info → fairchild-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairchild
-Version: 0.0.4
+Version: 0.0.6
 Summary: Workflow scheduling with PostgreSQL
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

fairchild-0.0.6.dist-info/RECORD

@@ -0,0 +1,25 @@
+fairchild/__init__.py,sha256=80mYyoeUFY-85M5lipyZE-4QPTdJ2fqM6KsFUqAyytw,159
+fairchild/cli.py,sha256=LOrF4e6LgMasWGmeRpciD6iDptC3IiiVF53Ll-TzN8M,9895
+fairchild/context.py,sha256=64yEo5Cj4LeBT6LQd2UdN00tM7SXSd2Vw_dM4RV1u68,1757
+fairchild/fairchild.py,sha256=QxGPvkhedyaEtjtdavIONgfX3O4H5BKo1hG1T2WFNJ4,4451
+fairchild/future.py,sha256=SeVm_6Ds4k3qdwpKnFl71Qknx9tRM9v3UWZ_tJCp7cw,2302
+fairchild/job.py,sha256=_ilXLHg1aQOM4xOUZArT-UDGzPQnKVDYKvru4Qz1MXs,3767
+fairchild/task.py,sha256=TsOjs2UYt8qN8WV3YxOP_4ppzBARh4ySz4eM1O9z4II,8135
+fairchild/ui.py,sha256=apOUmn7HZYg06F4J-Sf4EteV97U6YVmcFvE8fiHX7GI,18213
+fairchild/worker.py,sha256=OIv_NnKHU3fZuIQvDZqvcJ7-2EOvmfIctksxAuEzu_8,17421
+fairchild/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fairchild/db/migrations.py,sha256=tL5UPqllCipYC-XcEH_4ZfaRZLtJKaPACp70ZusvEvg,2174
+fairchild/db/migrations/001_initial.sql,sha256=FFObm3bIHdASd3d7lXzuAzWsmkCm3OAO2F63pw6HcMs,1711
+fairchild/db/migrations/002_add_parent_id.sql,sha256=ftDT053BaMnXX42aDxTtHnRnAgNKzIaUd1Fz_sO6LyQ,295
+fairchild/db/migrations/003_remove_workflows.sql,sha256=6svXO2nM7JiO-QHXfzIJCd6DeOSZ0AFQDsuQgPPv4IY,368
+fairchild/db/migrations/004_add_workers.sql,sha256=SOvHykAinr_O9gDf7kllEUZ57pw-USoHUsYLCfQumMI,714
+fairchild/db/migrations/005_add_worker_tasks.sql,sha256=0VJA5HBE2Aidjmk72nqLzreWA8A2jRDZsg1-6rcqTzo,186
+fairchild/db/migrations/006_rename_recorded_to_result.sql,sha256=LAKa_VnK5hXIeUY9rJNWlOYGz5hBV7ttHuKHlevWCjY,97
+fairchild/templates/dashboard.html,sha256=2kF3RLUMuZqQWbdlV-GPvYsBD8JnA_nWf4lBqRt60Sc,50071
+fairchild/templates/job.html,sha256=ptliW9AGguv0EaouSH5HFWfz-JqpuTj17ih8LbR2eQw,45059
+fairchild-0.0.6.dist-info/licenses/LICENSE,sha256=ad6qehkQLI1ax2pV6ocs7YePX06CPLBs3SThRbNC0q0,1068
+fairchild-0.0.6.dist-info/METADATA,sha256=mBRHxvdGvnjGhRoFvAT_FnnfrAwbqqINfV5M4RwvIfk,11006
+fairchild-0.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fairchild-0.0.6.dist-info/entry_points.txt,sha256=urOgjfuYex5__jBX91srCX8T5GgHvYZDPpWYkuA7z90,49
+fairchild-0.0.6.dist-info/top_level.txt,sha256=_2zkPnqS4i3JjLMpxRPDrBS0a04KBXZiD1NHFv7CO4U,10
+fairchild-0.0.6.dist-info/RECORD,,

fairchild/record.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass(frozen=True)
-class Record:
-    """Wrapper to indicate a task's return value should be persisted.
-
-    Usage:
-        @task(queue="default")
-        def my_task(item_id: int):
-            result = process(item_id)
-            return Record({"item_id": item_id, "result": result})
-
-    The recorded value will be stored in the job's `recorded` column
-    and can be retrieved by downstream jobs in a workflow.
-    """
-
-    value: Any
-
-    def __repr__(self) -> str:
-        return f"Record({self.value!r})"

fairchild-0.0.4.dist-info/RECORD

@@ -1,24 +0,0 @@
-fairchild/__init__.py,sha256=Q7FvQFBPDM12tf2hAg_nlROSdg7dYIXWnDwyqX-6mLU,209
-fairchild/cli.py,sha256=H0Y1Zr6POsbnRCJIoMVh65jLYiPt9_-kPNP4_5MGrjQ,10077
-fairchild/context.py,sha256=64yEo5Cj4LeBT6LQd2UdN00tM7SXSd2Vw_dM4RV1u68,1757
-fairchild/fairchild.py,sha256=QxGPvkhedyaEtjtdavIONgfX3O4H5BKo1hG1T2WFNJ4,4451
-fairchild/future.py,sha256=SeVm_6Ds4k3qdwpKnFl71Qknx9tRM9v3UWZ_tJCp7cw,2302
-fairchild/job.py,sha256=_ilXLHg1aQOM4xOUZArT-UDGzPQnKVDYKvru4Qz1MXs,3767
-fairchild/record.py,sha256=DjTQgeE2YjjsU2nB3pegB0Njq1_sNWgJialPLZQ1k7c,575
-fairchild/task.py,sha256=Nwt8FxDV7PK4y4nMXingFPPmPX4HLhamlJrSacyXgIg,6964
-fairchild/ui.py,sha256=q7Bj60PAulMtt5KM3UvkFqpGJuKvc4P8Vv3RN5tIirs,17806
-fairchild/worker.py,sha256=cZzHLuE7CF9bTLy_59zUeZHQs_p7z2VUMJfcMZTjWLs,17045
-fairchild/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fairchild/db/migrations.py,sha256=tL5UPqllCipYC-XcEH_4ZfaRZLtJKaPACp70ZusvEvg,2174
-fairchild/db/migrations/001_initial.sql,sha256=FFObm3bIHdASd3d7lXzuAzWsmkCm3OAO2F63pw6HcMs,1711
-fairchild/db/migrations/002_add_parent_id.sql,sha256=ftDT053BaMnXX42aDxTtHnRnAgNKzIaUd1Fz_sO6LyQ,295
-fairchild/db/migrations/003_remove_workflows.sql,sha256=6svXO2nM7JiO-QHXfzIJCd6DeOSZ0AFQDsuQgPPv4IY,368
-fairchild/db/migrations/004_add_workers.sql,sha256=SOvHykAinr_O9gDf7kllEUZ57pw-USoHUsYLCfQumMI,714
-fairchild/templates/dashboard.html,sha256=Ng0q9iXGdDSo74ltABUupzjbKhqpofC8S3Zw7wXUmLA,50041
-fairchild/templates/job.html,sha256=Pg7hd5p8dU5XJeCW9SryvDbvcErY1AMrxYm0z8hldnA,38042
-fairchild-0.0.4.dist-info/licenses/LICENSE,sha256=ad6qehkQLI1ax2pV6ocs7YePX06CPLBs3SThRbNC0q0,1068
-fairchild-0.0.4.dist-info/METADATA,sha256=RKftba_0moODAJNOAQiwVeYtC6HmXJuKGerN4VyHZDE,11006
-fairchild-0.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-fairchild-0.0.4.dist-info/entry_points.txt,sha256=urOgjfuYex5__jBX91srCX8T5GgHvYZDPpWYkuA7z90,49
-fairchild-0.0.4.dist-info/top_level.txt,sha256=_2zkPnqS4i3JjLMpxRPDrBS0a04KBXZiD1NHFv7CO4U,10
-fairchild-0.0.4.dist-info/RECORD,,