Merge pull request #1304 from transformerlab/fix/improve-job-monitor-task-submit

Add Task Submit in CLI -- in job monitor and CLI commands

Author: aliasaria

cli/src/transformerlab_cli/commands/job_monitor/ExperimentSelectModal.py

@@ -36,6 +36,20 @@ class ExperimentSelectModal(ModalScreen):
         align: center middle;
         margin-bottom: 1;
     }
+    Select {
+        width: 100%;
+        height: auto;
+        min-height: 3;
+    }
+    Select > SelectCurrent {
+        width: 1fr;
+        height: auto;
+        min-height: 1;
+        padding: 0 1;
+    }
+    Select > SelectCurrent > Static {
+        width: 1fr;
+    }
     """
 
     BINDINGS = [("escape", "dismiss", "Close")]

cli/src/transformerlab_cli/commands/job_monitor/JobMonitorApp.py

@@ -80,7 +80,8 @@ def action_add_task(self) -> None:
         self.push_screen(TaskAddModal())
 
     def action_list_tasks(self) -> None:
-        self.push_screen(TaskListModal())
+        current_experiment = get_current_experiment() or "alpha"
+        self.push_screen(TaskListModal(experiment_id=current_experiment))
 
     def action_refresh(self) -> None:
         """Refresh the job list."""

cli/src/transformerlab_cli/commands/job_monitor/TaskListModal.py

@@ -6,13 +6,40 @@
     Button,
     OptionList,
     Input,
+    Switch,
+    Select,
 )
 from textual.widgets.option_list import Option
-from textual.containers import Vertical
+from textual.containers import Vertical, ScrollableContainer
 from textual.screen import ModalScreen
 from textual import work, on
 
 from transformerlab_cli.util import api
+from transformerlab_cli.commands.task import fetch_providers, build_launch_payload, launch_task_on_provider
+
+
+def _infer_param_type(value) -> str:
+    """Infer parameter type from a simple shorthand value."""
+    if isinstance(value, bool):
+        return "bool"
+    if isinstance(value, int):
+        return "int"
+    if isinstance(value, float):
+        return "float"
+    return "string"
+
+
+def _normalize_param(key: str, value) -> dict:
+    """Normalize a parameter definition to extended schema format."""
+    if isinstance(value, dict) and "type" in value:
+        schema = dict(value)
+        schema.setdefault("title", key)
+        return schema
+    return {
+        "type": _infer_param_type(value),
+        "default": value,
+        "title": key,
+    }
 
 
 class TaskQueueModal(ModalScreen):
@@ -23,13 +50,17 @@ class TaskQueueModal(ModalScreen):
         align: center middle;
     }
     #queue-modal {
-        width: 50%;
-        min-width: 40;
-        height: auto;
+        width: 60%;
+        min-width: 50;
+        max-height: 80%;
         padding: 2;
         border: round $primary;
         background: $panel;
     }
+    #queue-form-container {
+        height: 1fr;
+        max-height: 20;
+    }
     .form-row {
         height: auto;
         margin-bottom: 1;
@@ -41,37 +72,262 @@ class TaskQueueModal(ModalScreen):
     .form-input {
         width: 100%;
     }
+    Select {
+        width: 100%;
+        height: auto;
+        min-height: 3;
+    }
+    Select > SelectCurrent {
+        width: 1fr;
+        height: auto;
+        min-height: 1;
+        padding: 0 1;
+    }
+    Select > SelectCurrent > Static {
+        width: 1fr;
+    }
+    .form-switch {
+        height: auto;
+    }
     #queue-submit-btn {
         margin-top: 1;
         width: 100%;
     }
+    #queue-spinner {
+        height: 3;
+        display: none;
+    }
+    #queue-status {
+        text-align: center;
+        height: auto;
+    }
     """
 
     BINDINGS = [("escape", "dismiss", "Close")]
 
     def __init__(self, task_info: dict) -> None:
         super().__init__()
         self.task_info = task_info
+        self.param_widgets: dict[str, str] = {}
+        self.providers: list[dict] = []
+        self.selected_provider_id: str = task_info.get("provider_id", "")
 
     def compose(self) -> ComposeResult:
         task_name = self.task_info.get("name", "Unknown")
+        parameters = self.task_info.get("parameters", {})
+
         with Vertical(id="queue-modal"):
             yield Label(f"[b]Queue Task: {task_name}[/b]")
 
             with Vertical(classes="form-row"):
