fairchild 0.0.4__tar.gz → 0.0.6__tar.gz

{fairchild-0.0.4 → fairchild-0.0.6}/PKG-INFO

@@ -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.4 → fairchild-0.0.6}/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-0.0.4 → fairchild-0.0.6}/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-0.0.6/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-0.0.6/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-0.0.4 → fairchild-0.0.6}/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-0.0.4 → fairchild-0.0.6}/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-0.0.4 → fairchild-0.0.6}/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 `