fairchild 0.0.5__tar.gz → 0.0.7__tar.gz

{fairchild-0.0.5 → fairchild-0.0.7}/PKG-INFO

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

{fairchild-0.0.5 → fairchild-0.0.7}/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.7/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.5 → fairchild-0.0.7}/fairchild/fairchild.py

@@ -146,12 +146,12 @@ class Fairchild:
 
         return Job.from_row(dict(row))
 
-    async def get_recorded(self, job_id: UUID) -> Any:
-        """Get the recorded value from a completed job."""
+    async def get_result(self, job_id: UUID) -> Any:
+        """Get the result value from a completed job."""
         await self._ensure_connected()
 
         query = """
-            SELECT recorded FROM fairchild_jobs
+            SELECT result FROM fairchild_jobs
             WHERE id = $1
         """
 
@@ -159,8 +159,8 @@ class Fairchild:
         if row is None:
             return None
 
-        recorded = row["recorded"]
-        if recorded is None:
+        result = row["result"]
+        if result is None:
             return None
 
-        return json.loads(recorded) if isinstance(recorded, str) else recorded
+        return json.loads(result) if isinstance(result, str) else result

{fairchild-0.0.5 → fairchild-0.0.7}/fairchild/job.py

@@ -57,7 +57,7 @@ class Job:
     max_attempts: int = 3
 
     # Results & errors
-    recorded: Any | None = None
+    result: Any | None = None
     errors: list[dict[str, Any]] = field(default_factory=list)
 
     # Metadata
@@ -90,7 +90,7 @@ class Job:
             completed_at=row["completed_at"],
             attempt=row["attempt"],
             max_attempts=row["max_attempts"],
-            recorded=_parse_json(row["recorded"]),
+            result=_parse_json(row["result"]),
             errors=_parse_json(row["errors"]) or [],
             tags=row.get("tags") or [],
             meta=_parse_json(row.get("meta")) or {},
@@ -114,7 +114,7 @@ class Job:
             "completed_at": self.completed_at,
             "attempt": self.attempt,
             "max_attempts": self.max_attempts,
-            "recorded": self.recorded,
+            "result": self.result,
             "errors": self.errors,
             "tags": self.tags,
             "meta": self.meta,

{fairchild-0.0.5 → fairchild-0.0.7}/fairchild/task.py

@@ -74,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)
@@ -197,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.5 → fairchild-0.0.7}/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;
@@ -1207,6 +1217,12 @@
         }
       }
 
+      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 = "") {
         const url = state ? `/api/jobs?state=${state}` : "/api/jobs";
         const res = await fetch(url);
@@ -1214,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("");
       }
 

{fairchild-0.0.5 → fairchild-0.0.7}/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-0.0.5 → fairchild-0.0.7}/fairchild/ui.py

@@ -159,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}
@@ -316,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
@@ -382,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
         )
@@ -409,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-0.0.5 → fairchild-0.0.7}/fairchild/worker.py

@@ -10,7 +10,6 @@ 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, get_task_schemas
 
 
@@ -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)

{fairchild-0.0.5 → fairchild-0.0.7}/fairchild.egg-info/PKG-INFO

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

{fairchild-0.0.5 → fairchild-0.0.7}/fairchild.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ fairchild/context.py
 fairchild/fairchild.py
 fairchild/future.py
 fairchild/job.py
-fairchild/record.py
 fairchild/task.py
 fairchild/ui.py
 fairchild/worker.py
@@ -24,11 +23,11 @@ fairchild/db/migrations/002_add_parent_id.sql
 fairchild/db/migrations/003_remove_workflows.sql
 fairchild/db/migrations/004_add_workers.sql
 fairchild/db/migrations/005_add_worker_tasks.sql
+fairchild/db/migrations/006_rename_recorded_to_result.sql
 fairchild/templates/dashboard.html
 fairchild/templates/job.html
 tests/test_cli.py
 tests/test_integration.py
 tests/test_job.py
-tests/test_record.py
 tests/test_task.py
 tests/test_web_ui.py