-                yield Label("CPU Resources:", classes="form-label")
-                yield Input(placeholder="e.g. 2", id="cpu-input", classes="form-input")
+                yield Label("Provider:", classes="form-label")
+                yield Select(
+                    [("Loading...", "_loading")],
+                    value="_loading",
+                    allow_blank=False,
+                    id="provider-select",
+                    classes="form-input",
+                )
+                # yield Label("[DEBUG] Selected: (none)", id="debug-provider-label")
 
-            with Vertical(classes="form-row"):
-                yield Label("Memory Resources:", classes="form-label")
-                yield Input(placeholder="e.g. 4GB", id="memory-input", classes="form-input")
+            with ScrollableContainer(id="queue-form-container"):
+                yield Label("[b]Task Parameters[/b]")
+                if not parameters:
+                    yield Label("[dim]No configurable parameters[/dim]")
+                else:
+                    for key, raw_value in parameters.items():
+                        schema = _normalize_param(key, raw_value)
+                        yield from self._render_param_field(key, schema)
 
             yield Button("Queue", id="queue-submit-btn", variant="primary")
+            yield LoadingIndicator(id="queue-spinner")
+            yield Label("", id="queue-status")
+
+    def on_mount(self) -> None:
+        self._fetch_providers_async()
+
+    @work(thread=True)
+    def _fetch_providers_async(self) -> None:
+        """Fetch available compute providers from the API."""
+        providers = fetch_providers()
+        self.app.call_from_thread(self.populate_providers, providers)
+
+    def populate_providers(self, providers: list[dict]) -> None:
+        """Populate the provider select widget."""
+        self.providers = providers
+        provider_select = self.query_one("#provider-select", Select)
+
+        if not providers:
+            with provider_select.prevent(Select.Changed):
+                provider_select.set_options([("No providers available", "_none")])
+                provider_select.value = "_none"
+            return
+
+        options = [(p.get("name", p.get("id")), p.get("id")) for p in providers]
+
+        task_provider_id = self.task_info.get("provider_id", "")
+        if task_provider_id and any(p.get("id") == task_provider_id for p in providers):
+            initial_value = task_provider_id
+        else:
+            initial_value = providers[0].get("id")
+
+        with provider_select.prevent(Select.Changed):
+            provider_select.set_options(options)
+            provider_select.value = initial_value
+
+        self.selected_provider_id = initial_value
+        # self._update_debug_label(initial_value)
+
+    # def _update_debug_label(self, value: str) -> None:
+    #     """Update the debug label with current selection."""
+    #     try:
+    #         debug_label = self.query_one("#debug-provider-label", Label)
+    #         provider_name = next((p.get("name") for p in self.providers if p.get("id") == value), value)
+    #         debug_label.update(f"[DEBUG] Selected: {provider_name} (id={value})")
+    #     except Exception:
+    #         pass
+
+    @on(Select.Changed, "#provider-select")
+    def on_provider_changed(self, event: Select.Changed) -> None:
+        if event.value != Select.BLANK:
+            self.selected_provider_id = str(event.value)
+            # self._update_debug_label(str(event.value))
+
+    def _render_param_field(self, key: str, schema: dict) -> ComposeResult:
+        """Render a single parameter field based on its schema."""
+        param_type = schema.get("type", "string")
+        title = schema.get("title", key)
+        default = schema.get("default", "")
+        ui_widget = schema.get("ui_widget")
+        options = schema.get("options", [])
+
+        widget_id = f"param-{key}"
+        self.param_widgets[key] = widget_id
+
+        with Vertical(classes="form-row"):
+            yield Label(f"{title}:", classes="form-label")
+
+            if param_type == "bool":
+                yield Switch(value=bool(default), id=widget_id, classes="form-switch")
+
+            elif param_type == "enum" or (ui_widget == "select" and options):
+                select_options = [(opt, opt) for opt in options]
+                yield Select(
+                    select_options,
+                    value=str(default) if default else Select.BLANK,
+                    id=widget_id,
+                    classes="form-input",
+                )
+
+            elif ui_widget == "password":
+                yield Input(
+                    value=str(default) if default else "",
+                    password=True,
+                    id=widget_id,
+                    classes="form-input",
+                )
+
+            else:
+                placeholder = ""
+                if param_type == "int":
+                    placeholder = f"Integer (default: {default})"
+                elif param_type == "float":
+                    placeholder = f"Float (default: {default})"
+                else:
+                    placeholder = f"default: {default}" if default else ""
+
+                yield Input(
+                    value=str(default) if default else "",
+                    placeholder=placeholder,
+                    id=widget_id,
+                    classes="form-input",
+                )
+
+    def _collect_param_values(self) -> dict:
+        """Collect current values from all parameter widgets."""
+        values = {}
+        parameters = self.task_info.get("parameters", {})
+
+        for key, raw_value in parameters.items():
+            schema = _normalize_param(key, raw_value)
+            widget_id = self.param_widgets.get(key)
+            if not widget_id:
+                continue
+
+            try:
+                widget = self.query_one(f"#{widget_id}")
+            except Exception:
+                continue
+
+            if isinstance(widget, Switch):
+                values[key] = widget.value
+            elif isinstance(widget, Select):
+                values[key] = widget.value if widget.value != Select.BLANK else schema.get("default", "")
+            elif isinstance(widget, Input):
+                raw = widget.value
+                param_type = schema.get("type", "string")
+                if param_type == "int":
+                    try:
+                        values[key] = int(raw) if raw else schema.get("default", 0)
+                    except ValueError:
+                        values[key] = schema.get("default", 0)
+                elif param_type == "float":
+                    try:
+                        values[key] = float(raw) if raw else schema.get("default", 0.0)
+                    except ValueError:
+                        values[key] = schema.get("default", 0.0)
+                else:
+                    values[key] = raw if raw else schema.get("default", "")
+
+        return values
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id == "queue-submit-btn":
-            self.notify("Queue functionality not implemented yet.", severity="information")
-            self.dismiss()
+            self._show_spinner(True, "Queuing task...")
+            self.queue_task()
+
+    def _show_spinner(self, show: bool, message: str = "") -> None:
+        """Show or hide the spinner and update status message."""
+        spinner = self.query_one("#queue-spinner", LoadingIndicator)
+        status = self.query_one("#queue-status", Label)
+        button = self.query_one("#queue-submit-btn", Button)
+
+        spinner.display = show
+        button.display = not show
+        status.update(message)
+
+    @work(thread=True)
+    def queue_task(self) -> None:
+        """Queue the task by calling the provider launch endpoint."""
+        param_values = self._collect_param_values()
+        task = self.task_info
+
+        provider_id = self.selected_provider_id
+        if not provider_id:
+            self.app.call_from_thread(self._show_spinner, False)
+            self.app.call_from_thread(self.notify, "Please select a provider before queuing.", severity="error")
+            return
+
+        selected_provider = next((p for p in self.providers if p.get("id") == provider_id), None)
+        provider_name = selected_provider.get("name") if selected_provider else task.get("provider_name")
+
+        payload = build_launch_payload(task, provider_name, param_values)
+
+        try:
+            data = launch_task_on_provider(provider_id, payload)
+            job_id = data.get("job_id", "unknown")
+            self.app.call_from_thread(
+                self.notify, f"Task queued successfully. Job ID: {job_id}", severity="information"
+            )
+            self.app.call_from_thread(self._dismiss_all_modals)
+        except RuntimeError as e:
+            self.app.call_from_thread(self._show_spinner, False)
+            self.app.call_from_thread(self.notify, str(e), severity="error")
+
+    def _dismiss_all_modals(self) -> None:
+        """Dismiss this modal and the parent TaskListModal to return to homepage."""
+        self.dismiss()
+        self.app.pop_screen()
 
 
 class TaskListModal(ModalScreen):
