fairchild 0.0.4__tar.gz → 0.0.5__tar.gz

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

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

{fairchild-0.0.4 → fairchild-0.0.5}/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.5/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.4 → fairchild-0.0.5}/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,

{fairchild-0.0.4 → fairchild-0.0.5}/fairchild/templates/dashboard.html

@@ -354,13 +354,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,25 +1207,6 @@
         }
       }
 
-      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("");
-      }
-
       async function fetchJobs(state = "") {
         const url = state ? `/api/jobs?state=${state}` : "/api/jobs";
         const res = await fetch(url);
@@ -1462,7 +1436,6 @@
           fetchStats(),
           fetchQueues(),
           fetchWorkers(currentWorkerState),
-          fetchWorkflows(),
           fetchJobs(currentState),
           fetchTimeseries(),
         ]);
@@ -1484,14 +1457,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 +1475,6 @@
           option.textContent = `${task.name} (queue: ${task.queue})`;
           select.appendChild(option);
         });
-        tasksLoaded = true;
       }
 
       function onTaskSelected() {

{fairchild-0.0.4 → fairchild-0.0.5}/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)
 
@@ -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)
 

{fairchild-0.0.4 → fairchild-0.0.5}/fairchild/worker.py

@@ -11,7 +11,7 @@ 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:
@@ -398,26 +398,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 → fairchild-0.0.5}/fairchild.egg-info/PKG-INFO

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

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

@@ -23,6 +23,7 @@ fairchild/db/migrations/001_initial.sql
 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/templates/dashboard.html
 fairchild/templates/job.html
 tests/test_cli.py

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

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

{fairchild-0.0.4 → fairchild-0.0.5}/tests/test_web_ui.py

@@ -50,6 +50,39 @@ async def client(fairchild_app):
         yield client
 
 
+@pytest_asyncio.fixture
+async def client_with_worker(fairchild_app):
+    """Create a test client with a simulated worker registration."""
+    import json
+    from uuid import uuid4
+    from fairchild.task import get_task_schemas
+    from fairchild.ui import _fairchild_key
+
+    # Import tasks to register them in _task_registry
+    import examples.tasks  # noqa: F401
+
+    fairchild = fairchild_app[_fairchild_key]
+
+    # Register a fake worker with task schemas (simulates what real workers do)
+    worker_id = uuid4()
+    tasks = get_task_schemas()
+    query = """
+        INSERT INTO fairchild_workers (id, hostname, pid, queues, tasks, state)
+        VALUES ($1, $2, $3, $4::jsonb, $5::jsonb, 'running')
+    """
+    await fairchild._pool.execute(
+        query,
+        worker_id,
+        "test-host",
+        12345,
+        json.dumps({"default": 1}),
+        json.dumps(tasks),
+    )
+
+    async with TestClient(TestServer(fairchild_app)) as client:
+        yield client
+
+
 @pytest.mark.asyncio
 async def test_dashboard_returns_html(client):
     """Test that the dashboard endpoint returns HTML."""
@@ -121,12 +154,9 @@ async def test_api_timeseries_returns_data(client):
 
 
 @pytest.mark.asyncio
-async def test_enqueue_job_via_api(client):
+async def test_enqueue_job_via_api(client_with_worker):
     """Test enqueuing a job through the JSON API."""
-    # Import tasks to register them
-    import examples.tasks  # noqa: F401
-
-    resp = await client.post(
+    resp = await client_with_worker.post(
         "/api/jobs", json={"task": "examples.tasks.add", "args": {"a": 10, "b": 20}}
     )
     assert resp.status == 201
@@ -137,12 +167,10 @@ async def test_enqueue_job_via_api(client):
 
 
 @pytest.mark.asyncio
-async def test_enqueue_and_fetch_job(client):
+async def test_enqueue_and_fetch_job(client_with_worker):
     """Test enqueuing a job and fetching its details."""
-    import examples.tasks  # noqa: F401
-
     # Enqueue a job
-    resp = await client.post(
+    resp = await client_with_worker.post(
         "/api/jobs", json={"task": "examples.tasks.hello", "args": {"name": "TestUser"}}
     )
     assert resp.status == 201
@@ -150,7 +178,7 @@ async def test_enqueue_and_fetch_job(client):
     job_id = enqueue_data["id"]
 
     # Fetch the job details
-    resp = await client.get(f"/api/jobs/{job_id}")
+    resp = await client_with_worker.get(f"/api/jobs/{job_id}")
     assert resp.status == 200
     job_data = await resp.json()
     assert job_data["id"] == job_id
@@ -165,19 +193,17 @@ async def test_enqueue_and_fetch_job(client):
 
 
 @pytest.mark.asyncio
-async def test_job_page_returns_html(client):
+async def test_job_page_returns_html(client_with_worker):
     """Test that the job detail page returns HTML."""
-    import examples.tasks  # noqa: F401
-
     # First enqueue a job to get a valid ID
-    resp = await client.post(
+    resp = await client_with_worker.post(
         "/api/jobs", json={"task": "examples.tasks.add", "args": {"a": 1, "b": 2}}
     )
     data = await resp.json()
     job_id = data["id"]
 
     # Fetch the job page
-    resp = await client.get(f"/jobs/{job_id}")
+    resp = await client_with_worker.get(f"/jobs/{job_id}")
     assert resp.status == 200
     assert resp.content_type == "text/html"
     text = await resp.text()