{fairchild-0.0.5 → fairchild-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fairchild"
-version = "0.0.5"
+version = "0.0.7"
 description = "Workflow scheduling with PostgreSQL"
 readme = "README.md"
 requires-python = ">=3.13"

{fairchild-0.0.5 → fairchild-0.0.7}/tests/test_cli.py

@@ -1,4 +1,5 @@
 """Integration tests for the fairchild CLI."""
+
 import subprocess
 import sys
 import os
@@ -8,29 +9,33 @@ def test_fairchild_run_command():
     """Test the 'fairchild run' command with orchestrator_n example."""
     # Set PYTHONPATH to include current directory
     env = os.environ.copy()
-    env['PYTHONPATH'] = '.'
-    
+    env["PYTHONPATH"] = "."
+
     # Get the repository root (assuming tests/ is in repo root)
     repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    
+
     # Run the command
     result = subprocess.run(
         [
-            sys.executable, '-m', 'fairchild.cli',
-            'run',
-            '-i', 'examples.tasks',
-            'examples.tasks.orchestrator_n',
-            '-a', 'n_items=2'
+            sys.executable,
+            "-m",
+            "fairchild.cli",
+            "run",
+            "-i",
+            "examples.tasks",
+            "examples.tasks.orchestrator_n",
+            "-a",
+            "n_items=2",
         ],
         cwd=repo_root,
         capture_output=True,
         text=True,
-        env=env
+        env=env,
     )
-    
+
     # Check it ran successfully
     assert result.returncode == 0, f"Command failed with: {result.stderr}"
-    
+
     # Check expected output
     output = result.stdout
     assert "Invoking examples.tasks.orchestrator_n..." in output
@@ -38,32 +43,36 @@ def test_fairchild_run_command():
     assert "0 * 2 = 0" in output
     assert "1 * 2 = 2" in output
     assert "Summing [0, 2] = 2" in output
-    assert "Result: Record({'spawned': 3})" in output or "Result: Record(value={'spawned': 3})" in output
+    assert "Result: {'spawned': 3}" in output
 
 
 def test_fairchild_run_hello():
     """Test the 'fairchild run' command with a simple hello task."""
     env = os.environ.copy()
-    env['PYTHONPATH'] = '.'
-    
+    env["PYTHONPATH"] = "."
+
     repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    
+
     result = subprocess.run(
         [
-            sys.executable, '-m', 'fairchild.cli',
-            'run',
-            '-i', 'examples.tasks',
-            'examples.tasks.hello',
-            '-a', 'name=World'
+            sys.executable,
+            "-m",
+            "fairchild.cli",
+            "run",
+            "-i",
+            "examples.tasks",
+            "examples.tasks.hello",
+            "-a",
+            "name=World",
         ],
         cwd=repo_root,
         capture_output=True,
         text=True,
-        env=env
+        env=env,
     )
-    
+
     assert result.returncode == 0, f"Command failed with: {result.stderr}"
-    
+
     output = result.stdout
     assert "Invoking examples.tasks.hello..." in output
     assert "Hello, World!" in output
@@ -74,27 +83,32 @@ def test_fairchild_run_hello():
 def test_fairchild_run_add():
     """Test the 'fairchild run' command with add task."""
     env = os.environ.copy()
-    env['PYTHONPATH'] = '.'
-    
+    env["PYTHONPATH"] = "."
+
     repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    
+
     result = subprocess.run(
         [
-            sys.executable, '-m', 'fairchild.cli',
-            'run',
-            '-i', 'examples.tasks',
-            'examples.tasks.add',
-            '-a', 'a=5',
-            '-a', 'b=3'
+            sys.executable,
+            "-m",
+            "fairchild.cli",
+            "run",
+            "-i",
+            "examples.tasks",
+            "examples.tasks.add",
+            "-a",
+            "a=5",
+            "-a",
+            "b=3",
         ],
         cwd=repo_root,
         capture_output=True,
         text=True,
-        env=env
+        env=env,
     )
-    
+
     assert result.returncode == 0, f"Command failed with: {result.stderr}"
-    
+
     output = result.stdout
     assert "Invoking examples.tasks.add..." in output
     assert "5 + 3 = 8" in output

{fairchild-0.0.5 → fairchild-0.0.7}/tests/test_task.py

@@ -1,14 +1,15 @@
 """Tests for task registration and task decorator."""
-from fairchild import task, Record
+
+from fairchild import task
 
 
 def test_task_decorator():
     """Test that the @task decorator creates a Task object."""
-    
+
     @task(queue="test", priority=1)
-    def simple_task(x: int) -> Record:
-        return Record({"result": x * 2})
-    
+    def simple_task(x: int) -> dict:
+        return {"result": x * 2}
+
     # Check that task has expected attributes
     assert simple_task.queue == "test"
     assert simple_task.priority == 1
@@ -16,20 +17,15 @@ def test_task_decorator():
     # Task name includes full module path
     assert "simple_task" in simple_task.name
     assert simple_task.name.endswith(".simple_task")
-    
+
 
 def test_task_with_custom_settings():
     """Test task with all custom settings."""
-    
-    @task(
-        queue="custom",
-        priority=9,
-        max_attempts=5,
-        tags=["test", "custom"]
-    )
+
+    @task(queue="custom", priority=9, max_attempts=5, tags=["test", "custom"])
     def custom_task() -> None:
         pass
-    
+
     assert custom_task.queue == "custom"
     assert custom_task.priority == 9
     assert custom_task.max_attempts == 5
@@ -38,25 +34,24 @@ def test_task_with_custom_settings():
 
 def test_task_execution_without_worker():
     """Test that tasks can be called directly when not in a worker context."""
-    
+
     @task()
-    def add_numbers(a: int, b: int) -> Record:
-        return Record({"sum": a + b})
-    
+    def add_numbers(a: int, b: int) -> dict:
+        return {"sum": a + b}
+
     # When called directly (not in a worker), should execute the function
     result = add_numbers(5, 3)
-    
-    # Record should be unwrapped in direct calls
+
     assert result == {"sum": 8}
 
 
 def test_task_name_derivation():
     """Test that task names are derived from module and function."""
-    
+
     @task()
     def my_function():
         pass
-    
+
     # Should include module and function name
     assert "my_function" in my_function.name
     assert my_function.name.endswith(".my_function")

fairchild-0.0.5/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.5/tests/test_record.py

@@ -1,40 +0,0 @@
-"""Tests for Record class."""
-from fairchild import Record
-
-
-def test_record_creation():
-    """Test creating a Record with a value."""
-    record = Record({"key": "value"})
-    
-    assert record.value == {"key": "value"}
-
-
-def test_record_with_dict():
-    """Test Record with dictionary value."""
-    data = {"name": "test", "count": 42}
-    record = Record(data)
-    
-    assert record.value == data
-    assert record.value["name"] == "test"
-    assert record.value["count"] == 42
-
-
-def test_record_with_list():
-    """Test Record with list value."""
-    data = [1, 2, 3, 4, 5]
-    record = Record(data)
-    
-    assert record.value == data
-    assert len(record.value) == 5
-
-
-def test_record_with_primitive():
-    """Test Record with primitive value."""
-    record_int = Record(42)
-    assert record_int.value == 42
-    
-    record_str = Record("hello")
-    assert record_str.value == "hello"
-    
-    record_bool = Record(True)
-    assert record_bool.value is True