@@ -101,8 +357,9 @@ class TaskListModal(ModalScreen):
 
     BINDINGS = [("escape", "dismiss", "Close")]
 
-    def __init__(self) -> None:
+    def __init__(self, experiment_id: str = "default") -> None:
         super().__init__()
+        self.experiment_id = experiment_id
         self.tasks_data: list[dict] = []
 
     def compose(self) -> ComposeResult:
@@ -121,7 +378,7 @@ def on_mount(self) -> None:
     @work(thread=True)
     def fetch_tasks(self) -> None:
         try:
-            response = api.get("/tasks/list")
+            response = api.get(f"/experiment/{self.experiment_id}/task/list")
             if response.status_code == 200:
                 data = response.json()
             else:
@@ -145,11 +402,12 @@ def populate_tasks(self, tasks: list[dict]) -> None:
 
         self.tasks_data = tasks
         option_list.clear_options()
+        print("[DEBUG] Populating tasks:", tasks)
         for task in tasks:
             task_id = task.get("id", "?")
             task_name = task.get("name", "Unknown")
-            task_type = task.get("type", "N/A")
-            option_list.add_option(Option(f"{task_name} ({task_type})", id=task_id))
+            # task_type = task.get("type", "N/A")
+            option_list.add_option(Option(f"{task_name}", id=task_id))
 
     @on(OptionList.OptionSelected, "#task-option-list")
     def on_task_selected(self, event: OptionList.OptionSelected) -> None: