from __future__ import annotations from io import BytesIO from datetime import datetime from dataclasses import replace import json from pathlib import Path import re import shutil import sys from PySide6.QtCore import QDateTime, QThread, QTimer, Qt, QUrl, Signal from PySide6.QtGui import QCloseEvent, QDesktopServices, QIcon, QPixmap from PySide6.QtWidgets import ( QAbstractItemView, QApplication, QCheckBox, QComboBox, QDialog, QDialogButtonBox, QDateTimeEdit, QDoubleSpinBox, QFileDialog, QFrame, QGridLayout, QGroupBox, QHBoxLayout, QHeaderView, QLabel, QLineEdit, QListWidget, QListWidgetItem, QMainWindow, QMessageBox, QPlainTextEdit, QProgressBar, QPushButton, QScrollArea, QSizePolicy, QSpinBox, QStackedWidget, QSystemTrayIcon, QTabBar, QTabWidget, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget, ) from adam.config import ConfigManager from adam.assets import Asset from adam.ui.background import BackgroundRead from adam.ui.asset_refresh import asset_refresh from adam.dataset_lab import scan_dataset from adam.cnn_reviewer import reviewer_checkpoint, score_frames, train_reviewer from adam.experiment_tracker import ExperimentStore, ExperimentRun from adam.generations import ( ChatGenerationRequest, build_generation_plan, generation_model_match_score, generation_tools, parse_chat_generation_request, ) from adam.model_inspector import ModelComparison, ModelInspection, compare_models, inspect_model from adam.model_inspector.statistics import bytes_label, shape_label from adam.external_tools import ( ExternalToolStore, ToolAnalysis, analyze_selection, scan_folder, ) from adam.job_manager import JobManager from adam.models import Job, JobStatus, SystemSnapshot from adam.model_plugins import ModelPluginError, safe_plugin_id, scaffold_model_plugin from adam.model_profiles import ModelProfileRegistry from adam.monitoring import SystemMonitor from adam.orion import dataset_image_count, recommend_training_settings from adam.ollama import OllamaClient from adam.planner import Planner, PlanningError from adam.progressive_training import parse_stages, suggested_stages from adam.recommendations import recommend_for_profile from adam.remote_access import ( REMOTE_MODE_DISABLED, REMOTE_MODE_LOCAL, REMOTE_MODE_TAILSCALE, RemoteAccessService, remote_scope, ) from adam.registry import ToolRegistry from adam.studio import StudioStore from adam.tool_folders import ToolFolderManager, ToolFolderStatus from adam.transcript_dataset import available_transcription_backends, transcript_videos_to_dataset from adam.training_assistant import ( append_preflight_summary, build_fine_tune_request, build_training_request, combine_training_plans, completion_recommendation, presets_from_config, parse_model_batch_names, build_dataset_collection_request, suggest_existing_dataset, ) from adam.ui.theme import APP_STYLESHEET, COLORS from adam.ui.studio import StudioPage from adam.ui.generations import GenerationsPage from adam.ui.showcase import ShowcasePage from adam.ui.video_lora import VideoLoraPage from adam.ui.oasis_player import OasisPlayerPage from adam.ui.model_intelligence import ModelIntelligencePage from adam.ui.settings_ui import SettingsForm from adam.ui.widgets import ( ActiveJobPanel, ChatBubble, GenerationChatCard, MetricCard, PlanPanel, PromptEdit, PromptResizeHandle, SparklineWidget, ) def is_explicit_action_request(request: str) -> bool: """Recognize clear commands that must be handled by ADAM's planner, not chat.""" text = " ".join(request.casefold().split()) action = r"(?:train|collect|create|generate|start|run|prepare|resume|continue|open)" return bool( re.search(rf"^(?:please\s+)?{action}\b", text) or re.search(rf"\b(?:can|could|will|would)\s+you\s+(?:please\s+)?{action}\b", text) or re.search(rf"\b(?:yes[,!]?\s+)?{action}\s+(?:this|the)\s+(?:job|plan)\b", text) ) def is_pending_job_confirmation_request(request: str) -> bool: text = " ".join(request.casefold().split()) return bool( re.search(r"^(?:yes|confirm|approve|start)\b.*\b(?:this|the)\s+(?:job|plan)\b", text) or re.search(r"^yes[,!]?\s+(?:start|run)\b", text) ) def subject_idea_from_chat(response: str) -> str | None: """Extract a plainly labelled subject suggestion from the latest chat reply.""" plain = re.sub(r"[*`]", "", response) match = re.search( r"\b(?:subject\s+idea|suggested\s+subject)\s*:\s*" r"(?:\n\s*)?(?:>\s*)?[\"“]?(.+?)(?:[\"”]\s*$|\n|$)", plain, re.I, ) if not match: return None subject = match.group(1).strip(" \t>—–-.,!?:;\"'”") return subject if 2 <= len(subject) <= 180 else None def expand_subject_reference(request: str, response: str) -> tuple[str, str | None]: """Replace an unambiguous reference such as 'that subject' with its chat idea.""" if not re.search( r"\b(?:(?:the\s+)?subject\s+you\s+mentioned|that\s+subject(?:\s+you\s+mentioned)?)\b", request, re.I, ): return request, None subject = subject_idea_from_chat(response) if not subject: return request, None expanded = re.sub( r"\b(?:(?:the\s+)?subject\s+you\s+mentioned|that\s+subject(?:\s+you\s+mentioned)?)\b", subject, request, flags=re.I, ) return expanded, subject def _card() -> QFrame: frame = QFrame() frame.setProperty("card", True) return frame def _card_title(text: str) -> QLabel: label = QLabel(text) label.setObjectName("CardTitle") return label def _page_header(title: str, subtitle: str) -> QWidget: widget = QWidget() layout = QVBoxLayout(widget) layout.setContentsMargins(0, 0, 0, 15) layout.setSpacing(3) title_label = QLabel(title) title_label.setObjectName("PageTitle") subtitle_label = QLabel(subtitle) subtitle_label.setProperty("muted", True) subtitle_label.setWordWrap(True) layout.addWidget(title_label) layout.addWidget(subtitle_label) return widget class CollapsiblePanel(QFrame): """A compact card shell that lets dashboard panels give their space back.""" collapsed_changed = Signal(bool) def __init__( self, title: str, content: QWidget, config: ConfigManager, setting_key: str, collapse_direction: str = "up", ) -> None: super().__init__() self.setProperty("card", True) self.content = content self.panel_title = title.lower() self.config = config self.setting_key = setting_key self.collapse_direction = collapse_direction self._expanded_minimum = content.minimumHeight() self._expanded_maximum = content.maximumHeight() self._expanded_policy = content.sizePolicy() root = QVBoxLayout(self) root.setContentsMargins(0, 0, 0, 0) root.setSpacing(0) header = QWidget() header_layout = QHBoxLayout(header) header_layout.setContentsMargins(15, 10, 12, 9) self.title_label = _card_title(title) header_layout.addWidget(self.title_label) header_layout.addStretch() self.toggle = QPushButton() self.toggle.setProperty("chip", True) self.toggle.setFixedSize(30, 25) self.toggle.clicked.connect(self._toggle) header_layout.addWidget(self.toggle) root.addWidget(header) # The shell owns the card border and heading. Hide the panel's original # heading while preserving every existing control and signal. for label in content.findChildren(QLabel): if label.objectName() == "CardTitle" and label.text() == title: label.hide() break content.setProperty("card", False) content.style().unpolish(content) content.style().polish(content) root.addWidget(content, 1) self.set_collapsed(bool(config.get(setting_key, False)), persist=False) def _toggle(self) -> None: self.set_collapsed(not self.collapsed, persist=True) def set_collapsed(self, collapsed: bool, *, persist: bool = True) -> None: self.collapsed = collapsed self.content.setVisible(not collapsed) self.toggle.setText("+" if collapsed else "−") self.toggle.setToolTip(("Show " if collapsed else "Hide ") + self.panel_title) self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed if collapsed else QSizePolicy.Preferred) horizontal = self.collapse_direction == "right" self.title_label.setVisible(not (collapsed and horizontal)) if collapsed and horizontal: self.setFixedWidth(45) self.setMinimumHeight(45) self.setMaximumHeight(45) elif collapsed: self.setMinimumWidth(0) self.setMaximumWidth(16777215) self.setMinimumHeight(45) self.setMaximumHeight(45) else: if horizontal: self.setMinimumWidth(330) self.setMaximumWidth(390) else: self.setMinimumWidth(0) self.setMaximumWidth(16777215) self.setMinimumHeight(0) self.setMaximumHeight(16777215) if persist: self.config.update({self.setting_key: collapsed}) self.collapsed_changed.emit(collapsed) class ChatHistoryStore: """Small, local JSON store for archived Command Center conversations.""" def __init__(self, root: Path) -> None: self.path = root / "data" / "chat_history.json" self.path.parent.mkdir(parents=True, exist_ok=True) def load(self) -> list[dict]: try: value = json.loads(self.path.read_text(encoding="utf-8")) return value if isinstance(value, list) else [] except (OSError, json.JSONDecodeError): return [] def save_conversation(self, entries: list[dict[str, str]], mode: str) -> dict | None: useful = [entry for entry in entries if entry.get("text", "").strip()] if not useful: return None first_user = next((entry["text"] for entry in useful if entry.get("user")), useful[0]["text"]) now = datetime.now() conversation = { "id": now.strftime("%Y%m%d%H%M%S%f"), "title": first_user.replace("\n", " ").strip()[:72] or "Untitled conversation", "created_at": now.isoformat(timespec="seconds"), "mode": mode, "entries": useful, } history = self.load() history.insert(0, conversation) temporary = self.path.with_suffix(".tmp") temporary.write_text(json.dumps(history[:100], indent=2), encoding="utf-8") temporary.replace(self.path) return conversation class ChatHistoryPage(QWidget): open_requested = Signal(object) def __init__(self, store: ChatHistoryStore) -> None: super().__init__() self.store = store root = QVBoxLayout(self) root.setContentsMargins(28, 24, 28, 24) root.setSpacing(14) root.addWidget(_page_header("Chat history", "Reopen earlier prompts and conversations in Command Center.")) self.list = QListWidget() self.list.setSpacing(6) self.list.itemDoubleClicked.connect(self._open_item) root.addWidget(self.list, 1) self.open_button = QPushButton("Open selected chat →") self.open_button.setProperty("primary", True) self.open_button.clicked.connect(self._open_selected) root.addWidget(self.open_button, 0, Qt.AlignRight) self.refresh() def refresh(self) -> None: self.list.clear() for conversation in self.store.load(): stamp = str(conversation.get("created_at", "")).replace("T", " ") item = QListWidgetItem(f"{conversation.get('title', 'Untitled conversation')}\n{stamp} · {conversation.get('mode', 'trainer').title()} Mode") item.setData(Qt.UserRole, conversation) self.list.addItem(item) self.open_button.setEnabled(self.list.count() > 0) def _open_selected(self) -> None: item = self.list.currentItem() or (self.list.item(0) if self.list.count() else None) if item: self.open_requested.emit(item.data(Qt.UserRole)) def _open_item(self, item: QListWidgetItem) -> None: self.open_requested.emit(item.data(Qt.UserRole)) class PlanningWorker(QThread): chunk = Signal(str) planned = Signal(object) failed = Signal(str) def __init__(self, planner: Planner, request: str) -> None: super().__init__() self.planner = planner self.request = request def run(self) -> None: try: self.planned.emit(self.planner.plan(self.request, self.chunk.emit)) except Exception as exc: self.failed.emit(str(exc)) class BatchPlanningWorker(QThread): """Plans every requested model, then returns one ordered execution plan.""" chunk = Signal(str) planned = Signal(object) failed = Signal(str) def __init__(self, planner: Planner, requests: list[str]) -> None: super().__init__() self.planner = planner self.requests = requests def run(self) -> None: try: plans = [] total = len(self.requests) for index, request in enumerate(self.requests, 1): self.chunk.emit(f"Planning model {index} of {total}…\n") plan = self.planner.plan(request) if not plan.steps: raise PlanningError( f"Model {index} could not be turned into an actionable plan: {plan.summary}" ) plans.append(plan) self.planned.emit(combine_training_plans(plans)) except Exception as exc: self.failed.emit(str(exc)) class ToolScanWorker(QThread): scanned = Signal(object) failed = Signal(str) def __init__(self, folder: str) -> None: super().__init__() self.folder = folder def run(self) -> None: try: self.scanned.emit(scan_folder(self.folder)) except Exception as exc: self.failed.emit(str(exc)) class DatasetScanWorker(QThread): scanned = Signal(object) failed = Signal(str) def __init__(self, folder: str) -> None: super().__init__() self.folder = folder def run(self) -> None: try: self.scanned.emit(scan_dataset(self.folder)) except Exception as exc: self.failed.emit(str(exc)) class CnnReviewerWorker(QThread): """Run local CNN training/scoring away from the Qt UI thread.""" progress = Signal(str) completed = Signal(str, object) failed = Signal(str) def __init__(self, mode: str, root: Path, folder: str, decisions: dict[str, str]) -> None: super().__init__() self.mode, self.root, self.folder, self.decisions = mode, root, folder, decisions def run(self) -> None: try: if self.mode == "train": result = train_reviewer(self.root, self.folder, self.decisions, progress=self.progress.emit) else: checkpoint = reviewer_checkpoint(self.root, self.folder) if not checkpoint.is_file(): raise ValueError("Train the CNN reviewer for this dataset first.") result = score_frames(checkpoint, self.folder, progress=self.progress.emit) self.completed.emit(self.mode, result) except Exception as exc: self.failed.emit(str(exc)) class TranscriptExportWorker(QThread): completed = Signal(object) def __init__(self, videos: list[str], output: str) -> None: super().__init__() self.videos = videos self.output = output def run(self) -> None: self.completed.emit(transcript_videos_to_dataset(self.videos, self.output)) class ChatWorker(QThread): chunk = Signal(str) answered = Signal(str) failed = Signal(str) def __init__( self, planner: Planner, request: str, history: list[dict[str, str]], image_paths: list[str] | None = None, ) -> None: super().__init__() self.planner = planner self.request = request self.history = history self.image_paths = list(image_paths or []) def run(self) -> None: try: response = self.planner.chat( self.request, self.history, self.chunk.emit, self.image_paths ) self.answered.emit(response) except Exception as exc: self.failed.emit(str(exc)) class ModelPluginWizardDialog(QDialog): """Scaffold a copyable model plugin folder from a few fields.""" def __init__(self, root: Path, parent: QWidget | None = None) -> None: super().__init__(parent) self.root = root.resolve() self.created_folder = "" self.setWindowTitle("Create Model Plugin") self.setMinimumWidth(520) layout = QVBoxLayout(self) layout.setSpacing(10) layout.addWidget( _page_header( "Create a model plugin", "Scaffold the manifest and Python files for a new architecture.", ) ) form = QGridLayout() form.setHorizontalSpacing(12) form.setVerticalSpacing(9) self.name = QLineEdit() self.name.setPlaceholderText("Example: Neural Cellular Automata") self.plugin_id = QLineEdit() self.plugin_id.setPlaceholderText("neural_cellular_automata") self.architecture = QLineEdit() self.architecture.setPlaceholderText("nca, maskgit, vae, autoregressive") self.output_type = QComboBox() for label in ("image", "video", "audio", "text", "other"): self.output_type.addItem(label.title(), label) self.training = QCheckBox("Training") self.training.setChecked(True) self.generation = QCheckBox("Generation") self.generation.setChecked(True) capability_row = QHBoxLayout() capability_row.addWidget(self.training) capability_row.addWidget(self.generation) capability_row.addStretch() form.addWidget(QLabel("Model name"), 0, 0) form.addWidget(self.name, 0, 1) form.addWidget(QLabel("Plugin folder"), 1, 0) form.addWidget(self.plugin_id, 1, 1) form.addWidget(QLabel("Architecture"), 2, 0) form.addWidget(self.architecture, 2, 1) form.addWidget(QLabel("Output type"), 3, 0) form.addWidget(self.output_type, 3, 1) form.addWidget(QLabel("Capabilities"), 4, 0) form.addLayout(capability_row, 4, 1) layout.addLayout(form) self.status = QLabel() self.status.setProperty("muted", True) self.status.setWordWrap(True) layout.addWidget(self.status) buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) buttons.button(QDialogButtonBox.Ok).setText("Create plugin folder") buttons.accepted.connect(self._create) buttons.rejected.connect(self.reject) layout.addWidget(buttons) self.name.textChanged.connect(self._suggest_id) def _suggest_id(self, value: str) -> None: if not self.plugin_id.text().strip(): self.plugin_id.setPlaceholderText(safe_plugin_id(value)) def _create(self) -> None: name = self.name.text().strip() if not name: self.status.setText("Enter a model name.") return plugin_id = self.plugin_id.text().strip() or self.plugin_id.placeholderText() if not self.training.isChecked() and not self.generation.isChecked(): self.status.setText("Choose training, generation, or both.") return try: folder = scaffold_model_plugin( self.root, plugin_id=plugin_id, name=name, architecture=self.architecture.text().strip() or "custom", output_type=str(self.output_type.currentData() or "image"), include_training=self.training.isChecked(), include_generation=self.generation.isChecked(), ) except ModelPluginError as exc: self.status.setText(str(exc)) return self.created_folder = str(folder) self.accept() class ModelCreationDialog(QDialog): """Collects training choices in plain language and produces a planner request.""" BUILTIN_PREVIEW_TRAINERS = {"ddpm", "flow", "lora", "oasis"} def __init__(self, planner: Planner, config: ConfigManager, parent: QWidget | None = None) -> None: super().__init__(parent) self.planner = planner self.config = config self.request = "" self.requests: list[str] = [] self.collection_only = False self.scheduled_for: str | None = None self._model_states: list[dict[str, object]] = [] self._current_model_index = 0 self.setWindowTitle("Model Creation Assistant") self.setMinimumWidth(560) available = self.screen().availableGeometry() self.resize(min(940, available.width() - 40), min(850, available.height() - 60)) outer = QVBoxLayout(self) outer.setContentsMargins(0, 0, 0, 0) scroll = QScrollArea() scroll.setWidgetResizable(True) scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) content = QWidget() root = QVBoxLayout(content) root.setSizeConstraint(QVBoxLayout.SetMinimumSize) scroll.setWidget(content) outer.addWidget(scroll) root.setSpacing(10) root.addWidget( _page_header( "Create a model", "Choose what you know. ADAM will turn it into a complete, reviewable training request.", ) ) self._asset_refresh = asset_refresh(planner.assets, config) self._asset_refresh.changed.connect(self._refresh_asset_choices) self._asset_refresh.request() journey = QLabel( "1 GOAL → 2 DATASET → 3 TRAINING RECIPE → 4 REVIEW & APPROVE" ) journey.setWordWrap(True) journey.setStyleSheet( f"color: {COLORS['blue_2']}; background: #081a27; " f"border: 1px solid {COLORS['border_bright']}; border-radius: 8px; " "padding: 10px; font-size: 10px; font-weight: 700;" ) root.addWidget(journey) model_tabs_row = QHBoxLayout() self.model_tabs = QTabBar() self.model_tabs.setMovable(True) self.model_tabs.setTabsClosable(False) self.model_tabs.setExpanding(False) self.model_tabs.setStyleSheet("QTabBar::tab { min-width: 120px; padding: 8px 14px; }") self.model_tabs.addTab("Model 1") self._install_remove_button(0) self.add_model_button = QPushButton("+ Add model") self.add_model_button.setToolTip("Add another model after this one") model_tabs_row.addWidget(self.model_tabs, 1) model_tabs_row.addWidget(self.add_model_button) root.addLayout(model_tabs_row) batch_tools = QGridLayout() self.bulk_add_button = QPushButton("Paste model list…") self.create_plugin_button = QPushButton("Create plugin…") self.apply_many_button = QPushButton("Apply current settings…") self.save_draft_button = QPushButton("Save draft") self.load_draft_button = QPushButton("Load draft") self.match_existing_button = QPushButton("Match existing datasets") self.refresh_datasets_button = QPushButton("Find collected datasets") for index, button in enumerate(( self.bulk_add_button, self.apply_many_button, self.save_draft_button, self.load_draft_button, self.match_existing_button, self.refresh_datasets_button, self.create_plugin_button, )): button.setProperty("chip", True) batch_tools.addWidget(button, index // 3, index % 3) root.addLayout(batch_tools) form = QGridLayout() form.setHorizontalSpacing(12) form.setVerticalSpacing(9) self.preset = QComboBox() self.presets = presets_from_config(config) self.trainer = QComboBox() preferred_trainers = ["lora", "ddpm", "flow", "inrflow", "pixelrow", "oasis"] plugins = { plugin.id: plugin for plugin in planner.registry.model_plugins.all() if plugin.training_settings and plugin.info.get("category") != "Template" and plugin.info.get("workspace") != "video_lora" } for trainer_id in preferred_trainers: plugin = plugins.pop(trainer_id, None) if plugin: self.trainer.addItem(plugin.name, plugin.id) for plugin in sorted(plugins.values(), key=lambda item: item.name.casefold()): self.trainer.addItem(plugin.name, plugin.id) self.training_mode = QComboBox() self.training_mode.addItem("Train a new model", "new") self.training_mode.addItem("Continue one of my models", "continue") self.continue_model = QComboBox() self.source = QComboBox() self.source.addItem("Create a new dataset", "new") self.source.addItem("Use an existing dataset", "existing") self.source.addItem("Use the continued model's original dataset", "original") self.subject = QLineEdit() self.subject.setPlaceholderText("Example: Hatsune Miku") self.dataset = QComboBox() self.dataset.setEditable(True) self.dataset.setPlaceholderText("Select or type a dataset name") for asset in planner.assets.assets: if asset.kind == "dataset" and Path(asset.path).is_dir(): self.dataset.addItem(asset.name) self.model_name = QLineEdit() self.model_name.setPlaceholderText("Defaults to the subject or dataset name") self.trigger_word = QLineEdit() self.trigger_word.setPlaceholderText("Defaults to the model name") self.epochs = QSpinBox() self.epochs.setRange(1, 100_000) self.progressive_enabled = QCheckBox("Train from low to high resolution") self.progressive_schedule = QLineEdit() self.progressive_schedule.setPlaceholderText("Example: 64:300, 128:100, 256:50, 384:25, 512:10") self.progressive_auto_batch = QCheckBox("Choose a conservative batch size for each stage") self.progressive_auto_batch.setChecked(True) self.progressive_suggest = QPushButton("Suggest stages") self.progressive_suggest.setProperty("chip", True) progressive_row = QHBoxLayout() progressive_row.addWidget(self.progressive_schedule, 1) progressive_row.addWidget(self.progressive_suggest) self.progressive_stage_widget = QWidget() self.progressive_stage_widget.setLayout(progressive_row) self.images = QSpinBox() self.images.setRange(10, 100_000) self.images.setSuffix(" images") self.collection_mode = QComboBox() self.collection_mode.addItem("Collect this exact target", "target") self.collection_mode.addItem("Collect every available result (up to 5,000)", "all_available") self.preset_hint = QLabel() self.preset_hint.setWordWrap(True) self.preset_hint.setProperty("muted", True) rows = [ ("Preset", self.preset), ("Trainer", self.trainer), ("Starting point", self.training_mode), ("Model to continue", self.continue_model), ("Dataset choice", self.source), ("What should it learn?", self.subject), ("Existing dataset", self.dataset), ("Model name", self.model_name), ("LoRA trigger word", self.trigger_word), ("Training length", self.epochs), ("Progressive resolution", self.progressive_enabled), ("Resolution stages", self.progressive_stage_widget), ("Stage batch size", self.progressive_auto_batch), ("Internet image collection", self.collection_mode), ("New dataset size", self.images), ] self.form_labels: dict[str, QLabel] = {} for row, (label, widget) in enumerate(rows): label_widget = QLabel(label) self.form_labels[label] = label_widget form.addWidget(label_widget, row, 0) form.addWidget(widget, row, 1) root.addLayout(form) self.options_group = QGroupBox() options = QVBoxLayout(self.options_group) options_title = QLabel("Training options") options_title.setProperty("sectionTitle", True) self.training_form = SettingsForm() self.options_hint = QLabel(); self.options_hint.setProperty("muted", True); self.options_hint.setWordWrap(True) self.orion_settings_button = QPushButton("ORION: apply a starting recipe") self.orion_settings_button.setToolTip("Fill in a conservative draft from the image count and resolution. You can change every value afterward.") self.orion_settings_button.setProperty("chip", True) options.addWidget(options_title) options.addWidget(self.training_form) options.addWidget(self.orion_settings_button) options.addWidget(self.options_hint) root.addWidget(self.options_group) self.preview_group = QGroupBox("Live training preview") preview_form = QGridLayout(self.preview_group) self.preview_enabled = QCheckBox("Generate previews while training") self.preview_enabled.setChecked(True) self.preview_every = QSpinBox() self.preview_every.setRange(1, 100_000) self.preview_every.setValue(5) self.preview_every.setSuffix(" epochs") self.preview_prompt = QLineEdit() self.preview_prompt.setPlaceholderText("Optional prompt for conditioned models") self.preview_seed = QSpinBox() self.preview_seed.setRange(0, 2_147_483_647) self.preview_seed.setValue(123456789) preview_form.addWidget(self.preview_enabled, 0, 0, 1, 2) preview_form.addWidget(QLabel("Preview interval"), 1, 0) preview_form.addWidget(self.preview_every, 1, 1) preview_form.addWidget(QLabel("Preview prompt"), 2, 0) preview_form.addWidget(self.preview_prompt, 2, 1) preview_form.addWidget(QLabel("Reproducible seed"), 3, 0) preview_form.addWidget(self.preview_seed, 3, 1) root.addWidget(self.preview_group) root.addWidget(self.preset_hint) self.dataset_reviewed = QCheckBox( "I reviewed this dataset in Training Studio and it is ready to train" ) self.dataset_reviewed.setToolTip( "Training remains locked for this model until you explicitly mark its dataset ready." ) dataset_approval_row = QHBoxLayout() dataset_approval_row.addWidget(self.dataset_reviewed, 1) self.approve_all_datasets_button = QPushButton("Approve all datasets") self.approve_all_datasets_button.setProperty("chip", True) self.approve_all_datasets_button.setToolTip( "Mark every linked dataset in this batch as reviewed and ready to train." ) dataset_approval_row.addWidget(self.approve_all_datasets_button) root.addLayout(dataset_approval_row) self.review_summary = QLabel() self.review_summary.setWordWrap(True) self.review_summary.setProperty("muted", True) root.addWidget(self.review_summary) schedule_group = QGroupBox("Model Scheduler") schedule_layout = QGridLayout(schedule_group) self.schedule_enabled = QCheckBox("Start this training batch at a specific time") self.schedule_time = QDateTimeEdit(QDateTime.currentDateTime().addSecs(3600)) self.schedule_time.setCalendarPopup(True) self.schedule_time.setDisplayFormat("MMM d, yyyy h:mm AP") self.schedule_time.setMinimumDateTime(QDateTime.currentDateTime()) self.schedule_time.setEnabled(False) schedule_note = QLabel( "This is the earliest start time. If another job is still running, ADAM starts this batch when that job finishes." ) schedule_note.setProperty("muted", True) schedule_note.setWordWrap(True) schedule_layout.addWidget(self.schedule_enabled, 0, 0, 1, 2) schedule_layout.addWidget(QLabel("Schedule training"), 1, 0) schedule_layout.addWidget(self.schedule_time, 1, 1) schedule_layout.addWidget(schedule_note, 2, 0, 1, 2) root.addWidget(schedule_group) save_row = QHBoxLayout() self.preset_name = QLineEdit() self.preset_name.setPlaceholderText("Optional custom preset name") save_preset = QPushButton("Save current preset") save_preset.clicked.connect(self._save_preset) save_row.addWidget(self.preset_name, 1) save_row.addWidget(save_preset) root.addLayout(save_row) self.validation = QLabel() self.validation.setWordWrap(True) root.addWidget(self.validation) action_row = QHBoxLayout() self.collect_first_button = QPushButton("Collect missing datasets first") self.collect_first_button.setToolTip( "Queue dataset collection only, then keep this batch as a draft for review." ) action_row.addWidget(self.collect_first_button) action_row.addStretch() root.addLayout(action_row) buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) buttons.button(QDialogButtonBox.Ok).setText("Build training plan") buttons.accepted.connect(self._accept_request) buttons.rejected.connect(self.reject) outer.addWidget(buttons) self.preset.currentTextChanged.connect(self._apply_preset) self.trainer.currentIndexChanged.connect(self._trainer_changed) self.trainer.currentIndexChanged.connect(self._refresh_continue_models) self.training_mode.currentIndexChanged.connect(self._training_mode_changed) self.training_mode.currentIndexChanged.connect(self._update_review) self.continue_model.currentIndexChanged.connect(self._training_mode_changed) self.continue_model.currentIndexChanged.connect(self._update_review) self.source.currentIndexChanged.connect(self._update_source) self.source.currentIndexChanged.connect(self._update_review) self.subject.textChanged.connect(self._suggest_name) self.subject.textChanged.connect(self._update_review) self.dataset.currentTextChanged.connect(self._update_review) self.model_name.textChanged.connect(self._update_review) self.trigger_word.textChanged.connect(self._update_review) self.epochs.valueChanged.connect(self._update_review) self.progressive_enabled.toggled.connect(self._update_progressive_controls) self.progressive_enabled.toggled.connect(self._update_review) self.progressive_schedule.textChanged.connect(self._update_review) self.progressive_auto_batch.toggled.connect(self._update_review) self.progressive_suggest.clicked.connect(self._suggest_progressive_stages) self.images.valueChanged.connect(self._update_review) self.collection_mode.currentIndexChanged.connect(self._update_collection_mode) self.collection_mode.currentIndexChanged.connect(self._update_review) self.trainer.currentIndexChanged.connect(self._update_review) self.training_form.changed.connect(self._update_review) self.training_form.changed.connect(self._update_progressive_controls) self.preview_enabled.toggled.connect(self._update_preview_controls) self.preview_enabled.toggled.connect(self._update_review) self.preview_every.valueChanged.connect(self._update_review) self.preview_prompt.textChanged.connect(self._update_review) self.preview_seed.valueChanged.connect(self._update_review) self._refresh_presets_for_trainer() self._refresh_continue_models() self._apply_preset(self.preset.currentText()) self._set_training_defaults() self._update_progressive_controls() self._training_mode_changed() self._update_source() self._update_review() self._model_states = [self._capture_state()] self.model_tabs.currentChanged.connect(self._switch_model) self.model_tabs.tabMoved.connect(self._move_model) self.add_model_button.clicked.connect(self._add_model) self.bulk_add_button.clicked.connect(self._bulk_add_models) self.create_plugin_button.clicked.connect(self._create_model_plugin) self.apply_many_button.clicked.connect(self._apply_settings_to_models) self.save_draft_button.clicked.connect(self._save_batch_draft) self.load_draft_button.clicked.connect(self._load_batch_draft) self.match_existing_button.clicked.connect(self._match_existing_datasets) self.refresh_datasets_button.clicked.connect(self._find_collected_datasets) self.collect_first_button.clicked.connect(self._accept_collection_requests) self.dataset_reviewed.toggled.connect(self._update_review) self.approve_all_datasets_button.clicked.connect(self._approve_all_datasets) self.orion_settings_button.clicked.connect(self._apply_orion_settings) self.schedule_enabled.toggled.connect(self.schedule_time.setEnabled) self.schedule_enabled.toggled.connect(self._update_review) self.schedule_time.dateTimeChanged.connect(self._update_review) def _capture_state(self) -> dict[str, object]: return { "preset": self.preset.currentText(), "trainer": self.trainer.currentData(), "training_mode": self.training_mode.currentData(), "continue_model_id": getattr(self.continue_model.currentData(), "id", ""), "source": self.source.currentData(), "subject": self.subject.text(), "dataset": self.dataset.currentText(), "model_name": self.model_name.text(), "trigger_word": self.trigger_word.text(), "epochs": self.epochs.value(), "images": self.images.value(), "collection_mode": self.collection_mode.currentData(), "dataset_reviewed": self.dataset_reviewed.isChecked(), "progressive_enabled": self.progressive_enabled.isChecked(), "progressive_schedule": self.progressive_schedule.text(), "progressive_auto_batch": self.progressive_auto_batch.isChecked(), "training_options": self._training_options(), } def _refresh_asset_choices(self) -> None: """Update asset selectors after background discovery completes.""" current_dataset = self.dataset.currentText() self.dataset.clear() for asset in self.planner.assets.assets: if asset.kind == "dataset" and Path(asset.path).is_dir(): self.dataset.addItem(asset.name) self.dataset.setCurrentText(current_dataset) self._refresh_continue_models() def _load_state(self, state: dict[str, object]) -> None: trainer_index = self.trainer.findData(state.get("trainer", "lora")) self.trainer.setCurrentIndex(max(0, trainer_index)) self._refresh_presets_for_trainer(str(state.get("preset", ""))) self._refresh_continue_models(str(state.get("continue_model_id", ""))) mode_index = self.training_mode.findData(state.get("training_mode", "new")) self.training_mode.setCurrentIndex(max(0, mode_index)) source_index = self.source.findData(state.get("source", "new")) self.source.setCurrentIndex(max(0, source_index)) self.subject.setText(str(state.get("subject", ""))) self.dataset.setCurrentText(str(state.get("dataset", ""))) self.model_name.setText(str(state.get("model_name", ""))) self.trigger_word.setText(str(state.get("trigger_word", ""))) self.epochs.setValue(int(state.get("epochs", 100))) self.images.setValue(int(state.get("images", 60))) mode_index = self.collection_mode.findData(state.get("collection_mode", "target")) self.collection_mode.setCurrentIndex(max(0, mode_index)) self.dataset_reviewed.setChecked(bool(state.get("dataset_reviewed", False))) self.progressive_enabled.setChecked(bool(state.get("progressive_enabled", False))) self.progressive_schedule.setText(str(state.get("progressive_schedule", ""))) self.progressive_auto_batch.setChecked(bool(state.get("progressive_auto_batch", True))) options = state.get("training_options", {}) if isinstance(options, dict): self.training_form.set_values(options) self.preview_enabled.setChecked(bool(options.get("preview_enabled", True))) self.preview_every.setValue(int(options.get("preview_every", 5))) self.preview_prompt.setText(str(options.get("preview_prompt", ""))) self.preview_seed.setValue(int(options.get("preview_seed", 123456789))) self._update_source() self._training_mode_changed() self._update_progressive_controls() self._update_review() def _switch_model(self, index: int) -> None: if index < 0 or index >= len(self._model_states): return if 0 <= self._current_model_index < len(self._model_states): self._model_states[self._current_model_index] = self._capture_state() self._current_model_index = index self._load_state(self._model_states[index]) def _add_model(self) -> None: self._model_states[self._current_model_index] = self._capture_state() blank = dict(self._model_states[0]) blank.update({"subject": "", "dataset": "", "model_name": "", "continue_model_id": ""}) self._model_states.append(blank) index = self.model_tabs.addTab(f"Model {len(self._model_states)}") self._install_remove_button(index) self.model_tabs.setCurrentIndex(index) def _bulk_add_models(self) -> None: dialog = QDialog(self) dialog.setWindowTitle("Paste model list") dialog.setMinimumWidth(520) layout = QVBoxLayout(dialog) hint = QLabel("Enter one model subject per line. Numbered and bulleted lists are accepted.") hint.setWordWrap(True) editor = QPlainTextEdit() editor.setPlaceholderText("Windows XP\nAdventure Time\nLuigi\nEarthBound") editor.setMinimumHeight(260) controls = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) controls.button(QDialogButtonBox.Ok).setText("Add to batch") controls.accepted.connect(dialog.accept) controls.rejected.connect(dialog.reject) layout.addWidget(hint) layout.addWidget(editor) layout.addWidget(controls) if dialog.exec() != QDialog.Accepted: return names = parse_model_batch_names(editor.toPlainText()) if not names: self.validation.setText("Paste at least one model name.") return self._model_states[self._current_model_index] = self._capture_state() template = dict(self._model_states[self._current_model_index]) template["dataset_reviewed"] = False states = [] for name in names: state = dict(template) state.update({"source": "new", "subject": name, "dataset": "", "model_name": name}) states.append(state) current_blank = not any( str(self._model_states[0].get(key, "")).strip() for key in ("subject", "dataset", "model_name") ) if current_blank and len(self._model_states) == 1: self._model_states = states else: self._model_states.extend(states) self._rebuild_model_tabs() self.model_tabs.setCurrentIndex(0 if current_blank else len(self._model_states) - len(states)) self.validation.setText(f"Added {len(names)} models. Their shared settings came from the current model.") def _create_model_plugin(self) -> None: dialog = ModelPluginWizardDialog(self.planner.root, self) if dialog.exec() != QDialog.Accepted: return self.validation.setText( f"Created {dialog.created_folder}. Restart ADAM after editing the plugin code." ) def _rebuild_model_tabs(self) -> None: self.model_tabs.blockSignals(True) while self.model_tabs.count(): self.model_tabs.removeTab(0) for index, state in enumerate(self._model_states): name = str(state.get("model_name", "")).strip() or f"Model {index + 1}" tab = self.model_tabs.addTab(name) self._install_remove_button(tab) self.model_tabs.blockSignals(False) self._current_model_index = min(self._current_model_index, len(self._model_states) - 1) self.model_tabs.setCurrentIndex(self._current_model_index) self._load_state(self._model_states[self._current_model_index]) def _apply_settings_to_models(self) -> None: self._model_states[self._current_model_index] = self._capture_state() dialog = QDialog(self) dialog.setWindowTitle("Apply current settings") layout = QVBoxLayout(dialog) layout.addWidget(QLabel("Select the models that should receive the current trainer and recipe:")) choices = QListWidget() choices.setSelectionMode(QAbstractItemView.MultiSelection) for index, state in enumerate(self._model_states): item = QListWidgetItem(str(state.get("model_name", "")).strip() or f"Model {index + 1}") item.setData(Qt.UserRole, index) choices.addItem(item) controls = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) controls.button(QDialogButtonBox.Ok).setText("Apply settings") controls.accepted.connect(dialog.accept); controls.rejected.connect(dialog.reject) layout.addWidget(choices); layout.addWidget(controls) if dialog.exec() != QDialog.Accepted or not choices.selectedItems(): return source = self._capture_state() shared_keys = { "preset", "trainer", "training_mode", "continue_model_id", "epochs", "images", "collection_mode", "training_options", } for item in choices.selectedItems(): target = self._model_states[int(item.data(Qt.UserRole))] for key in shared_keys: target[key] = source[key] self._load_state(self._model_states[self._current_model_index]) self.validation.setText(f"Applied the current settings to {len(choices.selectedItems())} models.") def _save_batch_draft(self) -> None: self._model_states[self._current_model_index] = self._capture_state() self.config.update({"model_batch_draft": { "saved_at": datetime.now().isoformat(timespec="seconds"), "models": self._model_states, }}) self.validation.setText(f"Saved a draft with {len(self._model_states)} models.") def _load_batch_draft(self) -> None: payload = self.config.get("model_batch_draft", {}) states = payload.get("models", []) if isinstance(payload, dict) else [] if not isinstance(states, list) or not states: self.validation.setText("There is no saved model batch draft yet.") return self._model_states = [dict(state) for state in states if isinstance(state, dict)] self._current_model_index = 0 self._rebuild_model_tabs() self.validation.setText(f"Loaded the saved draft with {len(self._model_states)} models.") def _find_collected_datasets(self) -> None: self._model_states[self._current_model_index] = self._capture_state() self.planner.assets.discover(self.config) found = 0 for state in self._model_states: if state.get("source") != "new": continue subject = str(state.get("subject", "")).strip() matches = self.planner.assets.find("dataset", subject) ready = next((asset for asset in matches if Path(asset.path).is_dir()), None) if ready: state["source"] = "existing" state["dataset"] = ready.name found += 1 self._load_state(self._model_states[self._current_model_index]) self._save_batch_draft() self.validation.setText( f"Linked {found} collected datasets. Review them in Training Studio, then mark each model ready." ) def _match_existing_datasets(self) -> None: """Link batch models to clearly matching registered datasets without guessing.""" self._model_states[self._current_model_index] = self._capture_state() self.planner.assets.discover(self.config) datasets = [asset for asset in self.planner.assets.assets if asset.kind == "dataset"] matched = 0 ambiguous: list[str] = [] unmatched: list[str] = [] for index, state in enumerate(self._model_states, 1): if state.get("source") == "existing" and str(state.get("dataset", "")).strip(): continue suggestion = suggest_existing_dataset(state, datasets) label = str(state.get("model_name", "")).strip() or str(state.get("subject", "")).strip() or f"Model {index}" if suggestion.status == "matched": state["source"] = "existing" state["dataset"] = suggestion.dataset_name state["dataset_reviewed"] = False matched += 1 elif suggestion.status == "ambiguous": ambiguous.append(label) else: unmatched.append(label) self._load_state(self._model_states[self._current_model_index]) self._save_batch_draft() details = [f"Matched {matched} model(s) to existing datasets."] if ambiguous: details.append("Needs your choice (similar datasets): " + ", ".join(ambiguous[:4]) + ("…" if len(ambiguous) > 4 else "") + ".") if unmatched: details.append("No confident match: " + ", ".join(unmatched[:4]) + ("…" if len(unmatched) > 4 else "") + ".") details.append("Matches are not marked reviewed; inspect them, then approve the batch when ready.") self.validation.setText(" ".join(details)) def _accept_collection_requests(self) -> None: self._model_states[self._current_model_index] = self._capture_state() requests = [] for state in self._model_states: if state.get("source") != "new": continue subject = str(state.get("subject", "")).strip() if not subject: continue requests.append(build_dataset_collection_request( subject, image_count=int(state.get("images", 100)), collection_mode=str(state.get("collection_mode", "target")), )) if not requests: self.validation.setText("Every model already uses an existing dataset, or a subject is missing.") return self._save_batch_draft() self.collection_only = True self.requests = requests self.request = requests[0] self.accept() def _approve_all_datasets(self) -> None: self._model_states[self._current_model_index] = self._capture_state() missing = [ index + 1 for index, state in enumerate(self._model_states) if state.get("source") != "existing" or not str(state.get("dataset", "")).strip() ] if missing: shown = ", ".join(str(index) for index in missing[:8]) suffix = "…" if len(missing) > 8 else "" self.validation.setText( f"Link the collected datasets for model(s) {shown}{suffix} before approving the batch. " "Use Find collected datasets first." ) return answer = QMessageBox.question( self, "Approve all datasets", f"Mark all {len(self._model_states)} linked datasets as reviewed and ready to train?\n\n" "This accepts each dataset as-is. It will not review individual images or exclude any images marked rejected.", ) if answer != QMessageBox.Yes: return for state in self._model_states: state["dataset_reviewed"] = True self._load_state(self._model_states[self._current_model_index]) self._save_batch_draft() self.validation.setText( f"Approved all {len(self._model_states)} datasets. The batch is ready to build a training plan." ) def _install_remove_button(self, index: int) -> None: remove = QPushButton("−") remove.setFixedSize(26, 24) remove.setToolTip("Remove this model from the batch") remove.setStyleSheet("padding: 0; font-size: 16px; font-weight: 700;") remove.clicked.connect( lambda _checked=False, button=remove: self._remove_button_clicked(button) ) self.model_tabs.setTabButton(index, QTabBar.RightSide, remove) def _remove_button_clicked(self, button: QPushButton) -> None: for index in range(self.model_tabs.count()): if self.model_tabs.tabButton(index, QTabBar.RightSide) is button: self._remove_model(index) return def _remove_model(self, index: int) -> None: if len(self._model_states) == 1: self.validation.setText("Keep at least one model in the training batch.") return if index == self._current_model_index: self._model_states[index] = self._capture_state() self._model_states.pop(index) self.model_tabs.removeTab(index) self._current_model_index = self.model_tabs.currentIndex() self._load_state(self._model_states[self._current_model_index]) self._renumber_tabs() def _move_model(self, old: int, new: int) -> None: if old == new or old >= len(self._model_states) or new >= len(self._model_states): return state = self._model_states.pop(old) self._model_states.insert(new, state) self._current_model_index = new self._renumber_tabs() def _renumber_tabs(self) -> None: for index, state in enumerate(self._model_states): name = str(state.get("model_name", "")).strip() self.model_tabs.setTabText(index, name or f"Model {index + 1}") def _refresh_presets_for_trainer(self, preferred: str = "") -> None: trainer = str(self.trainer.currentData() or "") names = [ name for name, values in self.presets.items() if str(values.get("trainer", "")) == trainer ] self.preset.blockSignals(True) self.preset.clear() if names: self.preset.addItems(names) target = preferred if preferred in names else names[0] self.preset.setCurrentText(target) else: self.preset.addItem("Plugin defaults") self.preset.blockSignals(False) def _apply_preset(self, name: str) -> None: values = self.presets.get(name, {}) trainer = str(self.trainer.currentData() or "") if not values: plugin = self.planner.registry.model_plugins.by_trainer(trainer) label = plugin.name if plugin else self.trainer.currentText() self.preset_hint.setText(f"{label}: using the plugin's default settings.") self._set_training_defaults() return if str(values.get("trainer", "")) != trainer: return self._set_training_defaults() self.epochs.setValue(int(values.get("epochs", 100))) self.images.setValue(int(values.get("image_count", 60))) options = values.get("training_options", {}) if isinstance(options, dict): self.training_form.set_values(options) stages = options.get("progressive_stages") if isinstance(stages, list) and stages: self.progressive_enabled.setChecked(True) self.progressive_schedule.setText( ", ".join( f"{item.get('resolution')}:{item.get('epochs')}" for item in stages if isinstance(item, dict) ) ) self.progressive_auto_batch.setChecked(bool(options.get("progressive_auto_batch", True))) if self.preview_group.isVisible(): self.preview_enabled.setChecked(bool(options.get("preview_enabled", True))) self.preview_every.setValue(int(options.get("preview_every", 5))) self.preview_prompt.setText(str(options.get("preview_prompt", ""))) self.preview_seed.setValue(int(options.get("preview_seed", 123456789))) self.preset_hint.setText(str(values.get("description", ""))) self._update_progressive_controls() def _update_source(self) -> None: continuing = self.training_mode.currentData() == "continue" creating = self.source.currentData() == "new" self.subject.setEnabled(creating) self.collection_mode.setEnabled(creating) self.images.setEnabled(creating and self.collection_mode.currentData() == "target") self.dataset.setEnabled(not creating and self.source.currentData() != "original") if not creating: self._suggest_name(self.dataset.currentText()) def _update_collection_mode(self) -> None: self.images.setEnabled( self.source.currentData() == "new" and self.collection_mode.currentData() == "target" ) def _model_can_continue(self, asset: object) -> bool: trainer = str(getattr(asset, "trainer", "")) path = Path(str(getattr(asset, "path", ""))) checkpoint = str(getattr(asset, "checkpoint", "")) checkpoint_ready = bool(checkpoint and Path(checkpoint).exists()) ddpm_pipeline = trainer == "ddpm" and (path / "model_index.json").is_file() flow_model = trainer == "flow" and ( (path / "flow_model_info.json").is_file() and (path / "unet" / "config.json").is_file() ) oasis_model = trainer == "oasis" and ( (path / "action_flow_model_info.json").is_file() and (path / "unet" / "config.json").is_file() ) try: supports_resume = "resume_training" in self.planner.registry.get( f"{trainer}_trainer" ).capabilities except Exception: supports_resume = False return supports_resume and (checkpoint_ready or ddpm_pipeline or flow_model or oasis_model) def _refresh_continue_models(self, preferred_id: str = "") -> None: trainer = str(self.trainer.currentData() or "") current = preferred_id or str(getattr(self.continue_model.currentData(), "id", "")) self.continue_model.blockSignals(True) self.continue_model.clear() models = [ asset for asset in self.planner.assets.assets if asset.kind == "model" and asset.trainer == trainer and self._model_can_continue(asset) ] for asset in sorted(models, key=lambda item: item.name.casefold()): self.continue_model.addItem(asset.name, asset) if not models: self.continue_model.addItem("No resumable models found") self.continue_model.model().item(0).setEnabled(False) elif current: index = next( ( i for i in range(self.continue_model.count()) if getattr(self.continue_model.itemData(i), "id", "") == current ), -1, ) if index >= 0: self.continue_model.setCurrentIndex(index) self.continue_model.blockSignals(False) def _continued_model_has_original_dataset(self) -> bool: asset = self.continue_model.currentData() if not asset: return False return any( item.kind == "dataset" and item.id == getattr(asset, "dataset_id", "") and Path(item.path).is_dir() for item in self.planner.assets.assets ) def _training_mode_changed(self) -> None: continuing = self.training_mode.currentData() == "continue" has_original_dataset = self._continued_model_has_original_dataset() self.continue_model.setVisible(continuing) if hasattr(self, "form_labels"): self.form_labels["Model to continue"].setVisible(continuing) self.source.model().item(self.source.findData("original")).setEnabled( continuing and has_original_dataset ) if not continuing and self.source.currentData() == "original": self.source.setCurrentIndex(self.source.findData("existing")) if continuing and self.source.currentData() == "new" and self.trainer.currentData() in {"flow", "oasis"}: target = "original" if has_original_dataset else "existing" self.source.setCurrentIndex(self.source.findData(target)) if continuing and self.source.currentData() == "original" and not has_original_dataset: self.source.setCurrentIndex(self.source.findData("existing")) self._update_source() def _trainer_changed(self) -> None: self._refresh_presets_for_trainer() flow = self.trainer.currentData() == "flow" oasis = self.trainer.currentData() == "oasis" self.trigger_word.setVisible(self.trainer.currentData() == "lora") if self.training_mode.currentData() != "continue" and (flow or oasis): self.source.setCurrentIndex(self.source.findData("existing")) self.source.model().item(self.source.findData("new")).setEnabled( self.training_mode.currentData() == "continue" or not (flow or oasis) ) if flow: self.preset_hint.setText( "Flow Matching currently uses an existing reviewed dataset. " "Create a dataset first if you do not have one yet." ) if oasis: self.preset_hint.setText( "Oasis uses existing gameplay folders with frames and synchronized action labels. " "Record or convert an action dataset before training." ) self._apply_preset(self.preset.currentText()) self._update_progressive_controls() def _set_training_defaults(self) -> None: trainer = str(self.trainer.currentData()) full_schema = self.planner.registry.model_plugins.training_schema(trainer) builtin_preview = trainer in self.BUILTIN_PREVIEW_TRAINERS schema = { key: spec for key, spec in full_schema.items() if not (builtin_preview and key.startswith("preview_")) } self.training_form.set_schema(schema) self.preview_group.setVisible(builtin_preview) self.orion_settings_button.setEnabled(trainer in {"ddpm", "flow", "lora", "oasis"}) plugin = self.planner.registry.model_plugins.by_trainer(trainer) self.options_group.setEnabled(bool(schema)) if plugin: self.options_hint.setText( f"{plugin.name}: settings are generated from the model plugin manifest." ) else: self.options_hint.setText("This trainer has no model plugin manifest yet.") def _progressive_supported(self) -> bool: return str(self.trainer.currentData() or "") in {"ddpm", "flow"} def _progressive_final_resolution(self) -> int: value = self.training_form.values().get("resolution", 128) try: return int(str(value).split("x", 1)[0]) except (TypeError, ValueError): return 128 def _update_progressive_controls(self) -> None: supported = self._progressive_supported() can_progress = supported and self._progressive_final_resolution() >= 128 for label in ("Progressive resolution", "Resolution stages", "Stage batch size"): if label in self.form_labels: self.form_labels[label].setVisible(supported) self.progressive_enabled.setVisible(supported) self.progressive_stage_widget.setVisible(supported) self.progressive_auto_batch.setVisible(supported) if not can_progress: self.progressive_enabled.setChecked(False) active = can_progress and self.progressive_enabled.isChecked() self.progressive_enabled.setEnabled(can_progress) self.progressive_schedule.setEnabled(active) self.progressive_suggest.setEnabled(active) self.progressive_auto_batch.setEnabled(active) def _suggest_progressive_stages(self) -> None: stages = suggested_stages(self._progressive_final_resolution(), self.epochs.value()) if len(stages) < 2: self.validation.setText("Choose a final resolution of at least 128px for progressive training.") return self.progressive_schedule.setText( ", ".join(f"{stage.resolution}:{stage.epochs}" for stage in stages) ) def _parse_progressive_schedule( self, value: str, total_epochs: int, trainer: str | None = None, ) -> list[dict[str, int]]: trainer = trainer or str(self.trainer.currentData() or "") entries: list[dict[str, int]] = [] for token in value.split(","): parts = token.strip().lower().replace("px", "").split(":", 1) if len(parts) != 2: raise ValueError("Use stages in the form 64:300, 128:100, 256:50.") try: entries.append({"resolution": int(parts[0].strip()), "epochs": int(parts[1].strip())}) except ValueError as exc: raise ValueError("Stage resolutions and epochs must be whole numbers.") from exc try: return [ {"resolution": stage.resolution, "epochs": stage.epochs} for stage in parse_stages(entries, trainer=trainer, total_epochs=total_epochs) ] except Exception as exc: raise ValueError(str(exc)) from exc def _state_training_options(self, state: dict[str, object]) -> dict[str, object]: options = state.get("training_options", {}) resolved = dict(options) if isinstance(options, dict) else {} if not bool(state.get("progressive_enabled", False)): resolved.pop("progressive_stages", None) resolved.pop("progressive_auto_batch", None) return resolved trainer = str(state.get("trainer", "")) if trainer not in {"ddpm", "flow"}: raise ValueError("Progressive resolution training is currently available for DDPM and Flow Matching.") stages = self._parse_progressive_schedule( str(state.get("progressive_schedule", "")), int(state.get("epochs", 0)), trainer, ) configured_resolution = resolved.get("resolution", 0) try: final_resolution = int(str(configured_resolution).split("x", 1)[0]) except (TypeError, ValueError): final_resolution = 0 if stages[-1]["resolution"] != final_resolution: raise ValueError( f"The final progressive stage is {stages[-1]['resolution']}px, " f"but the training resolution is {final_resolution}px." ) resolved["progressive_stages"] = stages resolved["progressive_auto_batch"] = bool(state.get("progressive_auto_batch", True)) return resolved def _orion_image_count(self) -> int: if self.source.currentData() == "new": return 5_000 if self.collection_mode.currentData() == "all_available" else self.images.value() name = self.dataset.currentText().strip() for asset in self.planner.assets.find("dataset", name): count = dataset_image_count(asset.path) if count: return count return self.images.value() def _orion_dataset_path(self) -> str: """Return a real Oasis dataset path when the current selection has one.""" if self.source.currentData() == "new": return "" name = self.dataset.currentText().strip() for asset in self.planner.assets.find("dataset", name): if Path(asset.path).is_dir(): return str(asset.path) return name if Path(name).is_dir() else "" def _apply_orion_settings(self) -> None: trainer = str(self.trainer.currentData()) images = self._orion_image_count() current = self.training_form.values() raw_resolution = current.get("resolution", 128) or 128 if isinstance(raw_resolution, str) and "x" in raw_resolution: resolution = int(raw_resolution.lower().split("x", 1)[0]) else: resolution = int(raw_resolution) profile = ModelProfileRegistry(self.planner.registry.model_plugins).get(trainer) if profile: result = recommend_for_profile( profile, dataset_items=images, dataset_path=self._orion_dataset_path(), resolution=resolution, snapshot=getattr(self.parent(), "latest_snapshot", None), ).to_dict() else: result = recommend_training_settings(trainer, images, resolution) self.epochs.setValue(int(result["epochs"])) settings = result["settings"] self.training_form.set_values(settings) if "preview_every" in settings: self.preview_every.setValue(int(settings["preview_every"])) warnings = result.get("warnings", []) self.preset_hint.setText(str(result["summary"])) reasons = result.get("reasons", []) explanation = "" if reasons: explanation = "\nWhy: " + " ".join(str(reason) for reason in reasons[:3]) self.validation.setText( "ORION applied a reviewable starting recipe. Nothing has been queued or started." + explanation + ("\n" + "\n".join(str(item) for item in warnings) if warnings else "") ) self._update_review() def _training_options(self) -> dict[str, object]: plugin_options = self.training_form.values() if self.preview_group.isVisible(): plugin_options.update({ "preview_enabled": self.preview_enabled.isChecked(), "preview_every": self.preview_every.value(), }) if self.trainer.currentData() != "oasis": plugin_options.update({ "preview_prompt": self.preview_prompt.text().strip(), "preview_seed": self.preview_seed.value(), }) if self.trainer.currentData() == "lora": trigger_word = self.trigger_word.text().strip() if trigger_word: plugin_options["trigger_word"] = trigger_word if self._progressive_supported() and self.progressive_enabled.isChecked(): try: plugin_options["progressive_stages"] = self._parse_progressive_schedule( self.progressive_schedule.text(), self.epochs.value() ) plugin_options["progressive_auto_batch"] = self.progressive_auto_batch.isChecked() except ValueError: # Keep the draft editable. _accept_request provides the concrete # message before a malformed schedule can enter a job plan. pass return plugin_options def _update_preview_controls(self) -> None: enabled = self.preview_enabled.isChecked() self.preview_every.setEnabled(enabled) self.preview_prompt.setEnabled(enabled) self.preview_seed.setEnabled(enabled) def _suggest_name(self, value: str) -> None: if not self.model_name.text().strip(): self.model_name.setPlaceholderText(value.strip() or "Model name") def _update_review(self) -> None: continuing = self.training_mode.currentData() == "continue" creating = self.source.currentData() == "new" subject = self.subject.text().strip() if creating else self.dataset.currentText().strip() model = self.model_name.text().strip() or subject or "Unnamed model" if self.source.currentData() == "original": base = self.continue_model.currentData() dataset = f"reuse the dataset linked to {getattr(base, 'name', 'the selected model')}" elif creating: dataset = ( f"collect every result Bing makes available (up to 5,000) for {subject or 'the subject'}" if self.collection_mode.currentData() == "all_available" else f"collect up to {self.images.value()} images of {subject or 'the subject'}" ) else: dataset = f"use the registered {subject or 'selected'} dataset" if continuing: base = self.continue_model.currentData() action = f"continue {getattr(base, 'name', 'a selected model')}" else: action = f"train {model}" self.review_summary.setText( f"Review: {dataset}; {action} with " f"{self.trainer.currentText()} for {self.epochs.value():,} epochs. " + ( f"Trigger: {self.trigger_word.text().strip() or model}. " if self.trainer.currentData() == "lora" and not continuing else "" ) + self._training_option_summary() + self._preview_summary() + ( f"Scheduled for {self.schedule_time.dateTime().toString('MMM d, yyyy h:mm AP')}. " if hasattr(self, "schedule_enabled") and self.schedule_enabled.isChecked() else "" ) + "ADAM will run preflight checks and still ask for approval." ) if hasattr(self, "model_tabs") and self.model_tabs.count(): self.model_tabs.setTabText(self.model_tabs.currentIndex(), model) def _preview_summary(self) -> str: if self.preview_group.isVisible(): if self.preview_enabled.isChecked(): return f"Live preview every {self.preview_every.value()} epochs. " return "Live previews off. " values = self.training_form.values() if values.get("preview_every"): return f"Plugin preview every {values['preview_every']} steps. " return "" def _training_option_summary(self) -> str: values = self.training_form.values() details = [] if values.get("resolution"): details.append(f"{values['resolution']}px") if values.get("batch_size"): details.append(f"batch {values['batch_size']}") if values.get("learning_rate"): details.append(f"lr {float(values['learning_rate']):.7f}") if self._progressive_supported() and self.progressive_enabled.isChecked(): try: self._parse_progressive_schedule(self.progressive_schedule.text(), self.epochs.value()) details.append("progressive " + self.progressive_schedule.text().strip()) except ValueError: details.append("progressive schedule needs attention") if self.trainer.currentData() == "oasis": from adam.oasis_dataset import oasis_pace pace = oasis_pace( self._orion_dataset_path(), frame_gap=int(values.get("frame_gap", 1) or 1), ) capture_fps = pace["capture_fps"] native_fps = pace["native_ai_fps"] if isinstance(capture_fps, (int, float)) and isinstance(native_fps, (int, float)): details.append(f"{float(capture_fps):g} FPS capture → {float(native_fps):g} native AI FPS") return " · ".join(details) + ". " if details else "" def _save_preset(self) -> None: name = self.preset_name.text().strip() if not name: self.validation.setText("Enter a name before saving the preset.") return stored = self.config.get("training_presets", {}) stored = dict(stored) if isinstance(stored, dict) else {} stored[name] = { "trainer": self.trainer.currentData(), "epochs": self.epochs.value(), "image_count": self.images.value(), "training_options": self._training_options(), "description": "Your saved training settings.", } self.config.update({"training_presets": stored}) self.presets[name] = stored[name] self._refresh_presets_for_trainer(name) self.preset.setCurrentText(name) self.validation.setText(f"Saved preset: {name}") def _accept_request(self) -> None: self._model_states[self._current_model_index] = self._capture_state() requests: list[str] = [] for index, state in enumerate(self._model_states, 1): continuing = state.get("training_mode") == "continue" creating = state.get("source") == "new" subject = str(state.get("subject", "")).strip() dataset = str(state.get("dataset", "")).strip() try: resolved_options = self._state_training_options(state) except ValueError as exc: self.validation.setText(f"Model {index}: {exc}") self.model_tabs.setCurrentIndex(index - 1) return if continuing: model = next( ( asset for asset in self.planner.assets.assets if asset.kind == "model" and asset.id == str(state.get("continue_model_id", "")) and self._model_can_continue(asset) ), None, ) if not model: self.validation.setText(f"Model {index}: choose a completed model to continue.") self.model_tabs.setCurrentIndex(index - 1) return if state.get("source") == "existing" and not dataset: self.validation.setText(f"Model {index}: choose the gameplay dataset for continuation.") self.model_tabs.setCurrentIndex(index - 1) return if state.get("source") == "new" and not subject: self.validation.setText(f"Model {index}: tell ADAM what the new dataset should contain.") self.model_tabs.setCurrentIndex(index - 1) return requests.append(build_fine_tune_request( model_name=model.name, trainer=model.trainer, epochs=int(state.get("epochs", 100)), dataset_mode=str(state.get("source", "original")), dataset_name=dataset, new_subject=subject, image_count=int(state.get("images", 60)), training_options=resolved_options, )) continue if creating and not subject: self.validation.setText(f"Model {index}: tell ADAM what it should learn.") self.model_tabs.setCurrentIndex(index - 1) return if not creating and not dataset: self.validation.setText(f"Model {index}: choose or type an existing dataset name.") self.model_tabs.setCurrentIndex(index - 1) return if not bool(state.get("dataset_reviewed", False)): self.validation.setText( f"Model {index}: review its dataset in Training Studio, then mark it ready to train." ) self.model_tabs.setCurrentIndex(index - 1) return name = str(state.get("model_name", "")).strip() or subject or dataset requests.append(build_training_request( trainer=str(state.get("trainer", "lora")), subject=subject, dataset_name=dataset, create_dataset=creating, epochs=int(state.get("epochs", 100)), image_count=int(state.get("images", 60)), collection_mode=str(state.get("collection_mode", "target")), model_name=name, training_options=resolved_options, )) self.requests = requests self.request = requests[0] if self.schedule_enabled.isChecked(): scheduled = self.schedule_time.dateTime() if scheduled <= QDateTime.currentDateTime(): self.validation.setText("Choose a scheduled training time in the future.") return self.scheduled_for = scheduled.toPython().astimezone().isoformat() else: self.scheduled_for = None self.config.update({"model_batch_draft": { "saved_at": datetime.now().isoformat(timespec="seconds"), "models": self._model_states, }}) self.accept() class FineTuneDialog(QDialog): """Select a registered resumable model and request additional training.""" def __init__(self, planner: Planner, parent: QWidget | None = None) -> None: super().__init__(parent) self.planner = planner self.request = "" self.setWindowTitle("Fine-Tune Assistant") self.setMinimumWidth(560) root = QVBoxLayout(self) root.setSpacing(10) root.addWidget( _page_header( "Fine-tune a model", "Continue a completed model from its saved checkpoint with more training on its original dataset.", ) ) notice = QLabel( "Fine-tuning never starts immediately. ADAM will validate the checkpoint, dataset, " "tool connection, and available disk space before asking for approval." ) notice.setWordWrap(True) notice.setProperty("muted", True) root.addWidget(notice) form = QGridLayout() self.model = QComboBox() self.dataset_mode = QComboBox() self.dataset_mode.addItem("Use the model's original dataset", "original") self.dataset_mode.addItem("Use another registered dataset", "existing") self.dataset_mode.addItem("Collect a new dataset", "new") self.dataset = QComboBox() for asset in planner.assets.assets: if asset.kind == "dataset" and Path(asset.path).is_dir(): self.dataset.addItem(asset.name, asset) self.new_subject = QLineEdit() self.new_subject.setPlaceholderText("What should the new dataset contain?") self.output_model_name = QLineEdit() self.output_model_name.setPlaceholderText("A distinct name for this fine-tuned model") self.image_count = QSpinBox() self.image_count.setRange(10, 5000) self.image_count.setValue(60) self.image_count.setSuffix(" images") self.epochs = QSpinBox() self.epochs.setRange(1, 100_000) self.epochs.setValue(25) self.epochs.setSuffix(" additional epochs") form.addWidget(QLabel("Completed model"), 0, 0) form.addWidget(self.model, 0, 1) form.addWidget(QLabel("Dataset choice"), 1, 0) form.addWidget(self.dataset_mode, 1, 1) form.addWidget(QLabel("Registered dataset"), 2, 0) form.addWidget(self.dataset, 2, 1) form.addWidget(QLabel("New dataset subject"), 3, 0) form.addWidget(self.new_subject, 3, 1) form.addWidget(QLabel("New dataset size"), 4, 0) form.addWidget(self.image_count, 4, 1) form.addWidget(QLabel("Fine-tuned model name"), 5, 0) form.addWidget(self.output_model_name, 5, 1) form.addWidget(QLabel("Continue training"), 6, 0) form.addWidget(self.epochs, 6, 1) root.addLayout(form) self.options_group = QGroupBox("Training settings") options = QGridLayout(self.options_group) self.resolution = QComboBox(); self.resolution.addItems(["64", "128", "256", "384", "512"]); self.resolution.setCurrentText("128") self.batch_size = QSpinBox(); self.batch_size.setRange(1, 64); self.batch_size.setValue(1) self.learning_rate = QDoubleSpinBox(); self.learning_rate.setDecimals(7); self.learning_rate.setRange(0.0000001, 0.1); self.learning_rate.setSingleStep(0.00005); self.learning_rate.setValue(0.0001) self.gradient_accumulation = QSpinBox(); self.gradient_accumulation.setRange(1, 64); self.gradient_accumulation.setValue(1) self.workers = QSpinBox(); self.workers.setRange(0, 16); self.workers.setValue(4) self.precision = QComboBox(); self.precision.addItem("FP16 (faster / less VRAM)", "fp16"); self.precision.addItem("Full precision", "no") self.save_every = QSpinBox(); self.save_every.setRange(1, 1000); self.save_every.setValue(10) self.preview_steps = QSpinBox(); self.preview_steps.setRange(1, 500); self.preview_steps.setValue(50) self.intensity = QSpinBox(); self.intensity.setRange(10, 100); self.intensity.setValue(100); self.intensity.setSuffix("%") for row, (label, widget) in enumerate(( ("Resolution", self.resolution), ("Batch size", self.batch_size), ("Learning rate", self.learning_rate), ("Gradient accumulation", self.gradient_accumulation), ("Loader workers", self.workers), ("Precision", self.precision), ("Save every", self.save_every), ("Preview steps", self.preview_steps), ("Training intensity", self.intensity), )): options.addWidget(QLabel(label), row, 0) options.addWidget(widget, row, 1) self.options_hint = QLabel() self.options_hint.setWordWrap(True) self.options_hint.setProperty("muted", True) options.addWidget(self.options_hint, 9, 0, 1, 2) root.addWidget(self.options_group) self.summary = QLabel() self.summary.setWordWrap(True) self.summary.setProperty("muted", True) root.addWidget(self.summary) self.validation = QLabel() self.validation.setWordWrap(True) root.addWidget(self.validation) buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) self.plan_button = buttons.button(QDialogButtonBox.Ok) self.plan_button.setText("Build fine-tune plan") buttons.accepted.connect(self._accept_request) buttons.rejected.connect(self.reject) root.addWidget(buttons) self._add_model_groups() if not any(self.model.itemData(index) for index in range(self.model.count())): self.plan_button.setEnabled(False) self.validation.setText( "No completed model can be fine-tuned yet. Complete a DDPM, Flow Matching, " "or LoRA run, then return here." ) self.model.currentIndexChanged.connect(self._update_summary) self.model.currentIndexChanged.connect(self._model_changed) self.dataset_mode.currentIndexChanged.connect(self._dataset_mode_changed) self.dataset_mode.currentIndexChanged.connect(self._update_summary) self.dataset.currentIndexChanged.connect(self._update_summary) self.new_subject.textChanged.connect(self._update_summary) self.output_model_name.textChanged.connect(self._update_summary) self.image_count.valueChanged.connect(self._update_summary) self.epochs.valueChanged.connect(self._update_summary) for widget in (self.resolution, self.batch_size, self.learning_rate, self.gradient_accumulation, self.workers, self.precision, self.save_every, self.preview_steps, self.intensity): signal = getattr(widget, "valueChanged", None) or getattr(widget, "currentIndexChanged", None) if signal: signal.connect(self._update_summary) self._dataset_mode_changed() self._model_changed() self._update_summary() def _add_model_groups(self) -> None: """Show every model family, while allowing only safe continuation choices.""" labels = {"ddpm": "DDPM models", "flow": "Flow Matching models", "lora": "LoRA models", "oasis": "Oasis models"} models = [asset for asset in self.planner.assets.assets if asset.kind == "model"] for trainer in ("ddpm", "flow", "lora", "oasis"): header_index = self.model.count() self.model.addItem(f"— {labels[trainer]} —") self.model.model().item(header_index).setEnabled(False) group = [asset for asset in models if asset.trainer == trainer] if not group: index = self.model.count() self.model.addItem("No registered models found") self.model.model().item(index).setEnabled(False) continue for asset in group: checkpoint_ready = bool(asset.checkpoint and Path(asset.checkpoint).is_file()) ddpm_pipeline = trainer == "ddpm" and (Path(asset.path) / "model_index.json").is_file() flow_model = trainer == "flow" and ( (Path(asset.path) / "flow_model_info.json").is_file() and (Path(asset.path) / "unet" / "config.json").is_file() ) oasis_model = trainer == "oasis" and ( (Path(asset.path) / "action_flow_model_info.json").is_file() and (Path(asset.path) / "unet" / "config.json").is_file() ) try: supports_resume = "resume_training" in self.planner.registry.get( f"{trainer}_trainer" ).capabilities except Exception: supports_resume = False ready = supports_resume and (checkpoint_ready or ddpm_pipeline or flow_model or oasis_model) if ready: detail = ( "saved Flow model" if flow_model else "saved checkpoint" if checkpoint_ready else "saved DDPM model" ) self.model.addItem(f"{asset.name} · {detail}", asset) else: reason = ( "continuation not connected" if not supports_resume else "no usable checkpoint" ) index = self.model.count() self.model.addItem(f"{asset.name} · {reason}") self.model.model().item(index).setEnabled(False) def _update_summary(self) -> None: asset = self.model.currentData() if not asset: self.summary.setText( "Choose a model marked with a saved checkpoint or saved DDPM model. " "Unavailable entries stay visible so you can see every model family." ) return mode = self.dataset_mode.currentData() if mode == "existing": dataset_text = f"use {self.dataset.currentText() or 'another registered dataset'}" elif mode == "new": dataset_text = f"collect {self.image_count.value()} images of {self.new_subject.text().strip() or 'a new subject'}" else: dataset_text = "reuse the dataset linked to the original run" output_name = self.output_model_name.text().strip() or asset.name self.summary.setText( f"Review: continue {asset.name} as {output_name} with {asset.trainer.upper()} for " f"{self.epochs.value():,} additional epochs; {dataset_text}. " "ADAM will validate everything and ask for approval before starting." ) def _dataset_mode_changed(self) -> None: mode = self.dataset_mode.currentData() self.dataset.setEnabled(mode == "existing") self.new_subject.setEnabled(mode == "new") self.image_count.setEnabled(mode == "new") def _model_changed(self) -> None: asset = self.model.currentData() trainer = asset.trainer if asset else "" if asset and not self.output_model_name.text().strip(): self.output_model_name.setText(f"{asset.name} Fine Tune") original_index = self.dataset_mode.findData("original") has_original_dataset = bool( asset and any( item.kind == "dataset" and item.id == asset.dataset_id and Path(item.path).is_dir() for item in self.planner.assets.assets ) ) if original_index >= 0: self.dataset_mode.model().item(original_index).setEnabled(has_original_dataset or not asset) if asset and not has_original_dataset and self.dataset_mode.currentData() == "original": self.dataset_mode.setCurrentIndex(self.dataset_mode.findData("existing")) self.options_group.setEnabled(trainer in {"ddpm", "flow", "oasis"}) self.resolution.setEnabled(trainer != "flow") if trainer == "flow": try: info = json.loads((Path(asset.path) / "flow_model_info.json").read_text(encoding="utf-8")) self.resolution.setCurrentText(str(int(info["resolution"]))) except (OSError, ValueError, TypeError, KeyError, json.JSONDecodeError): pass self.options_hint.setText( "Flow continuation keeps the original model resolution and starts a fresh optimizer schedule. " + ( "ADAM saves the fine-tuned model in a new folder." if has_original_dataset else "Choose another registered dataset; this older model has no recoverable original dataset link." ) ) elif trainer == "ddpm": self.options_hint.setText("These settings are passed to the DDPM trainer for this continuation run.") elif trainer == "oasis": self.options_hint.setText("Oasis continuation uses an existing action model folder and a reviewed gameplay action dataset.") else: self.options_hint.setText("The connected LoRA trainer currently reuses its saved training settings; choose the additional epochs above.") self._update_summary() def _training_options(self, trainer: str) -> dict[str, object]: if trainer == "ddpm": return { "resolution": int(self.resolution.currentText()), "batch_size": self.batch_size.value(), "learning_rate": self.learning_rate.value(), "gradient_accumulation_steps": self.gradient_accumulation.value(), "dataloader_num_workers": self.workers.value(), "mixed_precision": self.precision.currentData(), "save_every": self.save_every.value(), "preview_steps": self.preview_steps.value(), "training_intensity": self.intensity.value(), } if trainer == "flow": return { "resolution": int(self.resolution.currentText()), "batch_size": self.batch_size.value(), "learning_rate": self.learning_rate.value(), "gradient_accumulation": self.gradient_accumulation.value(), "workers": self.workers.value(), "mixed_precision": self.precision.currentData(), "save_every": self.save_every.value(), "preview_every": self.save_every.value(), "preview_steps": self.preview_steps.value(), "gradient_checkpointing": False, } if trainer == "oasis": return { "resolution": "256x144", "batch_size": min(2, self.batch_size.value()), "learning_rate": self.learning_rate.value(), "gradient_accumulation": self.gradient_accumulation.value(), "workers": min(2, self.workers.value()), "mixed_precision": "fp32", "save_every": self.save_every.value(), "preview_every": self.save_every.value(), "preview_steps": 1, } return {} def _accept_request(self) -> None: asset = self.model.currentData() if not asset: return mode = str(self.dataset_mode.currentData()) dataset_asset = self.dataset.currentData() if mode == "existing" and not dataset_asset: self.validation.setText("Choose a registered dataset.") return if mode == "new" and not self.new_subject.text().strip(): self.validation.setText("Tell ADAM what the new dataset should contain.") return self.request = build_fine_tune_request( model_name=asset.name, output_model_name=self.output_model_name.text(), trainer=asset.trainer, epochs=self.epochs.value(), dataset_mode=mode, dataset_name=dataset_asset.name if mode == "existing" else "", new_subject=self.new_subject.text(), image_count=self.image_count.value(), training_options=self._training_options(asset.trainer), ) self.accept() class VideoDatasetDialog(QDialog): """Builds a complete, reviewable YouTube dataset collection request.""" def __init__(self, parent: QWidget | None = None) -> None: super().__init__(parent) self.request = "" self.setWindowTitle("Video Dataset Collection Assistant") self.setMinimumSize(680, 760) root = QVBoxLayout(self) root.setSpacing(10) root.addWidget(_page_header( "Collect a video dataset", "Supply YouTube links and choose how ADAM should download, extract, filter, and document the dataset.", )) journey = QLabel("1 SOURCES → 2 DOWNLOAD LIMITS → 3 FRAME EXTRACTION → 4 REVIEW & APPROVE") journey.setStyleSheet( f"color: {COLORS['blue_2']}; background: #081a27; " f"border: 1px solid {COLORS['border_bright']}; border-radius: 8px; " "padding: 10px; font-size: 10px; font-weight: 700;" ) root.addWidget(journey) scroll = QScrollArea() scroll.setWidgetResizable(True) body = QWidget() form = QGridLayout(body) form.setHorizontalSpacing(14) form.setVerticalSpacing(9) self.dataset_name = QLineEdit("Video_Dataset") self.dataset_name.setPlaceholderText("Example: Roblox_Obby") self.urls = QPlainTextEdit() self.urls.setPlaceholderText("Paste one YouTube video or playlist URL per line") self.urls.setFixedHeight(88) self.max_videos = QSpinBox(); self.max_videos.setRange(1, 500); self.max_videos.setValue(5) self.max_duration = QDoubleSpinBox(); self.max_duration.setRange(0, 1440); self.max_duration.setValue(20); self.max_duration.setSuffix(" minutes") self.total_duration = QDoubleSpinBox(); self.total_duration.setRange(0, 100000); self.total_duration.setValue(100); self.total_duration.setSuffix(" minutes") self.max_size = QDoubleSpinBox(); self.max_size.setRange(0, 1_000_000); self.max_size.setValue(0); self.max_size.setSuffix(" MB (0 = no limit)") self.resolution = QComboBox() for label, value in (("480p", 480), ("720p (recommended)", 720), ("1080p", 1080), ("1440p", 1440), ("2160p / 4K", 2160)): self.resolution.addItem(label, value) self.resolution.setCurrentIndex(self.resolution.findData(720)) self.audio = QCheckBox("Include audio in the normalized MP4") self.skip_start = QDoubleSpinBox(); self.skip_start.setRange(0, 3600); self.skip_start.setValue(5); self.skip_start.setSuffix(" seconds") self.skip_end = QDoubleSpinBox(); self.skip_end.setRange(0, 3600); self.skip_end.setValue(5); self.skip_end.setSuffix(" seconds") self.mode = QComboBox() self.mode.addItem("General image dataset (filter repetition)", "image") self.mode.addItem("Sequential video training (preserve neighbors)", "sequential") self.frame_rate = QDoubleSpinBox(); self.frame_rate.setRange(0.01, 120); self.frame_rate.setDecimals(2); self.frame_rate.setValue(2); self.frame_rate.setSuffix(" frames/second") self.max_frames = QSpinBox(); self.max_frames.setRange(1, 1_000_000); self.max_frames.setValue(2000); self.max_frames.setSuffix(" accepted frames") self.remove_blur = QCheckBox("Reject blurry frames"); self.remove_blur.setChecked(True) self.remove_black = QCheckBox("Reject black frames"); self.remove_black.setChecked(True) self.remove_duplicates = QCheckBox("Reject near-duplicate frames"); self.remove_duplicates.setChecked(True) self.duplicate_threshold = QDoubleSpinBox(); self.duplicate_threshold.setRange(0, 1); self.duplicate_threshold.setDecimals(2); self.duplicate_threshold.setSingleStep(0.01); self.duplicate_threshold.setValue(0.96) self.keep_video = QCheckBox("Keep normalized MP4 files"); self.keep_video.setChecked(True) self.mix_frames = QCheckBox("Also mix accepted frames into one final folder") self.captions = QCheckBox("Generate basic frame captions") self.credits = QCheckBox("Generate source credits"); self.credits.setChecked(True) self.timestamps = QCheckBox("Save exact source timestamps"); self.timestamps.setChecked(True) self.permission = QComboBox() for value in ("not_verified", "user_owned", "permission_confirmed_by_user", "creative_commons_reported", "standard_youtube_license", "public_domain_claimed", "license_unknown"): self.permission.addItem(value.replace("_", " ").title(), value) self.dry_run = QCheckBox("Metadata preview only — do not download") rows = [ ("Dataset folder name", self.dataset_name), ("YouTube URLs", self.urls), ("Maximum videos", self.max_videos), ("Maximum length per video", self.max_duration), ("Maximum combined duration", self.total_duration), ("Maximum estimated download size", self.max_size), ("Preferred resolution", self.resolution), ("Audio", self.audio), ("Skip beginning", self.skip_start), ("Skip ending", self.skip_end), ("Dataset mode", self.mode), ("Extraction rate", self.frame_rate), ("Dataset limit", self.max_frames), ("Blur filter", self.remove_blur), ("Black-frame filter", self.remove_black), ("Duplicate filter", self.remove_duplicates), ("Duplicate threshold", self.duplicate_threshold), ("Original videos", self.keep_video), ("Frame layout", self.mix_frames), ("Captions", self.captions), ("Attribution", self.credits), ("Frame provenance", self.timestamps), ("Permission status", self.permission), ("Run mode", self.dry_run), ] for row, (label, widget) in enumerate(rows): form.addWidget(QLabel(label), row, 0, Qt.AlignTop) form.addWidget(widget, row, 1) scroll.setWidget(body) root.addWidget(scroll, 1) self.summary = QLabel() self.summary.setWordWrap(True) self.summary.setProperty("muted", True) root.addWidget(self.summary) self.validation = QLabel() self.validation.setWordWrap(True) root.addWidget(self.validation) buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) buttons.button(QDialogButtonBox.Ok).setText("Build collection plan") buttons.accepted.connect(self._accept_request) buttons.rejected.connect(self.reject) root.addWidget(buttons) for widget in (self.dataset_name, self.urls): signal = widget.textChanged if isinstance(widget, QLineEdit) else widget.textChanged signal.connect(self._update_summary) for widget in (self.max_videos, self.max_duration, self.total_duration, self.max_size, self.skip_start, self.skip_end, self.frame_rate, self.max_frames, self.duplicate_threshold): widget.valueChanged.connect(self._update_summary) for widget in (self.resolution, self.mode, self.permission): widget.currentIndexChanged.connect(self._update_summary) for widget in (self.audio, self.dry_run): widget.toggled.connect(self._update_summary) self.mode.currentIndexChanged.connect(self._mode_changed) self._update_summary() def _mode_changed(self) -> None: sequential = self.mode.currentData() == "sequential" self.remove_duplicates.setEnabled(not sequential) if sequential: self.remove_duplicates.setChecked(False) self._update_summary() def _update_summary(self) -> None: action = "preview metadata for" if self.dry_run.isChecked() else "collect" self.summary.setText( f"Review: {action} up to {self.max_videos.value()} video(s) at {self.resolution.currentData()}p, " f"{'with' if self.audio.isChecked() else 'without'} audio; extract {self.frame_rate.value():g} frames/second " f"in {self.mode.currentData()} mode, capped at {self.max_frames.value():,} accepted frames. " "ADAM will still show the final plan before downloading." ) def _accept_request(self) -> None: name = self.dataset_name.text().strip() urls = [line.strip() for line in self.urls.toPlainText().splitlines() if line.strip()] if not name: self.validation.setText("Enter a dataset folder name.") return if not urls or any(not re.match(r"https?://(?:www\.)?(?:youtube\.com|youtu\.be)/", url, re.I) for url in urls): self.validation.setText("Paste at least one valid YouTube video or playlist URL, one per line.") return settings = [ f"maximum {self.max_videos.value()} videos", f"maximum video duration {self.max_duration.value():g} minutes", f"maximum total duration {self.total_duration.value():g} minutes", f"maximum total size {self.max_size.value():g} MB", f"{self.resolution.currentData()}p", "with audio" if self.audio.isChecked() else "without audio", f"skip beginning {self.skip_start.value():g} seconds", f"skip ending {self.skip_end.value():g} seconds", f"{self.mode.currentData()} mode", f"{self.frame_rate.value():g} frames per second", f"maximum {self.max_frames.value()} accepted frames", "remove blurry frames" if self.remove_blur.isChecked() else "keep blurry frames", "remove black frames" if self.remove_black.isChecked() else "keep black frames", "remove near duplicates" if self.remove_duplicates.isChecked() else "keep duplicates", f"duplicate threshold {self.duplicate_threshold.value():.2f}", "keep MP4 files" if self.keep_video.isChecked() else "delete MP4 files", "mix accepted frames" if self.mix_frames.isChecked() else "separate source folders", "generate captions" if self.captions.isChecked() else "no captions", "generate source credits" if self.credits.isChecked() else "no source credits", "save exact timestamps" if self.timestamps.isChecked() else "do not save exact timestamps", f"permission status {self.permission.currentData()}", ] prefix = "Metadata-only inspect" if self.dry_run.isChecked() else "Collect a video dataset from" self.request = f"{prefix} {' '.join(urls)}. {', '.join(settings)}. Store everything in the {name} dataset folder." self.accept() class RecentPlansPanel(QFrame): selected = Signal(str) view_all_requested = Signal() def __init__(self, jobs: JobManager) -> None: super().__init__() self.jobs = jobs self.setProperty("card", True) self.setMaximumHeight(215) root = QVBoxLayout(self) root.setContentsMargins(15, 13, 15, 13) root.setSpacing(7) header = QHBoxLayout() header.addWidget(_card_title("RECENT PLANS")) self.queue_label = QLabel() self.queue_label.setProperty("muted", True) self.queue_label.setStyleSheet("font-size: 10px;") header.addStretch() header.addWidget(self.queue_label) root.addLayout(header) self.rows = QWidget() self.rows_layout = QVBoxLayout(self.rows) self.rows_layout.setContentsMargins(0, 0, 0, 0) self.rows_layout.setSpacing(5) root.addWidget(self.rows) self.view_all = QPushButton("View all plans →") self.view_all.setProperty("chip", True) self.view_all.clicked.connect(self.view_all_requested) root.addWidget(self.view_all) self.refresh() def refresh(self) -> None: while self.rows_layout.count(): item = self.rows_layout.takeAt(0) if item.widget(): item.widget().deleteLater() queued = sum( job.status in {JobStatus.SCHEDULED, JobStatus.QUEUED, JobStatus.AWAITING_CONFIRMATION} for job in self.jobs.jobs ) self.queue_label.setText(f"{queued} queued" if queued else "Queue clear") recent = self.jobs.jobs[:3] if not recent: empty = QLabel("Completed and active plans will appear here.") empty.setProperty("muted", True) empty.setWordWrap(True) self.rows_layout.addWidget(empty) return status_markers = { JobStatus.FINISHED: "✓", JobStatus.RUNNING: "●", JobStatus.PAUSED: "Ⅱ", JobStatus.FAILED: "!", JobStatus.CANCELLED: "×", JobStatus.INTERRUPTED: "!", JobStatus.AWAITING_CONFIRMATION: "?", JobStatus.SCHEDULED: "◷", JobStatus.QUEUED: "…", } for job in recent: tools = ", ".join( dict.fromkeys(step.tool_id.replace("_", " ").title() for step in job.plan.steps) ) or "Conversation" marker = status_markers.get(job.status, "·") button = QPushButton( f"{marker} {job.plan.project_name}\n {job.status.value} · {tools}" ) button.setProperty("recentPlan", True) button.setToolTip(job.plan.summary) button.clicked.connect( lambda _checked=False, job_id=job.id: self.selected.emit(job_id) ) self.rows_layout.addWidget(button) class SystemSummaryPanel(QFrame): def __init__(self) -> None: super().__init__() self.setProperty("card", True) self.setMinimumHeight(124) root = QVBoxLayout(self) root.setContentsMargins(16, 11, 16, 11) root.setSpacing(6) root.addWidget(_card_title("SYSTEM MONITOR")) row = QHBoxLayout() row.setSpacing(0) self.gpu = self._metric("GPU", "Waiting for GPU") self.cpu = self._metric("CPU", "Waiting for CPU") self.storage = self._metric("STORAGE", "Checking drive") row.addLayout(self.gpu[0], 2) row.addWidget(self._divider()) row.addLayout(self.cpu[0], 2) row.addWidget(self._divider()) row.addLayout(self.storage[0], 2) row.addWidget(self._divider()) activity_box = QVBoxLayout() activity_box.setContentsMargins(14, 0, 14, 0) activity_title = QLabel("ACTIVITY") activity_title.setProperty("muted", True) activity_title.setStyleSheet("font-size: 9px; font-weight: 700;") self.activity = SparklineWidget("Collecting activity…") self.activity.setMinimumHeight(43) self.activity.setMaximumHeight(43) activity_box.addWidget(activity_title) activity_box.addWidget(self.activity) row.addLayout(activity_box, 2) row.addWidget(self._divider()) tools_box = QVBoxLayout() tools_box.setContentsMargins(14, 0, 0, 0) tools_title = QLabel("TOOLS STATUS") tools_title.setProperty("muted", True) tools_title.setStyleSheet("font-size: 9px; font-weight: 700;") tools_box.addWidget(tools_title) tool_grid = QGridLayout() tool_grid.setHorizontalSpacing(13) tool_grid.setVerticalSpacing(3) checks = ( ("Python", bool(sys.executable)), ("Git", bool(shutil.which("git"))), ("Ollama", bool(shutil.which("ollama"))), ("FFmpeg", bool(shutil.which("ffmpeg"))), ) for index, (name, available) in enumerate(checks): label = QLabel(f"{'✓' if available else '○'} {name}") label.setStyleSheet( f"font-size: 10px; color: {COLORS['green'] if available else COLORS['muted']};" ) tool_grid.addWidget(label, index // 2, index % 2) tools_box.addLayout(tool_grid) row.addLayout(tools_box, 2) root.addLayout(row) self._activity_values: list[float] = [] @staticmethod def _divider() -> QFrame: divider = QFrame() divider.setFrameShape(QFrame.VLine) divider.setStyleSheet(f"color: {COLORS['border']};") return divider @staticmethod def _metric(title: str, initial: str) -> tuple[QVBoxLayout, QLabel, QLabel, QProgressBar]: layout = QVBoxLayout() layout.setContentsMargins(14, 0, 14, 0) layout.setSpacing(3) heading = QLabel(title) heading.setProperty("muted", True) heading.setStyleSheet("font-size: 9px; font-weight: 700;") value = QLabel(initial) value.setStyleSheet("font-size: 11px; font-weight: 600;") detail = QLabel("—") detail.setProperty("muted", True) detail.setStyleSheet("font-size: 9px;") progress = QProgressBar() progress.setRange(0, 100) layout.addWidget(heading) layout.addWidget(value) layout.addWidget(detail) layout.addWidget(progress) return layout, value, detail, progress def update_snapshot(self, snapshot: SystemSnapshot) -> None: self.gpu[1].setText(snapshot.gpu_name) temp = f" · {snapshot.gpu_temperature:.0f}°C" if snapshot.gpu_temperature is not None else "" self.gpu[2].setText( f"VRAM {snapshot.vram_used_gb:.1f} / {snapshot.vram_total_gb:.1f} GB{temp}" ) self.gpu[3].setValue(int(snapshot.vram_percent)) self.cpu[1].setText(f"Usage {snapshot.cpu_percent:.0f}%") self.cpu[2].setText( f"RAM {snapshot.memory_used_gb:.1f} / {snapshot.memory_total_gb:.1f} GB" ) self.cpu[3].setValue(int(snapshot.memory_percent)) if snapshot.disk_total_gb >= 1024: storage_text = ( f"{snapshot.disk_used_gb / 1024:.2f} / " f"{snapshot.disk_total_gb / 1024:.2f} TB" ) else: storage_text = f"{snapshot.disk_used_gb:.0f} / {snapshot.disk_total_gb:.0f} GB" self.storage[1].setText(storage_text) self.storage[2].setText(f"{snapshot.disk_percent:.0f}% used") self.storage[3].setValue(int(snapshot.disk_percent)) self._activity_values.append(max(snapshot.cpu_percent, snapshot.gpu_percent)) self._activity_values = self._activity_values[-50:] self.activity.set_values(self._activity_values) class CommandCenterPage(QWidget): provider_changed = Signal(str) tool_folders_changed = Signal() open_jobs_requested = Signal() open_dataset_lab_requested = Signal() open_experiments_requested = Signal() open_remote_requested = Signal() history_changed = Signal() def __init__( self, planner: Planner, jobs: JobManager, config: ConfigManager, tool_folders: ToolFolderManager, root_path: Path, remote_service: RemoteAccessService | None = None, ) -> None: super().__init__() self.setMinimumHeight(820) self.planner = planner self.jobs = jobs self.config = config self.tool_folders = tool_folders self.root_path = root_path self.remote_service = remote_service self.selected_job: Job | None = None self._announced: set[tuple[str, JobStatus]] = set() self._planning_worker: PlanningWorker | None = None self._chat_worker: ChatWorker | None = None self._planning_bubble: ChatBubble | None = None self._streamed_text = "" self._chat_request = "" self._chat_history: list[dict[str, str]] = [] self._conversation_entries: list[dict[str, str]] = [] self.history_store = ChatHistoryStore(root_path) self._generation_cards: dict[str, GenerationChatCard] = {} self._prompt_reference_image = "" self._pending_schedule_for: str | None = None self.latest_snapshot = SystemSnapshot() root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) header_row = QHBoxLayout() header = _page_header( "Command center", "Describe the outcome. ADAM will propose an allow-listed plan before any work begins.", ) header.setMinimumHeight(58) header_row.addWidget(header, 1) self.new_chat_button = QPushButton("＋ New Chat") self.new_chat_button.setProperty("chip", True) self.new_chat_button.setToolTip("Archive this conversation and start fresh") self.new_chat_button.clicked.connect(self.start_new_chat) header_row.addWidget(self.new_chat_button, 0, Qt.AlignTop) self.mode_selector = QComboBox() self.mode_selector.addItem("Trainer Mode", "trainer") self.mode_selector.addItem("Chat Mode", "chat") mode_index = self.mode_selector.findData( self.config.get("command_center_mode", "trainer") ) self.mode_selector.setCurrentIndex(max(0, mode_index)) self.mode_selector.setMinimumWidth(145) self.mode_selector.setToolTip( "Trainer Mode plans registered work. Chat Mode only talks with Ollama." ) header_row.addWidget(self.mode_selector, 0, Qt.AlignTop) self.provider_badge = QLabel() self.provider_badge.setAlignment(Qt.AlignCenter) self.provider_badge.setMinimumWidth(190) self.provider_badge.setStyleSheet( f"background: #091a27; border: 1px solid {COLORS['border_bright']}; " f"border-radius: 15px; padding: 7px 12px; color: {COLORS['blue_2']}; " "font-size: 11px; font-weight: 700;" ) self.refresh_provider_badge() header_row.addWidget(self.provider_badge, 0, Qt.AlignTop) root.addLayout(header_row) columns = QHBoxLayout() columns.setSpacing(12) left = self._build_chat() self.right_panels = QWidget() self.right_panels.setMaximumWidth(390) right_layout = QVBoxLayout(self.right_panels) right_layout.setContentsMargins(0, 0, 0, 0) right_layout.setSpacing(12) self.plan_panel = PlanPanel() self.recent_panel = RecentPlansPanel(self.jobs) self.active_panel = ActiveJobPanel() self.plan_shell = CollapsiblePanel( "CURRENT PLAN", self.plan_panel, config, "command_center_current_plan_collapsed", "right" ) self.recent_shell = CollapsiblePanel( "RECENT PLANS", self.recent_panel, config, "command_center_recent_plans_collapsed", "right" ) self.active_shell = CollapsiblePanel( "ACTIVE JOB", self.active_panel, config, "command_center_active_job_collapsed", "right" ) for shell in (self.plan_shell, self.recent_shell, self.active_shell): shell.collapsed_changed.connect(self._update_right_panel_width) right_layout.addWidget(shell, 0, Qt.AlignRight) self.remote_shell = CollapsiblePanel( "PHONE REMOTE", self._build_remote_shortcut(), config, "command_center_phone_remote_collapsed", "right", ) self.remote_shell.collapsed_changed.connect(self._update_right_panel_width) right_layout.addWidget(self.remote_shell, 0, Qt.AlignRight) right_layout.addStretch(1) columns.addWidget(left, 1) columns.addWidget(self.right_panels) self._update_right_panel_width() root.addLayout(columns, 1) self.system_summary = SystemSummaryPanel() self.system_shell = CollapsiblePanel( "SYSTEM MONITOR", self.system_summary, config, "command_center_system_monitor_collapsed" ) root.addWidget(self.system_shell) self.plan_panel.approved.connect(self.jobs.confirm) self.plan_panel.rejected.connect(self.jobs.reject) self.active_panel.pause_requested.connect(self.jobs.pause) self.active_panel.resume_requested.connect(self.jobs.resume) self.active_panel.cancel_requested.connect(self.jobs.cancel) self.active_panel.open_requested.connect(self.open_output) self.jobs.job_created.connect(self._job_created) self.jobs.job_updated.connect(self._job_updated) self.jobs.active_changed.connect(self.active_panel.set_job) self.jobs.active_changed.connect( lambda job: self.recent_shell.setVisible(job is None) ) self.recent_panel.selected.connect(self._select_recent_job) self.recent_panel.view_all_requested.connect(self.open_jobs_requested) if self.jobs.active_job: self.active_panel.set_job(self.jobs.active_job) self.mode_selector.currentIndexChanged.connect(self._mode_changed) self._apply_mode_ui(announce=False) self._set_controls_collapsed( bool(self.config.get("command_center_controls_collapsed", False)), persist=False, ) def _build_remote_shortcut(self) -> QFrame: card = _card() card.setMaximumWidth(390) layout = QVBoxLayout(card) layout.setContentsMargins(14, 12, 14, 12) layout.setSpacing(7) layout.addWidget(_card_title("PHONE REMOTE")) self.command_qr = QLabel("Enable phone access in Remote Access to show a QR code.") self.command_qr.setAlignment(Qt.AlignCenter) self.command_qr.setMinimumHeight(120) self.command_qr.setStyleSheet("background: white; color: #183246; border-radius: 6px; padding: 6px;") layout.addWidget(self.command_qr) self.command_remote_link = QPushButton("Open phone remote site") self.command_remote_link.setProperty("chip", True) self.command_remote_link.clicked.connect(self._open_phone_remote) layout.addWidget(self.command_remote_link) self.command_remote_hint = QLabel() self.command_remote_hint.setWordWrap(True) self.command_remote_hint.setProperty("muted", True) layout.addWidget(self.command_remote_hint) self.refresh_remote_access() return card def refresh_remote_access(self) -> None: service = self.remote_service if not hasattr(self, "_remote_link_reader"): self._remote_link_reader = BackgroundRead(self) self._remote_link_reader.ready.connect(self._remote_url_loaded) self._remote_link_reader.request(lambda: (service.settings(), service.phone_test_url()) if service else ({}, ""), force=True) def _remote_url_loaded(self, result: object) -> None: settings, url = result if self.remote_service and settings != self.remote_service.settings(): self.refresh_remote_access() return if getattr(self, "_remote_qr_url", None) == url: return self._remote_qr_url = url self.command_remote_link.setEnabled(bool(url)) if not url: self.command_qr.setPixmap(QPixmap()) self.command_qr.setText("Enable phone access in Remote Access to show a QR code.") self.command_remote_hint.setText("Remote control opens from the same Wi-Fi after phone access is enabled.") return try: import qrcode image = qrcode.make(url).convert("RGB") buffer = BytesIO() image.save(buffer, format="PNG") pixmap = QPixmap() pixmap.loadFromData(buffer.getvalue(), "PNG") self.command_qr.setText("") self.command_qr.setPixmap(pixmap.scaled(180, 180, Qt.KeepAspectRatio, Qt.SmoothTransformation)) self.command_remote_hint.setText(url) except ImportError: self.command_qr.setPixmap(QPixmap()) self.command_qr.setText("QR code support is unavailable.") self.command_remote_hint.setText(url) def _open_phone_remote(self) -> None: if self.remote_service: url = self.remote_service.phone_test_url() if url: QDesktopServices.openUrl(QUrl(url)) def _build_chat(self) -> QFrame: frame = _card() layout = QVBoxLayout(frame) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) chat_header = QHBoxLayout() chat_header.setContentsMargins(18, 15, 18, 12) chat_header.addWidget(_card_title("CONVERSATION")) chat_header.addStretch() self.chat_new_button = QPushButton("＋ New Chat") self.chat_new_button.setProperty("chip", True) self.chat_new_button.setToolTip("Archive this conversation and start fresh") self.chat_new_button.clicked.connect(self.start_new_chat) chat_header.addWidget(self.chat_new_button) online = QLabel("● LOCAL & PRIVATE") online.setStyleSheet( f"color: {COLORS['green']}; font-size: 10px; font-weight: 700;" ) chat_header.addWidget(online) layout.addLayout(chat_header) self.scroll = QScrollArea() self.scroll.setWidgetResizable(True) self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.scroll.viewport().setStyleSheet(f"background: {COLORS['surface']};") self.messages = QWidget() self.messages.setStyleSheet(f"background: {COLORS['surface']};") self.messages_layout = QVBoxLayout(self.messages) self.messages_layout.setContentsMargins(18, 6, 18, 14) self.messages_layout.setSpacing(11) self.messages_layout.addWidget(self._build_welcome()) self.messages_layout.addStretch(1) self.scroll.setWidget(self.messages) layout.addWidget(self.scroll, 1) actions = QWidget() actions_root = QVBoxLayout(actions) actions_root.setContentsMargins(14, 8, 14, 10) actions_root.setSpacing(7) actions_header = QHBoxLayout() actions_header.addWidget(_card_title("SUGGESTED ACTIONS")) actions_header.addStretch() self.controls_toggle = QPushButton("−") self.controls_toggle.setProperty("chip", True) self.controls_toggle.setFixedSize(30, 25) self.controls_toggle.setToolTip("Hide suggested actions and shortcuts") self.controls_toggle.clicked.connect(self._toggle_controls) actions_header.addWidget(self.controls_toggle) actions_root.addLayout(actions_header) self.actions_content = QWidget() actions_content_layout = QVBoxLayout(self.actions_content) actions_content_layout.setContentsMargins(0, 0, 0, 0) actions_content_layout.setSpacing(0) self.actions_grid = QGridLayout() self.actions_grid.setContentsMargins(0, 0, 0, 0) self.actions_grid.setHorizontalSpacing(8) self.actions_grid.setVerticalSpacing(8) actions_content_layout.addLayout(self.actions_grid) self.action_cards: list[QPushButton] = [] action_specs = ( ("Auto-detect settings", "Recommend a safe\ntraining recipe.", self._open_model_assistant), ("Dataset Lab / EVE", "Inspect datasets,\ncaptions, and files.", self.open_dataset_lab_requested.emit), ("Compare runs", "Review experiment\ndifferences side by side.", self.open_experiments_requested.emit), ("Remote control", "Configure browser\nstatus access.", self.open_remote_requested.emit), ("Transcript to dataset", "Convert local video\nspeech into samples.", self.open_dataset_lab_requested.emit), ("Overnight queue", "Plan sequential jobs\nfor unattended runs.", self._open_model_batch_assistant), ("Generate an image", "Create it here from a\ncompleted model.", lambda: self.submit('Generate a DDPM image of "A new sample" for 100 steps on DDIM sampler with aspect ratio 16:9')), ) for title, description, callback in action_specs: button = QPushButton(f"{title}\n{description}") button.setProperty("workflowCard", True) button.setMinimumWidth(0) button.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) button.setToolTip(f"Start: {title}") button.clicked.connect(lambda _checked=False, action=callback: action()) self.action_cards.append(button) self._reflow_actions(2) actions_root.addWidget(self.actions_content) layout.addWidget(actions) self.utilities = QWidget() utilities_layout = QHBoxLayout(self.utilities) utilities_layout.setContentsMargins(14, 0, 14, 7) utilities_layout.setSpacing(7) for title, callback in ( ("Create a model…", self._open_model_assistant), ("Create model batch…", self._open_model_batch_assistant), ("Fine-tune…", self._open_fine_tune_assistant), ("Collect video…", self._open_video_dataset_assistant), ): button = QPushButton(title) button.setProperty("chip", True) button.clicked.connect(callback) utilities_layout.addWidget(button) utilities_layout.addStretch() layout.addWidget(self.utilities) composer = QFrame() composer.setStyleSheet( f"border-top: 1px solid {COLORS['border']}; background: #071019;" ) composer_layout = QVBoxLayout(composer) composer_layout.setContentsMargins(15, 13, 15, 13) composer_layout.setSpacing(7) self.reference_chip = QFrame() self.reference_chip.setProperty("innerCard", True) reference_layout = QHBoxLayout(self.reference_chip) reference_layout.setContentsMargins(7, 5, 7, 5) reference_layout.setSpacing(7) self.reference_thumbnail = QLabel() self.reference_thumbnail.setFixedSize(42, 42) self.reference_thumbnail.setAlignment(Qt.AlignCenter) self.reference_name = QLabel() self.reference_name.setProperty("muted", True) remove_reference = QPushButton("×") remove_reference.setFixedSize(26, 26) remove_reference.setToolTip("Remove reference image") remove_reference.clicked.connect(self._clear_prompt_reference) reference_layout.addWidget(self.reference_thumbnail) reference_layout.addWidget(self.reference_name) reference_layout.addStretch() reference_layout.addWidget(remove_reference) self.reference_chip.hide() composer_layout.addWidget(self.reference_chip) input_row = QHBoxLayout() input_row.setSpacing(10) self.add_reference_button = QPushButton("+") self.add_reference_button.setFixedSize(34, 34) self.add_reference_button.setToolTip("Attach a reference image") self.add_reference_button.clicked.connect(self._choose_prompt_reference) self.prompt = PromptEdit() self.prompt.setPlaceholderText( "Tell ADAM what you want to accomplish… (Shift+Enter for a new line)" ) self.prompt.setMinimumHeight(66) self.prompt.send_requested.connect(self._submit_prompt) prompt_column = QVBoxLayout() prompt_column.setContentsMargins(0, 0, 0, 0) prompt_column.setSpacing(0) prompt_column.addWidget(self.prompt) prompt_column.addWidget(PromptResizeHandle(self.prompt)) self.send_button = QPushButton("Plan request →") self.send_button.setProperty("primary", True) self.send_button.setStyleSheet( f"background-color: {COLORS['blue']}; color: #00101b; " f"border: 1px solid {COLORS['blue_2']}; font-weight: 700;" ) self.send_button.setFixedHeight(43) self.send_button.clicked.connect(self._submit_prompt) input_row.addWidget(self.add_reference_button, 0, Qt.AlignVCenter) input_row.addLayout(prompt_column, 1) input_row.addWidget(self.send_button, 0, Qt.AlignVCenter) composer_layout.addLayout(input_row) layout.addWidget(composer) return frame def _update_right_panel_width(self, _collapsed: bool = False) -> None: shells = (self.plan_shell, self.recent_shell, self.active_shell, self.remote_shell) all_collapsed = all(shell.collapsed for shell in shells) if all_collapsed: self.right_panels.setFixedWidth(45) else: self.right_panels.setMinimumWidth(330) self.right_panels.setMaximumWidth(390) def _build_welcome(self) -> QWidget: welcome = QWidget() row = QHBoxLayout(welcome) row.setContentsMargins(0, 0, 0, 0) row.setSpacing(20) greeting = ChatBubble( "Good to see you. I can coordinate a LoRA pipeline, prepare datasets, " "generate previews, or inspect this system. I’ll always show the plan " "before collection or training begins.", label="ADAM · READY", ) greeting.setMaximumWidth(300) self.welcome_greeting = greeting greeting.hide() row.addWidget(greeting, 0, Qt.AlignTop) brand = QWidget() self.welcome_brand = brand brand_layout = QHBoxLayout(brand) brand_layout.setContentsMargins(8, 2, 8, 2) brand_layout.setSpacing(16) logo = QLabel() pixmap = QPixmap(str(self.root_path / "assets" / "adam_atom.png")) if not pixmap.isNull(): logo.setPixmap( pixmap.scaled(138, 138, Qt.KeepAspectRatio, Qt.SmoothTransformation) ) logo.setFixedSize(142, 142) copy = QVBoxLayout() copy.setSpacing(4) name = QLabel("A D A M") name.setStyleSheet("font-size: 31px; font-weight: 650; letter-spacing: 6px;") meaning = QLabel("AI DEVELOPMENT AND\nAUTOMATION MANAGER") meaning.setStyleSheet("font-size: 11px; font-weight: 600; letter-spacing: 2px;") slogan = QLabel("Plan it. Prepare it. Train it.") slogan.setProperty("muted", True) slogan.setStyleSheet("font-size: 12px; padding-top: 8px;") copy.addStretch() copy.addWidget(name) copy.addWidget(meaning) copy.addWidget(slogan) copy.addStretch() brand_layout.addWidget(logo) brand_layout.addLayout(copy) row.addWidget(brand, 1) return welcome def start_new_chat(self, _checked: bool = False, *, archive: bool = True) -> None: busy = bool( (self._planning_worker and self._planning_worker.isRunning()) or (self._chat_worker and self._chat_worker.isRunning()) ) if busy: QMessageBox.information( self, "ADAM is still working", "Wait for the current response to finish before starting a new chat.", ) return if archive and self.history_store.save_conversation( self._conversation_entries, str(self.mode_selector.currentData()) ): self.history_changed.emit() self._clear_message_canvas() self._chat_history = [] self._conversation_entries = [] self._generation_cards = {} self._planning_bubble = None self._streamed_text = "" self._chat_request = "" self._clear_prompt_reference() self.prompt.clear() self.messages_layout.insertWidget(0, self._build_welcome()) self.prompt.setFocus() def open_conversation(self, conversation: dict) -> None: self.start_new_chat(archive=True) mode = str(conversation.get("mode", "trainer")) mode_index = self.mode_selector.findData(mode) if mode_index >= 0: self.mode_selector.blockSignals(True) self.mode_selector.setCurrentIndex(mode_index) self.mode_selector.blockSignals(False) self._apply_mode_ui(announce=False) for entry in conversation.get("entries", []): self.add_message( str(entry.get("text", "")), user=bool(entry.get("user", False)), label=str(entry.get("label", "YOU" if entry.get("user") else "ADAM")), record=True, ) self._chat_history = [ {"role": "user" if entry.get("user") else "assistant", "content": str(entry.get("text", ""))} for entry in conversation.get("entries", []) if str(entry.get("text", "")).strip() ][-20:] def _clear_message_canvas(self) -> None: while self.messages_layout.count() > 1: item = self.messages_layout.takeAt(0) if item.widget(): item.widget().deleteLater() def _reflow_actions(self, columns: int) -> None: while self.actions_grid.count(): self.actions_grid.takeAt(0) for index, button in enumerate(self.action_cards): self.actions_grid.addWidget(button, index // columns, index % columns) def _toggle_controls(self) -> None: self._set_controls_collapsed( self.actions_content.isVisible(), persist=True ) def _set_controls_collapsed(self, collapsed: bool, *, persist: bool) -> None: self.actions_content.setVisible(not collapsed) self.utilities.setVisible(not collapsed) self.controls_toggle.setText("+" if collapsed else "−") self.controls_toggle.setToolTip( "Show suggested actions and shortcuts" if collapsed else "Hide suggested actions and shortcuts" ) if persist: self.config.update({"command_center_controls_collapsed": collapsed}) def resizeEvent(self, event) -> None: super().resizeEvent(event) if hasattr(self, "actions_grid"): available = max(1, self.width() - 390) columns = 7 if available >= 1120 else 4 if available >= 680 else 2 self.welcome_greeting.setVisible(available >= 650) if getattr(self, "_action_columns", None) != columns: self._action_columns = columns self._reflow_actions(columns) def _open_model_assistant(self) -> None: if self.mode_selector.currentData() != "trainer": self.mode_selector.setCurrentIndex(self.mode_selector.findData("trainer")) dialog = ModelCreationDialog(self.planner, self.config, self) if dialog.exec() == QDialog.Accepted and dialog.requests: self._pending_schedule_for = dialog.scheduled_for if len(dialog.requests) == 1: self.submit(dialog.requests[0]) else: self.submit_training_batch(dialog.requests) def _open_model_batch_assistant(self) -> None: if self.mode_selector.currentData() != "trainer": self.mode_selector.setCurrentIndex(self.mode_selector.findData("trainer")) dialog = ModelCreationDialog(self.planner, self.config, self) dialog.setWindowTitle("Model Batch Builder") QTimer.singleShot(0, dialog._bulk_add_models) if dialog.exec() == QDialog.Accepted and dialog.requests: self._pending_schedule_for = dialog.scheduled_for self.submit_training_batch(dialog.requests) def submit_training_batch(self, requests: list[str]) -> None: if self._planning_worker and self._planning_worker.isRunning(): self.add_message("I’m still interpreting the previous request.", label="ADAM · PLANNING") return self.add_message( f"Create a sequential training batch with {len(requests)} models.", user=True ) self._streamed_text = "" self._planning_bubble = self.add_message("Planning the model batch…", label="ADAM · PLANNING") self._planning_worker = BatchPlanningWorker(self.planner, requests) self._planning_worker.chunk.connect(self._planning_chunk) self._planning_worker.planned.connect(self._planning_finished) self._planning_worker.failed.connect(self._planning_failed) self._planning_worker.finished.connect(self._planning_worker_finished) self.send_button.setEnabled(False) self.mode_selector.setEnabled(False) self.send_button.setText("Planning…") self._planning_worker.start() def _open_fine_tune_assistant(self) -> None: if self.mode_selector.currentData() != "trainer": self.mode_selector.setCurrentIndex(self.mode_selector.findData("trainer")) dialog = FineTuneDialog(self.planner, self) if dialog.exec() == QDialog.Accepted and dialog.request: self.submit(dialog.request) def _open_video_dataset_assistant(self) -> None: if self.mode_selector.currentData() != "trainer": self.mode_selector.setCurrentIndex(self.mode_selector.findData("trainer")) dialog = VideoDatasetDialog(self) if dialog.exec() == QDialog.Accepted and dialog.request: self.submit(dialog.request) def add_message( self, text: str, *, user: bool = False, label: str = "", record: bool = True ) -> ChatBubble: wrapper = QWidget() wrapper_layout = QHBoxLayout(wrapper) wrapper_layout.setContentsMargins(0, 0, 0, 0) bubble = ChatBubble(text, user=user, label=label) if user: wrapper_layout.addStretch(1) wrapper_layout.addWidget(bubble) else: wrapper_layout.addWidget(bubble) wrapper_layout.addStretch(1) self.messages_layout.insertWidget(self.messages_layout.count() - 1, wrapper) if record and text.strip() and text.strip() not in {"Thinking…", "Planning the model batch…"}: self._conversation_entries.append( {"text": text, "user": user, "label": label or ("YOU" if user else "ADAM")} ) QTimer.singleShot( 0, lambda: self.scroll.verticalScrollBar().setValue( self.scroll.verticalScrollBar().maximum() ), ) return bubble def _submit_prompt(self) -> None: text = self.prompt.toPlainText().strip() if text: self.prompt.clear() self.submit(text) def _choose_prompt_reference(self) -> None: path, _ = QFileDialog.getOpenFileName( self, "Choose reference image", self._prompt_reference_image, "Images (*.png *.jpg *.jpeg *.webp *.bmp)", ) if not path: return self._prompt_reference_image = path pixmap = QPixmap(path) self.reference_thumbnail.setPixmap( pixmap.scaled(42, 42, Qt.KeepAspectRatio, Qt.SmoothTransformation) ) self.reference_name.setText(Path(path).name) self.reference_chip.show() def _clear_prompt_reference(self) -> None: self._prompt_reference_image = "" self.reference_thumbnail.clear() self.reference_name.clear() self.reference_chip.hide() def submit(self, request: str) -> None: planning_busy = self._planning_worker and self._planning_worker.isRunning() chatting_busy = self._chat_worker and self._chat_worker.isRunning() if planning_busy or chatting_busy: self.add_message( "I’m still interpreting the previous request. The rest of ADAM remains usable.", label="ADAM · PLANNING", ) return attached_image = self._prompt_reference_image visible_request = ( f"{request}\n\n[Attached image: {Path(attached_image).name}]" if attached_image and self.mode_selector.currentData() == "chat" else request ) self.add_message(visible_request, user=True) generation_request = parse_chat_generation_request(request) # Metadata is a structured generation command, even if the Command # Center was left in Chat mode when it was pasted. if generation_request and generation_request.is_pasted_metadata: if self._prompt_reference_image: generation_request = replace( generation_request, reference_image=self._prompt_reference_image ) self._start_generation(generation_request) return if self.mode_selector.currentData() == "chat": if is_pending_job_confirmation_request(request): pending = self.selected_job if pending and pending.status == JobStatus.AWAITING_CONFIRMATION: self.jobs.confirm(pending.id) self.add_message( f"Approved plan {pending.plan.id.upper()}. ADAM has queued the registered work.", label="ADAM · PLAN APPROVED", ) else: self.add_message( "There is no reviewed plan waiting for approval. Ask me to create the training plan first, then approve the plan ADAM shows you.", label="ADAM · NEEDS A PLAN", ) if attached_image: self._clear_prompt_reference() return if is_explicit_action_request(request): planning_request, subject = self._expand_chat_subject_reference(request) if attached_image: self._clear_prompt_reference() self._start_planning( planning_request, ( f"Using the earlier subject idea: {subject}\n\n" "Checking this request against ADAM’s registered workflows…" if subject else "Checking this request against ADAM’s registered workflows…" ), ) return self._start_chat(request, [attached_image] if attached_image else []) if attached_image: self._clear_prompt_reference() return if generation_request: if self._prompt_reference_image: generation_request = replace( generation_request, reference_image=self._prompt_reference_image ) self._start_generation(generation_request) return assignments = self.tool_folders.parse_assignments(request) if assignments: statuses = self.tool_folders.update(assignments) lines = [] valid_count = 0 for status in statuses.values(): if status.valid: valid_count += 1 entries = ", ".join(status.entry_points) lines.append(f"✓ {status.name}: connected ({entries})") else: lines.append(f"✕ {status.name}: {status.message}") self.add_message( "I saved the tool folder configuration.\n\n" + "\n".join(lines), label=( "ADAM · TOOLS CONNECTED" if valid_count == len(statuses) else "ADAM · FOLDER CHECK" ), ) self.tool_folders_changed.emit() return self._start_planning(request) def _expand_chat_subject_reference(self, request: str) -> tuple[str, str | None]: for item in reversed(self._chat_history): if item.get("role") != "assistant": continue expanded, subject = expand_subject_reference(request, item.get("content", "")) if subject: return expanded, subject return request, None def _start_planning(self, request: str, message: str = "Thinking…") -> None: self._streamed_text = "" self._planning_bubble = self.add_message(message, label="ADAM · PLANNING") self._planning_worker = PlanningWorker(self.planner, request) self._planning_worker.chunk.connect(self._planning_chunk) self._planning_worker.planned.connect(self._planning_finished) self._planning_worker.failed.connect(self._planning_failed) self._planning_worker.finished.connect(self._planning_worker_finished) self.send_button.setEnabled(False) self.mode_selector.setEnabled(False) self.send_button.setText("Planning…") self._planning_worker.start() def _generation_model_is_ready(self, asset) -> bool: path = Path(asset.path) if asset.trainer == "ddpm": return path.is_dir() and (path / "model_index.json").is_file() if asset.trainer == "flow": return path.is_dir() and (path / "flow_model_info.json").is_file() and (path / "unet" / "config.json").is_file() if asset.trainer == "lora": return ( path.is_file() and path.suffix.casefold() == ".safetensors" and "_comfy" not in path.stem.casefold() ) or ( path.is_dir() and any(item.is_file() and item.suffix.casefold() == ".safetensors" and "_comfy" not in item.stem.casefold() for item in path.glob("*.safetensors")) ) return path.exists() def _start_generation(self, parsed: ChatGenerationRequest) -> None: asset_refresh(self.planner.assets, self.config).request() tools = generation_tools(self.planner.registry) stable_diffusion_request = ( parsed.has_positive_prompt or bool(parsed.base_model_query) or bool(parsed.negative_prompt) or parsed.cfg_scale is not None or parsed.lora_strength is not None or parsed.denoise_strength is not None ) plain_model_search = ( not parsed.provider_hint and not stable_diffusion_request and not parsed.model_query ) # Positive Prompt is the explicit Stable Diffusion signal. A named LoRA # still remains active when a base checkpoint is supplied alongside it. base_only = ( stable_diffusion_request and parsed.provider_hint != "lora" and not parsed.model_query ) preferred_id = { "ddpm": "ddpm_generator", "flow": "flow_generator", "lora": "lora_generator", "pixelrow": "pixelrow_generator", "inrflow": "inrflow_generator", }.get(parsed.provider_hint, "") if stable_diffusion_request and parsed.provider_hint not in {"ddpm", "flow", "inrflow", "pixelrow"}: preferred_id = "lora_generator" preferred_tool = next((item for item in tools if item.id == preferred_id), None) if parsed.provider_hint and preferred_tool is None: self.add_message( f"The requested {parsed.provider_hint.upper()} image generator is not currently available.", label="ADAM · GENERATION NEEDS DETAILS", ) return candidates = [ asset for asset in self.planner.assets.assets if asset.kind == "model" and (not plain_model_search or asset.trainer in {"ddpm", "flow"}) and not ( plain_model_search and parsed.reference_image and asset.trainer == "flow" ) and any( asset.trainer in item.model_trainers for item in ([preferred_tool] if preferred_tool else tools) if item is not None ) and self._generation_model_is_ready(asset) ] model_query = parsed.model_query or (parsed.subject if not base_only else "") scored = sorted( ( (generation_model_match_score(model_query, asset.name), asset) for asset in candidates ), key=lambda item: item[0], reverse=True, ) model = next( ( asset for asset in candidates if parsed.metadata_model_path and Path(asset.path).resolve() == Path(parsed.metadata_model_path).expanduser().resolve() ), None, ) if model is None and parsed.metadata_model_path: direct_path = Path(parsed.metadata_model_path).expanduser() if direct_path.is_file() and direct_path.suffix.casefold() == ".safetensors": model = Asset( id="pasted-metadata", kind="model", name=direct_path.stem, path=str(direct_path.resolve()), trainer="lora", ) if model is None: model = scored[0][1] if scored and scored[0][0] > 0 else None if model is None and not model_query and len(candidates) == 1: model = candidates[0] if model is None and plain_model_search: # If there is no matching unconditional model, the subject can still # be rendered as a normal Stable Diffusion prompt. base_only = True preferred_tool = next( (item for item in tools if item.id == "lora_generator"), None ) model_query = "" if model is None and not base_only: detail = f' matching “{model_query}”' if model_query else "" examples: list[str] = [] for asset in candidates: if asset.name not in examples: examples.append(asset.name) if len(examples) == 4: break example_text = f" Available examples: {', '.join(examples)}." if examples else "" self.add_message( f"I couldn’t find a completed image model{detail}, so I did not substitute the model selected in Generations.{example_text} Try: Generate an image using model “Model Name”.", label="ADAM · GENERATION NEEDS MODEL", ) return tool = next( ( item for item in ([preferred_tool] if preferred_tool else tools) if item is not None and (base_only or model.trainer in item.model_trainers) ), None, ) if tool is None: self.add_message( "The matching model does not have an available image generator.", label="ADAM · GENERATION UNAVAILABLE", ) return if parsed.reference_image and "reference_image" not in tool.capabilities: self.add_message( f"{tool.name} does not support reference-image conditioning. Remove the attachment or choose LoRA/Stable Diffusion or DDPM.", label="ADAM · REFERENCE IMAGE UNSUPPORTED", ) return options = tool.generation_options saved_generation = self.config.get("generation_settings", {}) saved_generation = saved_generation if isinstance(saved_generation, dict) else {} sampler_options = [str(value) for value in options.get("samplers", [])] sampler = parsed.sampler or (str(saved_generation.get("sampler", "")) if tool.id == "lora_generator" else "") if sampler not in sampler_options: sampler = sampler_options[0] if sampler_options else sampler or "DDIM" aspect_options = [str(value) for value in options.get("aspect_ratios", [])] aspect = parsed.aspect_ratio or (str(saved_generation.get("aspect", "")) if tool.id == "lora_generator" else "") if aspect and aspect not in aspect_options: aspect = next((value for value in aspect_options if value.startswith(f"{aspect} ") or value == aspect), "") if not aspect: aspect = aspect_options[0] if aspect_options else "1:1 (Square)" step_min = int(options.get("step_min", 1) or 1) step_max = int(options.get("step_max", 500) or 500) default_steps = saved_generation.get("steps", options.get("step_default", 50)) if tool.id == "lora_generator" else options.get("step_default", 50) steps = parsed.steps if parsed.steps is not None else int(default_steps or 50) steps = max(step_min, min(steps, step_max)) count_limit = 8 if tool.id == "lora_generator" else 32 default_count = int(saved_generation.get("images", 1) or 1) if tool.id == "lora_generator" else 1 count = max(1, min(parsed.image_count or default_count, count_limit)) seed = parsed.seed if parsed.seed is not None else 0 extra_arguments = {} if tool.id == "ddpm_generator": extra_arguments = { "reference_image": parsed.reference_image, "reference_strength": max(0, min(parsed.reference_strength if parsed.reference_strength is not None else 65, 100)), "width": 0, "height": 0, } elif tool.id == "lora_generator": base_assets = [ asset for asset in self.planner.assets.assets if asset.kind == "base_model" and Path(asset.path).exists() ] base_model_path = "" if parsed.metadata_base_model_path and Path(parsed.metadata_base_model_path).expanduser().is_file(): base_model_path = str(Path(parsed.metadata_base_model_path).expanduser().resolve()) elif parsed.base_model_query: scored_bases = sorted( ( (generation_model_match_score(parsed.base_model_query, asset.name), asset) for asset in base_assets ), key=lambda item: item[0], reverse=True, ) if scored_bases and scored_bases[0][0] > 0: base_model_path = scored_bases[0][1].path if not base_model_path: self.add_message( f"I couldn’t find a Stable Diffusion base model matching “{parsed.base_model_query}”.", label="ADAM · LORA NEEDS BASE MODEL", ) return # A fresh Command Center image request should have a dependable SDXL # fallback instead of relying on whichever model the external trainer # happened to use last. if not base_model_path: preferred_base = next( ( asset for asset in base_assets if "waiillustrious" in "".join( character for character in asset.name.casefold() if character.isalnum() ) or "wallilustrious" in "".join( character for character in asset.name.casefold() if character.isalnum() ) ), None, ) if preferred_base is not None: base_model_path = preferred_base.path if not base_model_path: selected_base = str(saved_generation.get("base_model_path", "")) if selected_base and Path(selected_base).expanduser().exists(): base_model_path = selected_base if not base_model_path: trainer_root = Path(str(self.config.get("tool_folders", {}).get("lora_trainer", ""))) try: trainer_settings = json.loads( (trainer_root / "config" / "app_settings.json").read_text(encoding="utf-8") ) configured_base = str( trainer_settings.get("generate_model") or trainer_settings.get("last_model") or "" ) configured_path = Path(configured_base).expanduser() if configured_base and not configured_path.is_absolute(): configured_path = trainer_root / configured_path if configured_base and configured_path.exists(): base_model_path = str(configured_path.resolve()) except (OSError, ValueError, TypeError, json.JSONDecodeError): pass if not base_model_path and len(base_assets) == 1: base_model_path = base_assets[0].path if not base_model_path: names = ", ".join(asset.name for asset in base_assets[:4]) available = f" Available base models: {names}." if names else "" self.add_message( "LoRA generation also needs a Stable Diffusion base model. Put one in “LoRA StableDiffusionModels Here”, or select one in the Generations tab." + available, label="ADAM · LORA NEEDS BASE MODEL", ) return extra_arguments = { "negative_prompt": parsed.negative_prompt or str(saved_generation.get("negative_prompt", "")), "base_model_path": base_model_path, "width": parsed.width or 0, "height": parsed.height or 0, "cfg_scale": parsed.cfg_scale if parsed.cfg_scale is not None else float(saved_generation.get("cfg_scale", 0) or 0), "lora_strength": 0.0 if base_only else (parsed.lora_strength if parsed.lora_strength is not None else float(saved_generation.get("lora_strength", 0) or 0)), "reference_image": parsed.reference_image, "denoise_strength": parsed.denoise_strength if parsed.denoise_strength is not None else float(saved_generation.get("denoise_strength", 0) or 0), "prompt_weighting": bool(saved_generation.get("prompt_weighting", True)), } plan = build_generation_plan( tool, model_name=(Path(extra_arguments.get("base_model_path", "")).stem if base_only else model.name), model_path="" if base_only else model.path, prompt=parsed.prompt, image_count=count, steps=steps, seed=seed, sampler=sampler, aspect_ratio=aspect, extra_arguments=extra_arguments, ) job = self.jobs.submit(plan) if parsed.reference_image: self._clear_prompt_reference() self.selected_job = job self.plan_panel.set_job(job) card = GenerationChatCard(job, self.root_path / "assets" / "adam_atom.png") card.cancel_requested.connect(self.jobs.cancel) card.open_requested.connect( lambda path: QDesktopServices.openUrl(QUrl.fromLocalFile(path)) if path else None ) wrapper = QWidget() wrapper_layout = QHBoxLayout(wrapper) wrapper_layout.setContentsMargins(0, 0, 0, 0) wrapper_layout.addWidget(card) wrapper_layout.addStretch(1) self.messages_layout.insertWidget(self.messages_layout.count() - 1, wrapper) self._generation_cards[job.id] = card QTimer.singleShot(0, lambda: self.scroll.verticalScrollBar().setValue(self.scroll.verticalScrollBar().maximum())) def _planning_chunk(self, chunk: str) -> None: self._streamed_text += chunk if self._planning_bubble: self._planning_bubble.set_label("ADAM") self._planning_bubble.set_text(self._streamed_text) def _planning_failed(self, message: str) -> None: self._pending_schedule_for = None if self._planning_bubble: self._planning_bubble.set_label("ADAM · NEEDS INPUT") self._planning_bubble.set_text(message) self._conversation_entries.append({"text": message, "user": False, "label": "ADAM · NEEDS INPUT"}) def _planning_worker_finished(self) -> None: self.send_button.setEnabled(True) self.mode_selector.setEnabled(True) self._apply_mode_ui(announce=False) if self._planning_worker: self._planning_worker.deleteLater() self._planning_worker = None def _start_chat(self, request: str, image_paths: list[str] | None = None) -> None: self._chat_request = request self._streamed_text = "" self._planning_bubble = self.add_message("Thinking…", label="ADAM") self._chat_worker = ChatWorker( self.planner, request, list(self._chat_history), image_paths ) self._chat_worker.chunk.connect(self._planning_chunk) self._chat_worker.answered.connect(self._chat_finished) self._chat_worker.failed.connect(self._chat_failed) self._chat_worker.finished.connect(self._chat_worker_finished) self.send_button.setEnabled(False) self.mode_selector.setEnabled(False) self.send_button.setText("Thinking…") self._chat_worker.start() def _chat_finished(self, response: str) -> None: if self._planning_bubble and not self._streamed_text: self._type_into(self._planning_bubble, response) self._chat_history.extend( [ {"role": "user", "content": self._chat_request}, {"role": "assistant", "content": response}, ] ) self._chat_history = self._chat_history[-20:] final_response = self._streamed_text.strip() or response.strip() if final_response: self._conversation_entries.append( {"text": final_response, "user": False, "label": "ADAM"} ) def _chat_failed(self, message: str) -> None: if self._planning_bubble: self._planning_bubble.set_label("ADAM · CHAT UNAVAILABLE") self._planning_bubble.set_text(message) self._conversation_entries.append({"text": message, "user": False, "label": "ADAM · CHAT UNAVAILABLE"}) def _chat_worker_finished(self) -> None: self.send_button.setEnabled(True) self.mode_selector.setEnabled(True) self._apply_mode_ui(announce=False) if self._chat_worker: self._chat_worker.deleteLater() self._chat_worker = None def _mode_changed(self) -> None: self.config.update( {"command_center_mode": str(self.mode_selector.currentData())} ) self._apply_mode_ui(announce=True) def _apply_mode_ui(self, *, announce: bool) -> None: chat_mode = self.mode_selector.currentData() == "chat" self.send_button.setText("Send message →" if chat_mode else "Plan request →") self.prompt.setPlaceholderText( "Ask ADAM anything, or attach an image to discuss…" if chat_mode else "Tell ADAM what you want to accomplish… (Shift+Enter for a new line)" ) self.add_reference_button.setToolTip( "Attach an image for ADAM to describe or caption" if chat_mode else "Attach a reference image for image generation" ) if announce: self.add_message( ( "Chat Mode is active. I can answer questions and discuss your models " "and workflows through Ollama. Clear requests to train, collect, generate, " "or start work are checked by ADAM’s planner and shown as a reviewable plan." if chat_mode else "Trainer Mode is active. I can now build safe plans and run " "registered workflows after the required approval." ), label="ADAM · MODE", ) def _planning_finished(self, plan) -> None: self.refresh_provider_badge() final_response = self._streamed_text.strip() or str(plan.summary).strip() if final_response: self._conversation_entries.append( {"text": final_response, "user": False, "label": "ADAM"} ) if not plan.steps: self._pending_schedule_for = None label = { "Conversation": "ADAM", "DDPM training": "ADAM · NEEDS DETAILS", "Flow Matching training": "ADAM · NEEDS DETAILS", "Safety refusal": "ADAM · SAFETY", }.get(plan.project_name, "ADAM · NO ACTION TAKEN") if self._planning_bubble: self._planning_bubble.set_label(label) if not self._streamed_text: self._type_into(self._planning_bubble, plan.summary) return append_preflight_summary(plan, self.config) scheduled_for = self._pending_schedule_for self._pending_schedule_for = None job = self.jobs.submit(plan, scheduled_for=scheduled_for) self.selected_job = job self.plan_panel.set_job(job) trusted_start = self._can_trusted_start(plan) if trusted_start: self.jobs.confirm(job.id) state = ( "Trusted automation is enabled for this registered dataset-to-DDPM workflow, so it has started." if trusted_start else "Review the plan at right. I’m waiting for your approval." if plan.requires_confirmation else "The plan is scheduled and will start automatically when its time and the training slot are available." if job.status == JobStatus.SCHEDULED else "The plan uses safe, read-only or output-only tools, so it has been queued." ) text = f"{plan.summary}\n\n{len(plan.steps)} registered steps · {state}" if self._planning_bubble: self._planning_bubble.set_label(f"ADAM · PLAN {plan.id.upper()}") self._type_into(self._planning_bubble, text) def _type_into(self, bubble: ChatBubble, text: str) -> None: bubble.set_text("") position = {"value": 0} timer = QTimer(bubble) timer.setInterval(18) def advance() -> None: position["value"] = min(len(text), position["value"] + 8) bubble.set_text(text[: position["value"]]) if position["value"] >= len(text): timer.stop() timer.timeout.connect(advance) timer.start() def _can_trusted_start(self, plan) -> bool: # Trusted dataset-to-DDPM automation is only for ordinary reviewed plans. # ORION warnings deliberately restore the human approval gate. if getattr(plan, "orion_review", {}).get("level") == "warning": return False return bool( plan.requires_confirmation and self.config.get("trusted_dataset_ddpm_automation") and plan.steps and {step.tool_id for step in plan.steps}.issubset({"dataset_collector", "ddpm_trainer"}) ) def refresh_provider_badge(self) -> None: provider = str(self.config.get("provider", "ollama")).upper() if provider == "OLLAMA": self.provider_badge.setText(f"● OLLAMA · {self.config.get('ollama_model')}") else: self.provider_badge.setText("● SAFE PLANNER · MANUAL") def _select_recent_job(self, job_id: str) -> None: try: job = self.jobs.get(job_id) except KeyError: return self.selected_job = job self.plan_panel.set_job(job) def _job_created(self, job: Job) -> None: self.selected_job = job self.plan_panel.set_job(job) if job.status == JobStatus.AWAITING_CONFIRMATION: self.plan_shell.set_collapsed(False, persist=False) def update_snapshot(self, snapshot: SystemSnapshot) -> None: self.latest_snapshot = snapshot self.system_summary.update_snapshot(snapshot) def _job_updated(self, job: Job) -> None: self.recent_panel.refresh() generation_card = self._generation_cards.get(job.id) if generation_card: generation_card.update_job(job) if self.selected_job and job.id == self.selected_job.id: self.selected_job = job self.plan_panel.set_job(job) if self.jobs.active_job and job.id == self.jobs.active_job.id: self.active_panel.set_job(job) terminal = { JobStatus.FINISHED, JobStatus.FAILED, JobStatus.CANCELLED, JobStatus.INTERRUPTED, } marker = (job.id, job.status) if generation_card and job.status in terminal: self._announced.add(marker) return if job.status in terminal and marker not in self._announced: self._announced.add(marker) if job.status == JobStatus.FINISHED: demo_tools = [] real_tools = [] for step in job.plan.steps: try: if self.jobs.executor.registry.get(step.tool_id).demo: demo_tools.append(step.tool_id) else: real_tools.append(step.tool_id) except Exception: pass if demo_tools and real_tools: message = ( f"{job.plan.project_name} completed with a mixture of real and " "demo steps. The real collector output is available in Jobs; " "simulated preparation/training steps did not create a model." ) label = "ADAM · PARTIAL REAL WORKFLOW" elif demo_tools: message = ( f"{job.plan.project_name} demo simulation completed. No real " "images were downloaded and no model was trained. Review the " "generated manifests in Jobs." ) label = "ADAM · DEMO COMPLETE" else: message = ( f"{job.plan.project_name} completed successfully. " "The job record and full logs are available in Jobs." ) label = "ADAM · COMPLETE" recommendation = completion_recommendation(job.plan) if recommendation: message += "\n\n" + recommendation elif job.status == JobStatus.FAILED: message = f"{job.plan.project_name} failed safely: {job.error}" label = "ADAM · ERROR" else: message = f"{job.plan.project_name} was cancelled." label = "ADAM · STOPPED" self.add_message(message, label=label) @staticmethod def open_output(path: str) -> None: output = Path(path) if output.exists(): QDesktopServices.openUrl(QUrl.fromLocalFile(str(output))) class JobsPage(QWidget): def __init__(self, jobs: JobManager) -> None: super().__init__() self.jobs = jobs self.selected_job_id: str | None = None self._refresh_index = 0 self._refresh_token = 0 self._show_full_log = False self._log_job_id: str | None = None root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) root.addWidget( _page_header( "Jobs & history", "Every workflow has durable state, timestamps, logs, progress, and an output location.", ) ) body = QHBoxLayout() body.setSpacing(12) self.table = QTableWidget(0, 6) self.table.setHorizontalHeaderLabels( ["JOB", "PROJECT", "STATUS", "PROGRESS", "CREATED", "OUTPUT"] ) self.table.setAlternatingRowColors(True) self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.setSelectionMode(QAbstractItemView.SingleSelection) self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) self.table.verticalHeader().hide() header = self.table.horizontalHeader() header.setSectionResizeMode(0, QHeaderView.ResizeToContents) header.setSectionResizeMode(1, QHeaderView.Stretch) header.setSectionResizeMode(2, QHeaderView.ResizeToContents) header.setSectionResizeMode(3, QHeaderView.ResizeToContents) header.setSectionResizeMode(4, QHeaderView.ResizeToContents) header.setSectionResizeMode(5, QHeaderView.ResizeToContents) self.table.itemSelectionChanged.connect(self._selection_changed) body.addWidget(self.table, 3) details = _card() details.setMinimumWidth(350) details_layout = QVBoxLayout(details) details_layout.setContentsMargins(17, 16, 17, 16) self.detail_title = QLabel("Select a job") self.detail_title.setStyleSheet("font-size: 17px; font-weight: 650;") self.detail_status = QLabel("No job selected") self.detail_status.setProperty("muted", True) self.agent_status = QLabel("ORION, ATLAS, and NOVA reports will appear here.") self.agent_status.setWordWrap(True) self.agent_status.setProperty("muted", True) self.agent_status.setStyleSheet("font-size: 10px;") self.log_view = QPlainTextEdit() self.log_view.setReadOnly(True) self.log_view.setPlaceholderText("Job logs will appear here.") details_layout.addWidget(_card_title("JOB DETAILS")) details_layout.addWidget(self.detail_title) details_layout.addWidget(self.detail_status) details_layout.addWidget(self.agent_status) details_layout.addWidget(self.log_view, 1) # Two rows keep every action available when the Jobs panel is narrow. actions = QGridLayout() actions.setHorizontalSpacing(7) actions.setVerticalSpacing(7) self.pause_button = QPushButton("Pause") self.adjust_button = QPushButton("Adjust after epoch") self.stop_button = QPushButton("Stop") self.stop_button.setProperty("danger", True) self.end_task_button = QPushButton("End task") self.end_task_button.setProperty("danger", True) self.output_button = QPushButton("Open output") self.retry_button = QPushButton("Retry plan") self.approve_button = QPushButton("Approve & run") self.approve_button.setProperty("primary", True) self.approve_button.setToolTip("Approve this waiting plan and start it when its place in the queue is reached.") self.approve_button.setVisible(False) self.export_button = QPushButton("Export log") self.full_log_button = QPushButton("Show full log") self.export_all_button = QPushButton("Export all") self.clear_terminal_button = QPushButton("Remove completed / failed") self.clear_terminal_button.setProperty("danger", True) actions.addWidget(self.pause_button, 0, 0) actions.addWidget(self.adjust_button, 0, 1) actions.addWidget(self.stop_button, 0, 2) actions.addWidget(self.end_task_button, 0, 3) actions.addWidget(self.retry_button, 0, 4) actions.addWidget(self.export_button, 1, 0) actions.addWidget(self.full_log_button, 1, 1) actions.addWidget(self.export_all_button, 1, 2) actions.addWidget(self.clear_terminal_button, 1, 3) actions.addWidget(self.output_button, 1, 4) actions.addWidget(self.approve_button, 2, 0, 1, 5) details_layout.addLayout(actions) body.addWidget(details, 2) root.addLayout(body, 1) self.pause_button.clicked.connect(self._pause_or_resume) self.adjust_button.clicked.connect(self._adjust_after_epoch) self.stop_button.clicked.connect(self._stop) self.end_task_button.clicked.connect(self._end_task) self.output_button.clicked.connect(self._open_output) self.retry_button.clicked.connect(self._retry) self.approve_button.clicked.connect(self._approve) self.export_button.clicked.connect(self._export_log) self.full_log_button.clicked.connect(self._show_entire_log) self.export_all_button.clicked.connect(self._export_all) self.clear_terminal_button.clicked.connect(self._remove_completed_or_failed) self.jobs.job_created.connect(lambda _job: self.refresh()) self.jobs.job_updated.connect(self._on_job_updated) self.refresh() def refresh(self) -> None: self._refresh_token += 1 token = self._refresh_token self._refresh_index = 0 # Do not suppress painting while history rows stream in. Large histories # used to leave an apparently blank, but clickable, table until its final # row had been populated. self.table.setRowCount(len(self.jobs.jobs)) QTimer.singleShot(0, lambda: self._refresh_next_row(token)) def _refresh_next_row(self, token: int) -> None: """Populate one history row per event-loop turn to avoid a tab-switch hitch.""" if token != self._refresh_token: return if self._refresh_index >= len(self.jobs.jobs): if not self.selected_job_id and self.jobs.jobs: self.table.selectRow(0) return row = self._refresh_index job = self.jobs.jobs[row] selected = self.selected_job_id try: self._populate_job_row(row, job) if selected and job.id == selected: self.table.selectRow(row) finally: self._refresh_index += 1 QTimer.singleShot(0, lambda: self._refresh_next_row(token)) def _populate_job_row(self, row: int, job: Job) -> None: demo_steps = sum( self._tool_is_demo(step.tool_id) for step in job.plan.steps ) is_demo = demo_steps == len(job.plan.steps) and demo_steps > 0 is_mixed = 0 < demo_steps < len(job.plan.steps) display_status = job.status.value if job.status == JobStatus.FINISHED and is_demo: display_status = "Finished · demo" elif job.status == JobStatus.FINISHED and is_mixed: display_status = "Finished · mixed" values = [ job.id, job.plan.project_name, display_status, f"{job.progress}%", self._format_time(job.created_at), "Ready" if job.output_folder else "—", ] for column, value in enumerate(values): item = QTableWidgetItem(value) if column in (0, 2, 3, 4, 5): item.setTextAlignment(Qt.AlignCenter) self.table.setItem(row, column, item) def _selection_changed(self) -> None: rows = self.table.selectionModel().selectedRows() if not rows: return job_id = self.table.item(rows[0].row(), 0).text() if job_id != self._log_job_id: self._show_full_log = False self.selected_job_id = job_id self._show_job(self.jobs.get(job_id)) def _show_job(self, job: Job) -> None: self.detail_title.setText(job.plan.project_name) step = "" if 0 <= job.current_step < len(job.plan.steps): step = f" · {job.plan.steps[job.current_step].title}" self.detail_status.setText( f"{job.status.value} · {job.progress}% · {len(job.plan.steps)} steps{step}" + ( f" · starts {self._format_time(job.scheduled_for)}" if job.status == JobStatus.SCHEDULED and job.scheduled_for else "" ) ) reports = [] if job.plan.orion_review: reports.append(f"ORION · {job.plan.orion_review.get('headline', 'Reviewed')}") if job.atlas_report: reports.append(f"ATLAS · {job.atlas_report.get('severity', 'watching').upper()} — {job.atlas_report.get('message', '')}") latest_nova = job.nova_report.get("latest", {}) if latest_nova: reports.append(f"NOVA · {latest_nova.get('status', 'Reviewed')} — {latest_nova.get('summary', '')}") self.agent_status.setText("\n".join(reports) or "No agent reports are available for this job yet.") self._log_job_id = job.id visible_logs = job.logs if len(job.logs) > 300 and not self._show_full_log: visible_logs = [ f"Showing the newest 300 of {len(job.logs)} lines. " "Use “Show full log” to load the rest.", "", *job.logs[-300:], ] self.log_view.setPlainText("\n".join(visible_logs)) self.log_view.verticalScrollBar().setValue( self.log_view.verticalScrollBar().maximum() ) running = job.status in {JobStatus.RUNNING, JobStatus.PAUSED} self.pause_button.setEnabled(running) active_ddpm = ( running and 0 <= job.current_step < len(job.plan.steps) and job.plan.steps[job.current_step].tool_id == "ddpm_trainer" ) self.adjust_button.setEnabled(active_ddpm) self.pause_button.setText("Resume" if job.status == JobStatus.PAUSED else "Pause") self.stop_button.setEnabled( running or job.status in { JobStatus.SCHEDULED, JobStatus.QUEUED, JobStatus.AWAITING_CONFIRMATION, } ) self.end_task_button.setEnabled(job.status == JobStatus.INTERRUPTED) self.output_button.setEnabled(bool(job.output_folder)) awaiting_confirmation = job.status == JobStatus.AWAITING_CONFIRMATION vram_failure = job.status == JobStatus.FAILED and self.jobs._looks_like_vram_failure(job) self.retry_button.setText( "Retry with safer batch" if vram_failure else "Retry plan" ) self.retry_button.setEnabled( job.status in { JobStatus.FINISHED, JobStatus.FAILED, JobStatus.CANCELLED, JobStatus.INTERRUPTED, } ) self.approve_button.setVisible(awaiting_confirmation) self.approve_button.setEnabled(awaiting_confirmation) self.export_button.setEnabled(bool(job.logs)) self.full_log_button.setVisible(len(job.logs) > 300) self.full_log_button.setEnabled(len(job.logs) > 300 and not self._show_full_log) def _show_entire_log(self) -> None: job = self._selected() if not job: return self._show_full_log = True self._show_job(job) def _on_job_updated(self, job: Job) -> None: row = next( ( row for row in range(self.table.rowCount()) if self.table.item(row, 0) and self.table.item(row, 0).text() == job.id ), -1, ) if row >= 0: self._populate_job_row(row, job) else: self.refresh() if job.id == self.selected_job_id: self._show_job(job) def _selected(self) -> Job | None: if not self.selected_job_id: return None try: return self.jobs.get(self.selected_job_id) except KeyError: return None def _pause_or_resume(self) -> None: job = self._selected() if not job: return if job.status == JobStatus.PAUSED: self.jobs.resume(job.id) else: self.jobs.pause(job.id) def _adjust_after_epoch(self) -> None: job = self._selected() if not job or not (0 <= job.current_step < len(job.plan.steps)): return arguments = job.plan.steps[job.current_step].arguments dialog = QDialog(self) dialog.setWindowTitle("Adjust training after this epoch") dialog.setMinimumWidth(440) layout = QVBoxLayout(dialog) explanation = QLabel( "Training will finish the current epoch, save a complete checkpoint, " "release VRAM, and resume with these settings." ) explanation.setWordWrap(True) layout.addWidget(explanation) grid = QGridLayout() batch = QSpinBox(); batch.setRange(1, 64); batch.setValue(int(arguments.get("batch_size", 1))) accumulation = QSpinBox(); accumulation.setRange(1, 64); accumulation.setValue(int(arguments.get("gradient_accumulation_steps", 1))) intensity = QSpinBox(); intensity.setRange(10, 100); intensity.setValue(int(arguments.get("training_intensity", 100))); intensity.setSuffix("%") grid.addWidget(QLabel("Batch size"), 0, 0); grid.addWidget(batch, 0, 1) grid.addWidget(QLabel("Gradient accumulation"), 1, 0); grid.addWidget(accumulation, 1, 1) grid.addWidget(QLabel("Training intensity"), 2, 0); grid.addWidget(intensity, 2, 1) layout.addLayout(grid) note = QLabel("Tip: when lowering batch size, increase gradient accumulation to preserve a similar effective batch.") note.setWordWrap(True) note.setProperty("muted", True) layout.addWidget(note) buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) buttons.button(QDialogButtonBox.Ok).setText("Apply after epoch") buttons.accepted.connect(dialog.accept) buttons.rejected.connect(dialog.reject) layout.addWidget(buttons) if dialog.exec() != QDialog.Accepted: return try: self.jobs.request_training_adjustment(job.id, { "batch_size": batch.value(), "gradient_accumulation_steps": accumulation.value(), "training_intensity": intensity.value(), }) except ValueError as exc: QMessageBox.information(self, "Settings not queued", str(exc)) def _stop(self) -> None: job = self._selected() if job: self.jobs.cancel(job.id) def _end_task(self) -> None: job = self._selected() if not job: return self.jobs.end_task(job.id) def _open_output(self) -> None: job = self._selected() if job and job.output_folder: QDesktopServices.openUrl(QUrl.fromLocalFile(job.output_folder)) def _retry(self) -> None: job = self._selected() if not job: return try: retried = ( self.jobs.safer_vram_retry(job.id) if job.status == JobStatus.FAILED and self.jobs._looks_like_vram_failure(job) else self.jobs.retry(job.id) ) except ValueError as exc: QMessageBox.information(self, "Retry not created", str(exc)) return self.selected_job_id = retried.id self.refresh() def _approve(self) -> None: job = self._selected() if job and job.status == JobStatus.AWAITING_CONFIRMATION: self.jobs.confirm(job.id) def _export_log(self) -> None: job = self._selected() if not job: return selected, _filter = QFileDialog.getSaveFileName( self, "Export job log", str(self.jobs.root / "logs" / f"job_{job.id}.txt"), "Text files (*.txt)", ) if not selected: return try: Path(selected).write_text( f"ADAM job {job.id}\n{job.plan.project_name}\n" f"{job.status.value}\n\n" + "\n".join(job.logs), encoding="utf-8", ) except OSError as exc: QMessageBox.warning(self, "Log not exported", str(exc)) def _export_all(self) -> None: selected, _filter = QFileDialog.getSaveFileName( self, "Export job history", str(self.jobs.root / "logs" / "job_history.json"), "JSON files (*.json)", ) if not selected: return try: Path(selected).write_text( json.dumps({"jobs": [job.to_dict() for job in self.jobs.jobs]}, indent=2), encoding="utf-8", ) except OSError as exc: QMessageBox.warning(self, "History not exported", str(exc)) def _remove_completed_or_failed(self) -> None: count = sum( job.status in {JobStatus.FINISHED, JobStatus.FAILED} for job in self.jobs.jobs ) if not count: QMessageBox.information( self, "Nothing to remove", "There are no completed or failed jobs in history." ) return answer = QMessageBox.question( self, "Remove completed / failed jobs", f"Remove {count} completed or failed job record(s)? This does not delete output files.", QMessageBox.Yes | QMessageBox.No, QMessageBox.No, ) if answer != QMessageBox.Yes: return self.jobs.remove_completed_or_failed() self.selected_job_id = None self.log_view.clear() self.detail_title.setText("Select a job") self.detail_status.setText("No job selected") self.refresh() @staticmethod def _format_time(value: str) -> str: try: return datetime.fromisoformat(value).astimezone().strftime("%b %d · %H:%M") except ValueError: return value[:16] def _tool_is_demo(self, tool_id: str) -> bool: try: return self.jobs.executor.registry.get(tool_id).demo except Exception: return False class ModelInspectionWorker(QThread): progress_changed = Signal(int, str) inspection_ready = Signal(object) failed = Signal(str) def __init__(self, path: str, architecture: str = "", settings: dict | None = None) -> None: super().__init__() self.path = path self.architecture = architecture self.settings = settings or {} self._cancelled = False def cancel(self) -> None: self._cancelled = True def run(self) -> None: try: summary = inspect_model( self.path, recorded_architecture=self.architecture, run_settings=self.settings, progress=self.progress_changed.emit, cancelled=lambda: self._cancelled, ) except Exception as exc: self.failed.emit(str(exc)) return self.inspection_ready.emit(summary) class ModelComparisonWorker(QThread): progress_changed = Signal(int, str) comparison_ready = Signal(object) failed = Signal(str) def __init__(self, path_a: str, path_b: str, run_a: ExperimentRun | None = None, run_b: ExperimentRun | None = None) -> None: super().__init__() self.path_a = path_a self.path_b = path_b self.run_a = run_a self.run_b = run_b self._cancelled = False def cancel(self) -> None: self._cancelled = True def run(self) -> None: try: comparison = compare_models( self.path_a, self.path_b, arch_a=self.run_a.model_architecture if self.run_a else "", arch_b=self.run_b.model_architecture if self.run_b else "", settings_a=self.run_a.settings if self.run_a else {}, settings_b=self.run_b.settings if self.run_b else {}, progress=self.progress_changed.emit, cancelled=lambda: self._cancelled, ) except Exception as exc: self.failed.emit(str(exc)) return self.comparison_ready.emit(comparison) class ModelInspectorPlot(QWidget): def __init__(self) -> None: super().__init__() self.layout = QVBoxLayout(self) self.layout.setContentsMargins(8, 8, 8, 8) self.placeholder = QLabel("Inspect a model to see parameter and weight-distribution charts.") self.placeholder.setProperty("muted", True) self.placeholder.setAlignment(Qt.AlignCenter) self.layout.addWidget(self.placeholder, 1) self.canvas = None self.figure = None try: from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg from matplotlib.figure import Figure self.figure = Figure(figsize=(9, 4.5), facecolor=COLORS["surface"]) self.canvas = FigureCanvasQTAgg(self.figure) self.layout.addWidget(self.canvas, 1) self.canvas.hide() except Exception: self.placeholder.setText("Charts are unavailable because matplotlib could not initialize.") def plot(self, summary: ModelInspection | None) -> None: if self.canvas is None or self.figure is None or summary is None: return self.placeholder.hide() self.canvas.show() self.figure.clear() axes = self.figure.subplots(1, 3) for axis in axes: axis.set_facecolor(COLORS["surface"]) axis.tick_params(colors=COLORS["muted"], labelsize=8) for spine in axis.spines.values(): spine.set_color(COLORS["border"]) components = sorted(summary.components.items(), key=lambda item: item[1], reverse=True)[:10] axes[0].set_title("Component Parameters", color=COLORS["text"], fontsize=10) if components: labels = [name[:18] for name, _ in components] values = [count / 1_000_000 for _, count in components] axes[0].barh(labels[::-1], values[::-1], color=COLORS["blue"]) axes[0].set_xlabel("Millions", color=COLORS["muted"], fontsize=8) sizes = summary.tensor_size_distribution[:20] axes[1].set_title("Largest Tensors", color=COLORS["text"], fontsize=10) if sizes: labels = [Path(name).name[:16] for name, _ in sizes[:10]] values = [count / 1_000_000 for _, count in sizes[:10]] axes[1].bar(range(len(values)), values, color=COLORS["purple"]) axes[1].set_xticks(range(len(labels))) axes[1].set_xticklabels(labels, rotation=70, ha="right") axes[1].set_ylabel("Millions", color=COLORS["muted"], fontsize=8) axes[2].set_title("Abs Mean Distribution", color=COLORS["text"], fontsize=10) bins = summary.histogram.get("abs_mean_bins", []) counts = summary.histogram.get("counts", []) if len(bins) > 1 and counts: axes[2].bar(range(len(counts)), counts, color=COLORS["green"]) axes[2].set_xticks([0, len(counts) - 1]) axes[2].set_xticklabels([f"{bins[0]:.2g}", f"{bins[-1]:.2g}"]) axes[2].set_ylabel("Tensors", color=COLORS["muted"], fontsize=8) self.figure.tight_layout() self.canvas.draw_idle() class ExperimentTrackerPage(QWidget): clone_requested = Signal(str) def __init__(self, store: ExperimentStore) -> None: super().__init__() self.store = store self.selected_run_id = "" self.current_inspection: ModelInspection | None = None self.current_model_path = "" self.inspection_cache: dict[tuple[str, float, int], ModelInspection] = {} self.inspection_worker: ModelInspectionWorker | None = None self.comparison_worker: ModelComparisonWorker | None = None root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) header = QHBoxLayout() header.addWidget( _page_header( "Experiment tracker", "Search, score, clone, and compare local training runs recorded from ADAM jobs.", ), 1, ) refresh = QPushButton("Refresh") refresh.clicked.connect(self.refresh) header.addWidget(refresh, 0, Qt.AlignTop) root.addLayout(header) filters = QHBoxLayout() self.search = QLineEdit() self.search.setPlaceholderText("Search runs, datasets, or notes") self.architecture = QComboBox() self.architecture.addItem("All architectures", "") self.dataset = QLineEdit() self.dataset.setPlaceholderText("Dataset filter") filters.addWidget(self.search, 2) filters.addWidget(self.architecture) filters.addWidget(self.dataset, 1) root.addLayout(filters) body = QHBoxLayout() self.table = QTableWidget(0, 8) self.table.setHorizontalHeaderLabels( ["RUN", "MODEL", "ARCH", "DATASET", "EPOCHS", "LOSS", "TIME", "QUALITY"] ) self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.setSelectionMode(QAbstractItemView.MultiSelection) self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) self.table.setSortingEnabled(True) self.table.verticalHeader().hide() header_view = self.table.horizontalHeader() header_view.setSectionResizeMode(0, QHeaderView.ResizeToContents) header_view.setSectionResizeMode(1, QHeaderView.Stretch) header_view.setSectionResizeMode(2, QHeaderView.ResizeToContents) header_view.setSectionResizeMode(3, QHeaderView.Stretch) for column in range(4, 8): header_view.setSectionResizeMode(column, QHeaderView.ResizeToContents) body.addWidget(self.table, 3) details = _card() details.setMinimumWidth(390) details_layout = QVBoxLayout(details) details_layout.setContentsMargins(17, 16, 17, 16) details_layout.setSpacing(8) details_layout.addWidget(_card_title("RUN DETAILS")) self.detail_title = QLabel("Select a run") self.detail_title.setStyleSheet("font-size: 17px; font-weight: 650;") self.detail = QLabel("Recorded training settings will appear here.") self.detail.setWordWrap(True) self.detail.setProperty("muted", True) self.notes = QPlainTextEdit() self.notes.setPlaceholderText("Notes") self.notes.setMaximumHeight(110) rating_row = QHBoxLayout() rating_row.addWidget(QLabel("Quality")) self.quality = QSpinBox() self.quality.setRange(0, 100) self.quality.setSuffix(" / 100") rating_row.addWidget(self.quality) rating_row.addStretch() actions = QGridLayout() self.save_button = QPushButton("Save notes") self.clone_button = QPushButton("Clone settings") self.compare_button = QPushButton("Compare selected") self.output_button = QPushButton("Open output") self.inspect_button = QPushButton("Inspect model") self.manual_inspect_button = QPushButton("Choose checkpoint") self.cancel_inspect_button = QPushButton("Cancel scan") self.cancel_inspect_button.setEnabled(False) actions.addWidget(self.save_button, 0, 0) actions.addWidget(self.clone_button, 0, 1) actions.addWidget(self.compare_button, 1, 0) actions.addWidget(self.output_button, 1, 1) actions.addWidget(self.inspect_button, 2, 0) actions.addWidget(self.manual_inspect_button, 2, 1) actions.addWidget(self.cancel_inspect_button, 3, 0, 1, 2) self.inspect_status = QLabel("No model inspected yet.") self.inspect_status.setProperty("muted", True) self.inspect_status.setWordWrap(True) self.inspect_progress = QProgressBar() self.inspect_progress.setRange(0, 100) self.inspect_progress.setValue(0) details_layout.addWidget(self.detail_title) details_layout.addWidget(self.detail) details_layout.addLayout(rating_row) details_layout.addWidget(self.notes) details_layout.addLayout(actions) details_layout.addWidget(self.inspect_status) details_layout.addWidget(self.inspect_progress) details_layout.addStretch(1) body.addWidget(details, 2) root.addLayout(body, 3) self.analysis_tabs = QTabWidget() self.overview_view = QPlainTextEdit() self.overview_view.setReadOnly(True) self.overview_view.setPlaceholderText("Inspect a model to see architecture, parameters, configs, and major components.") weights_page = QWidget() weights_layout = QVBoxLayout(weights_page) weights_layout.setContentsMargins(10, 10, 10, 10) self.weight_search = QLineEdit() self.weight_search.setPlaceholderText("Search tensor names") self.weights_table = QTableWidget(0, 11) self.weights_table.setHorizontalHeaderLabels( ["TENSOR", "SHAPE", "DTYPE", "PARAMS", "MIN", "MAX", "MEAN", "STD", "ABS MEAN", "L2", "ZEROS"] ) self.weights_table.setSelectionBehavior(QAbstractItemView.SelectRows) self.weights_table.setEditTriggers(QAbstractItemView.NoEditTriggers) weights_header = self.weights_table.horizontalHeader() weights_header.setSectionResizeMode(0, QHeaderView.Stretch) for column in range(1, 11): weights_header.setSectionResizeMode(column, QHeaderView.ResizeToContents) weights_layout.addWidget(self.weight_search) weights_layout.addWidget(self.weights_table, 1) self.health_view = QPlainTextEdit() self.health_view.setReadOnly(True) self.plot_widget = ModelInspectorPlot() self.compare_view = QPlainTextEdit() self.compare_view.setReadOnly(True) self.compare_view.setPlaceholderText("Select 2 runs and choose Compare selected.") self.timeline_view = QPlainTextEdit() self.timeline_view.setReadOnly(True) self.timeline_view.setPlaceholderText("Checkpoint timeline appears when an inspected output has multiple checkpoints.") self.analysis_tabs.addTab(self.overview_view, "Overview") self.analysis_tabs.addTab(weights_page, "Weights") self.analysis_tabs.addTab(self.health_view, "Health") self.analysis_tabs.addTab(self.plot_widget, "Plots") self.analysis_tabs.addTab(self.compare_view, "Compare") self.analysis_tabs.addTab(self.timeline_view, "Timeline") root.addWidget(self.analysis_tabs, 2) self.search.textChanged.connect(self.refresh) self.architecture.currentIndexChanged.connect(self.refresh) self.dataset.textChanged.connect(self.refresh) self.table.itemSelectionChanged.connect(self._selection_changed) self.save_button.clicked.connect(self._save_notes) self.clone_button.clicked.connect(self._clone) self.compare_button.clicked.connect(self._compare) self.output_button.clicked.connect(self._open_output) self.inspect_button.clicked.connect(self._inspect_selected) self.manual_inspect_button.clicked.connect(self._inspect_manual) self.cancel_inspect_button.clicked.connect(self._cancel_inspection) self.weight_search.textChanged.connect(self._populate_weights) self.refresh() def refresh(self) -> None: current = self.selected_run_id runs = self.store.list_runs( self.search.text().strip(), str(self.architecture.currentData() or ""), self.dataset.text().strip(), ) known = sorted({run.model_architecture for run in self.store.list_runs(limit=1000) if run.model_architecture}) self.architecture.blockSignals(True) selected_arch = str(self.architecture.currentData() or "") self.architecture.clear() self.architecture.addItem("All architectures", "") for architecture in known: self.architecture.addItem(architecture.upper(), architecture) index = self.architecture.findData(selected_arch) self.architecture.setCurrentIndex(max(0, index)) self.architecture.blockSignals(False) self.table.setRowCount(len(runs)) self.table.setSortingEnabled(False) for row, run in enumerate(runs): values = [ run.id, run.model_name, run.model_architecture.upper(), run.dataset_name or Path(run.dataset_path).name, str(run.epochs), "—" if run.final_loss is None else f"{run.final_loss:.5f}", self._duration(run.training_time_seconds), "—" if run.quality_score is None else str(run.quality_score), ] for column, value in enumerate(values): item = QTableWidgetItem(value) item.setData(Qt.UserRole, run.id) if column in {0, 2, 4, 5, 6, 7}: item.setTextAlignment(Qt.AlignCenter) self.table.setItem(row, column, item) self.table.setSortingEnabled(True) if not runs: self.detail_title.setText("No experiments recorded") self.detail.setText("Training runs are recorded here when a registered trainer finishes, fails, or is cancelled.") self.notes.clear() self.compare_view.clear() self.inspect_button.setEnabled(False) self.output_button.setEnabled(False) if current: for row in range(self.table.rowCount()): if self.table.item(row, 0).text() == current: self.table.selectRow(row) break def _selection_changed(self) -> None: run = self._selected_run() if not run: return self.selected_run_id = run.id self.detail_title.setText(run.model_name) details = [ f"{run.model_architecture.upper()} · {run.status}", f"Epochs {run.epochs:,} · Batch {run.batch_size or '—'} · LR {run.learning_rate or '—'}", f"Resolution {run.resolution or '—'} · Loss {'—' if run.final_loss is None else f'{run.final_loss:.5f}'}", f"Dataset: {run.dataset_path or '—'}", f"Output: {run.output_folder or '—'}", ] if run.peak_vram_gb: details.append(f"VRAM at record time: {run.peak_vram_gb:.1f} GB") if run.preview_images: details.append(f"Previews recorded: {len(run.preview_images)}") self.detail.setText("\n".join(details)) self.notes.setPlainText(run.notes) self.quality.setValue(int(run.quality_score or 0)) model_path = self._default_model_path(run) self.output_button.setEnabled(bool(run.output_folder and Path(run.output_folder).exists())) self.inspect_button.setEnabled(bool(model_path)) if model_path: self.inspect_status.setText(f"Ready to inspect: {model_path}") def _selected_ids(self) -> list[str]: ids = [] for index in self.table.selectionModel().selectedRows(): item = self.table.item(index.row(), 0) if item: ids.append(item.text()) return ids def _selected_run(self) -> ExperimentRun | None: ids = self._selected_ids() return self.store.get(ids[0]) if ids else None def _save_notes(self) -> None: if not self.selected_run_id: return quality = self.quality.value() self.store.update_notes(self.selected_run_id, self.notes.toPlainText().strip(), quality if quality else None) self.refresh() def _clone(self) -> None: run = self._selected_run() if run: self.clone_requested.emit(self.store.clone_request(run.id)) def _compare(self) -> None: ids = self._selected_ids() if len(ids) < 2: self.compare_view.setPlainText("Select at least two experiment runs.") return runs = [self.store.get(run_id) for run_id in ids[:2]] paths = [self._default_model_path(run) if run else "" for run in runs] if len(paths) == 2 and paths[0] and paths[1]: self._start_comparison(paths[0], paths[1], runs[0], runs[1]) return rows = self.store.compare(ids) lines = ["Compare selected runs", "Run IDs: " + ", ".join(ids), ""] for row in rows: field = str(row.get("field", "")).replace("_", " ").title() marker = "Changed" if row.get("changed") else "Same" values = " | ".join(self._format_compare_value(field, row.get(run_id, "—")) for run_id in ids) lines.append(f"{marker:7} {field}: {values}") self.compare_view.setPlainText("\n".join(lines)) def _open_output(self) -> None: run = self._selected_run() if run and run.output_folder and Path(run.output_folder).exists(): QDesktopServices.openUrl(QUrl.fromLocalFile(run.output_folder)) def _default_model_path(self, run: ExperimentRun) -> str: candidates = [path for path in run.checkpoint_paths if path] candidates.append(run.output_folder) if run.model_architecture == "flow" and run.output_folder: candidates.insert(0, run.output_folder) for value in reversed(candidates): path = Path(value).expanduser() if path.exists(): return str(path) return "" def _cache_key(self, path: str) -> tuple[str, float, int] | None: target = Path(path).expanduser() if not target.exists(): return None try: if target.is_file(): stat = target.stat() return (str(target.resolve()), stat.st_mtime, stat.st_size) latest = 0.0 size = 0 for item in target.rglob("*"): if item.is_file(): stat = item.stat() latest = max(latest, stat.st_mtime) size += stat.st_size return (str(target.resolve()), latest, size) except OSError: return None def _inspect_selected(self) -> None: run = self._selected_run() if not run: self.inspect_status.setText("Select a run first.") return path = self._default_model_path(run) if not path: self.inspect_status.setText("No checkpoint or output folder was found for this run.") return self._start_inspection(path, run) def _inspect_manual(self) -> None: file_path, _ = QFileDialog.getOpenFileName( self, "Choose checkpoint", str(Path.cwd()), "Model checkpoints (*.safetensors *.pt *.pth *.bin *.ckpt);;All files (*)", ) selected = file_path if not selected: selected = QFileDialog.getExistingDirectory(self, "Choose model folder", str(Path.cwd())) if selected: self._start_inspection(selected, self._selected_run()) def _start_inspection(self, path: str, run: ExperimentRun | None = None) -> None: if self.inspection_worker and self.inspection_worker.isRunning(): self.inspect_status.setText("A model scan is already running.") return key = self._cache_key(path) if key and key in self.inspection_cache: self._show_inspection(self.inspection_cache[key]) self.inspect_status.setText(f"Loaded cached inspection: {Path(path).name}") return self.current_model_path = path self.inspect_progress.setValue(0) self.inspect_status.setText(f"Inspecting model: {path}") self.cancel_inspect_button.setEnabled(True) self.inspect_button.setEnabled(False) self.manual_inspect_button.setEnabled(False) self.inspection_worker = ModelInspectionWorker( path, run.model_architecture if run else "", run.settings if run else {}, ) self.inspection_worker.progress_changed.connect(self._inspection_progress) self.inspection_worker.inspection_ready.connect(lambda summary, cache_key=key: self._inspection_finished(summary, cache_key)) self.inspection_worker.failed.connect(self._inspection_failed) self.inspection_worker.finished.connect(self._inspection_worker_done) self.inspection_worker.start() def _cancel_inspection(self) -> None: if self.inspection_worker and self.inspection_worker.isRunning(): self.inspection_worker.cancel() self.inspect_status.setText("Cancelling model scan...") if self.comparison_worker and self.comparison_worker.isRunning(): self.comparison_worker.cancel() self.inspect_status.setText("Cancelling comparison...") def _inspection_progress(self, value: int, message: str) -> None: self.inspect_progress.setValue(value) self.inspect_status.setText(message) def _inspection_finished(self, summary: ModelInspection, cache_key: tuple[str, float, int] | None) -> None: if cache_key: self.inspection_cache[cache_key] = summary self._show_inspection(summary) self.inspect_status.setText(summary.messages[0] if summary.messages else "Inspection complete.") self.inspect_progress.setValue(100) def _inspection_failed(self, message: str) -> None: self.inspect_status.setText(message or "Model inspection failed.") self.health_view.setPlainText(message or "Model inspection failed.") def _inspection_worker_done(self) -> None: self.cancel_inspect_button.setEnabled(False) self.inspect_button.setEnabled(True) self.manual_inspect_button.setEnabled(True) def _show_inspection(self, summary: ModelInspection) -> None: self.current_inspection = summary self.overview_view.setPlainText(self._format_overview(summary)) self.health_view.setPlainText("\n".join(summary.health)) self._populate_weights() self.plot_widget.plot(summary) self.timeline_view.setPlainText(self._format_timeline(summary)) self.analysis_tabs.setCurrentWidget(self.overview_view) def _populate_weights(self) -> None: summary = self.current_inspection query = self.weight_search.text().strip().casefold() tensors = summary.tensors if summary else [] if query: tensors = [tensor for tensor in tensors if query in tensor.name.casefold()] tensors = sorted(tensors, key=lambda item: item.parameter_count, reverse=True)[:1000] self.weights_table.setRowCount(len(tensors)) for row, tensor in enumerate(tensors): values = [ tensor.name, shape_label(tensor.shape), tensor.dtype, f"{tensor.parameter_count:,}", self._metric(tensor.minimum), self._metric(tensor.maximum), self._metric(tensor.mean), self._metric(tensor.std), self._metric(tensor.abs_mean), self._metric(tensor.l2_norm), "-" if tensor.zero_percent is None else f"{tensor.zero_percent:.2f}%", ] for column, value in enumerate(values): item = QTableWidgetItem(value) if column > 0: item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) self.weights_table.setItem(row, column, item) def _format_overview(self, summary: ModelInspection) -> str: lines = [ f"Detected architecture: {summary.architecture} ({summary.confidence:.0%} confidence)", f"Model/checkpoint path: {summary.resolved_path}", f"Checkpoint size: {bytes_label(summary.size_bytes)}", f"Configuration files found: {len(summary.config_files)}", f"Resolution: {summary.resolution or '-'}", f"Epoch: {summary.epoch or '-'}", f"Step: {summary.step or '-'}", f"Number of tensors: {summary.tensor_count:,}", f"Total parameter count: {summary.total_parameters:,}", f"Trainable parameter count: {'-' if summary.trainable_parameters is None else f'{summary.trainable_parameters:,}'}", f"Parameter memory size: {bytes_label(summary.parameter_memory_bytes)}", "", "Tensor data types:", ] lines.extend(f" {dtype}: {count:,} parameters" for dtype, count in sorted(summary.dtypes.items())) lines.extend(["", "Major model components:"]) lines.extend(f" {name}: {count:,} parameters" for name, count in sorted(summary.components.items(), key=lambda item: item[1], reverse=True)[:20]) lines.extend(["", "Largest tensors/layers:"]) lines.extend(f" {tensor.name} {shape_label(tensor.shape)} {tensor.parameter_count:,}" for tensor in summary.largest_tensors[:15]) if summary.config_files: lines.extend(["", "Configuration files:"]) lines.extend(f" {path}" for path in summary.config_files[:20]) if summary.lora: lines.extend(["", "LoRA adapter details:"]) lines.extend(f" {key.replace('_', ' ').title()}: {value}" for key, value in summary.lora.items()) lines.append(" Tensor norms are adapter statistics; they do not directly tell visual strength.") if summary.messages: lines.extend(["", "Messages:"]) lines.extend(f" {message}" for message in summary.messages) return "\n".join(lines) def _format_timeline(self, summary: ModelInspection) -> str: if not summary.checkpoints: return "No timeline checkpoints were found near this model output." lines = [ "Checkpoint timeline", "Select several checkpoints with Compare selected runs, or inspect individual checkpoints from this list.", "", ] for path in summary.checkpoints[:80]: item = Path(path) try: size = bytes_label(sum(file.stat().st_size for file in item.rglob("*") if file.is_file()) if item.is_dir() else item.stat().st_size) except OSError: size = "-" lines.append(f"{item.name} | {size} | {path}") if len(summary.checkpoints) > 80: lines.append(f"... {len(summary.checkpoints) - 80} more checkpoints omitted.") return "\n".join(lines) def _start_comparison(self, path_a: str, path_b: str, run_a: ExperimentRun | None, run_b: ExperimentRun | None) -> None: if self.comparison_worker and self.comparison_worker.isRunning(): self.compare_view.setPlainText("A model comparison is already running.") return self.compare_view.setPlainText("Comparing checkpoints...") self.analysis_tabs.setCurrentWidget(self.compare_view) self.cancel_inspect_button.setEnabled(True) self.comparison_worker = ModelComparisonWorker(path_a, path_b, run_a, run_b) self.comparison_worker.progress_changed.connect(self._inspection_progress) self.comparison_worker.comparison_ready.connect(self._comparison_finished) self.comparison_worker.failed.connect(self._comparison_failed) self.comparison_worker.finished.connect(self._comparison_worker_done) self.comparison_worker.start() def _comparison_finished(self, comparison: ModelComparison) -> None: self.compare_view.setPlainText(self._format_model_comparison(comparison)) self.inspect_progress.setValue(100) self.inspect_status.setText("Model comparison complete.") def _comparison_failed(self, message: str) -> None: self.compare_view.setPlainText(message or "Model comparison failed.") self.inspect_status.setText(message or "Model comparison failed.") def _comparison_worker_done(self) -> None: self.cancel_inspect_button.setEnabled(False) def _format_model_comparison(self, comparison: ModelComparison) -> str: lines = [ "Compare checkpoints", f"A: {comparison.path_a}", f"B: {comparison.path_b}", f"Architecture: {comparison.architecture_a} vs {comparison.architecture_b} ({'match' if comparison.architecture_match else 'mismatch'})", f"Parameter-count difference: {comparison.parameter_count_difference:+,}", ] if comparison.resolution_difference: lines.append(f"Resolution difference: {comparison.resolution_difference[0]} vs {comparison.resolution_difference[1]}") lines.extend(["", "Messages:"]) lines.extend(f" {message}" for message in comparison.messages) if comparison.config_differences: lines.extend(["", "Config differences:"]) lines.extend(f" {item}" for item in comparison.config_differences[:30]) if comparison.only_a or comparison.only_b or comparison.shape_mismatches: lines.extend(["", "Tensor availability:"]) lines.append(f" Tensors only present in A: {len(comparison.only_a)}") lines.append(f" Tensors only present in B: {len(comparison.only_b)}") lines.append(f" Tensors with different shapes: {len(comparison.shape_mismatches)}") if comparison.group_comparisons: lines.extend(["", "Group summary:"]) for name, values in sorted(comparison.group_comparisons.items(), key=lambda item: item[1].get("mean_change_score", 0), reverse=True)[:20]: lines.append( f" {name}: {int(values['tensors'])} tensors, " f"change score {values['mean_change_score']:.6f}, " f"mean abs diff {values['mean_abs_difference']:.6f}" ) if comparison.tensor_comparisons: lines.extend(["", "Most changed tensors:"]) for item in comparison.tensor_comparisons[:40]: lines.append( f" {item.name} | score {self._metric(item.change_score)} | " f"mean abs {self._metric(item.mean_abs_difference)} | " f"relative {self._metric(item.relative_difference)} | " f"cosine {self._metric(item.cosine_similarity)} | L2 {self._metric(item.l2_distance)}" ) return "\n".join(lines) @staticmethod def _metric(value: float | None) -> str: if value is None: return "-" if abs(value) >= 1000 or (abs(value) < 0.001 and value != 0): return f"{value:.4e}" return f"{value:.6f}" @staticmethod def _duration(seconds: int) -> str: if seconds >= 3600: return f"{seconds // 3600}h {(seconds % 3600) // 60}m" return f"{seconds // 60}m {seconds % 60}s" @classmethod def _format_compare_value(cls, field: str, value) -> str: if value in (None, ""): return "—" if field == "Training Time Seconds": return cls._duration(int(value)) if field == "Learning Rate": try: return f"{float(value):.7f}" except (TypeError, ValueError): return str(value) if field in {"Final Loss", "Peak Vram Gb"}: try: return f"{float(value):.5f}" except (TypeError, ValueError): return str(value) return str(value) class DatasetLabPage(QWidget): def __init__(self, root_path: Path) -> None: super().__init__() self.root_path = root_path self.store = StudioStore(root_path) self.current_folder = "" self.selected_videos: list[str] = [] self.selected_item_path = "" self.cnn_scores: dict[str, object] = {} self._scan_worker: DatasetScanWorker | None = None self._transcript_worker: TranscriptExportWorker | None = None self._cnn_worker: CnnReviewerWorker | None = None root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) root.addWidget( _page_header( "Dataset Lab", "Inspect local datasets, caption coverage, duplicates, dimensions, and transcript exports.", ) ) chooser = QHBoxLayout() self.folder = QLineEdit() self.folder.setPlaceholderText("Choose a dataset folder") browse = QPushButton("Browse") scan = QPushButton("Scan") browse.clicked.connect(self._browse_dataset) scan.clicked.connect(self._scan) chooser.addWidget(self.folder, 1) chooser.addWidget(browse) chooser.addWidget(scan) root.addLayout(chooser) self.summary = QLabel("No dataset scanned yet.") self.summary.setWordWrap(True) self.summary.setProperty("muted", True) root.addWidget(self.summary) body = QHBoxLayout() self.files = QTableWidget(0, 7) self.files.setHorizontalHeaderLabels(["FILE", "TYPE", "SIZE", "DIMENSIONS", "CAPTION", "DUPLICATE", "CNN REVIEW"]) self.files.setEditTriggers(QAbstractItemView.NoEditTriggers) self.files.setSelectionBehavior(QAbstractItemView.SelectRows) self.files.setSelectionMode(QAbstractItemView.SingleSelection) self.files.verticalHeader().hide() self.files.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) for column in range(1, 7): self.files.horizontalHeader().setSectionResizeMode(column, QHeaderView.ResizeToContents) self.files.itemSelectionChanged.connect(self._show_selected_file) body.addWidget(self.files, 3) side = QVBoxLayout() side.setSpacing(12) inspector = _card() inspector_layout = QVBoxLayout(inspector) inspector_layout.setContentsMargins(17, 16, 17, 16) inspector_layout.setSpacing(8) inspector_layout.addWidget(_card_title("DATASET ITEM")) self.preview = QLabel("Select an image or caption") self.preview.setAlignment(Qt.AlignCenter) self.preview.setFixedSize(260, 190) self.preview.setProperty("muted", True) self.preview.setStyleSheet( f"background: #050d14; border: 1px solid {COLORS['border_bright']}; border-radius: 8px;" ) self.caption = QPlainTextEdit() self.caption.setPlaceholderText("Caption text appears here.") self.caption.setMaximumHeight(105) decision_row = QHBoxLayout() decision_row.addWidget(QLabel("Decision")) self.decision = QComboBox() self.decision.addItem("Uncertain", "unreviewed") self.decision.addItem("Accept", "keep") self.decision.addItem("Reject", "reject") decision_row.addWidget(self.decision) save_caption = QPushButton("Save caption") open_file = QPushButton("Open file") inspector_layout.addWidget(self.preview, 0, Qt.AlignHCenter) inspector_layout.addWidget(self.caption) inspector_layout.addLayout(decision_row) inspector_layout.addWidget(save_caption) inspector_layout.addWidget(open_file) side.addWidget(inspector) cnn = _card() cnn_layout = QVBoxLayout(cnn) cnn_layout.setContentsMargins(17, 16, 17, 16) cnn_layout.setSpacing(8) cnn_layout.addWidget(_card_title("CNN FRAME REVIEWER")) self.cnn_hint = QLabel( "Teach a small local CNN from your Keep and Reject choices. It only ranks frames for review; it never changes Oasis or deletes data." ) self.cnn_hint.setWordWrap(True) self.cnn_hint.setProperty("muted", True) self.cnn_train = QPushButton("Train from my decisions") self.cnn_score = QPushButton("Score this dataset") self.cnn_status = QLabel("Review at least 8 Keep and 8 Reject frames to begin.") self.cnn_status.setWordWrap(True) self.cnn_status.setProperty("muted", True) cnn_layout.addWidget(self.cnn_hint) cnn_layout.addWidget(self.cnn_train) cnn_layout.addWidget(self.cnn_score) cnn_layout.addWidget(self.cnn_status) side.addWidget(cnn) transcript = _card() transcript.setMinimumWidth(360) transcript_layout = QVBoxLayout(transcript) transcript_layout.setContentsMargins(17, 16, 17, 16) transcript_layout.setSpacing(9) transcript_layout.addWidget(_card_title("TRANSCRIPT TO DATASET")) self.video_summary = QLabel("No videos selected.") self.video_summary.setWordWrap(True) self.video_summary.setProperty("muted", True) backend_status = ", ".join( f"{backend.name}: {'ready' if backend.available else 'missing'}" for backend in available_transcription_backends() ) self.transcript_backend = QLabel(backend_status) self.transcript_backend.setWordWrap(True) self.transcript_backend.setProperty("muted", True) choose_videos = QPushButton("Choose videos") export = QPushButton("Export TXT / JSONL") choose_videos.clicked.connect(self._choose_videos) export.clicked.connect(self._export_transcripts) self.transcript_status = QPlainTextEdit() self.transcript_status.setReadOnly(True) self.transcript_status.setMaximumHeight(230) transcript_layout.addWidget(self.video_summary) transcript_layout.addWidget(self.transcript_backend) transcript_layout.addWidget(choose_videos) transcript_layout.addWidget(export) transcript_layout.addWidget(self.transcript_status, 1) side.addWidget(transcript, 1) body.addLayout(side, 1) root.addLayout(body, 1) save_caption.clicked.connect(self._save_caption) open_file.clicked.connect(self._open_selected_file) self.decision.currentIndexChanged.connect(self._decision_changed) self.cnn_train.clicked.connect(self._train_cnn_reviewer) self.cnn_score.clicked.connect(self._score_with_cnn_reviewer) def _browse_dataset(self) -> None: selected = QFileDialog.getExistingDirectory(self, "Choose dataset", self.folder.text() or str(self.root_path / "ADAM_Datasets")) if selected: self.folder.setText(selected) self._scan() def _scan(self) -> None: if self._scan_worker and self._scan_worker.isRunning(): self.summary.setText("Dataset scan is already running.") return folder = self.folder.text().strip() if not folder: self.summary.setText("Choose a dataset folder first.") return self.summary.setText("Scanning dataset...") self.cnn_scores = {} self.files.setRowCount(0) self._scan_worker = DatasetScanWorker(folder) self._scan_worker.scanned.connect(self._scan_finished) self._scan_worker.failed.connect(self._scan_failed) self._scan_worker.finished.connect(self._scan_worker.deleteLater) self._scan_worker.finished.connect(lambda: setattr(self, "_scan_worker", None)) self._scan_worker.start() def _scan_finished(self, report) -> None: self.current_folder = report.path self.store.load() self.summary.setText( f"{report.image_count:,} images · {report.video_count:,} videos · {report.caption_count:,} captions · " f"{report.missing_caption_count:,} missing captions · {report.duplicate_groups:,} duplicate groups\n" + (" ".join(report.warnings) if report.warnings else "Dataset sample looks ready for review.") ) self.files.setRowCount(len(report.items)) for row, item in enumerate(report.items): values = [ Path(item.path).name, item.kind, f"{item.size_bytes / 1024:.1f} KB", f"{item.width}x{item.height}" if item.width and item.height else "—", "Yes" if item.caption_path else "—", item.duplicate_key[:8] if item.duplicate_key else "—", "—", ] for column, value in enumerate(values): table_item = QTableWidgetItem(value) table_item.setToolTip(item.path) if column: table_item.setTextAlignment(Qt.AlignCenter) table_item.setData(Qt.UserRole, item.path) self.files.setItem(row, column, table_item) if report.items: self.files.selectRow(0) else: self.preview.setPixmap(QPixmap()) self.preview.setText("No files to preview") self.caption.clear() self._update_cnn_status() def _scan_failed(self, message: str) -> None: self.summary.setText(f"Dataset scan failed: {message}") def _show_selected_file(self) -> None: rows = self.files.selectionModel().selectedRows() if not rows: return item = self.files.item(rows[0].row(), 0) path = Path(str(item.data(Qt.UserRole) if item else "")).expanduser() self.selected_item_path = str(path) pixmap = QPixmap(str(path)) if not pixmap.isNull(): self.preview.setPixmap(pixmap.scaled(self.preview.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)) self.preview.setText("") caption_path = next((path.with_suffix(ext) for ext in (".txt", ".caption") if path.with_suffix(ext).is_file()), path.with_suffix(".txt")) else: self.preview.setPixmap(QPixmap()) self.preview.setText(path.name or "No preview") caption_path = path if path.suffix.casefold() in {".txt", ".caption"} else path.with_suffix(".txt") try: text = caption_path.read_text(encoding="utf-8") if caption_path.is_file() else "" except OSError as exc: text = f"Caption could not be read: {exc}" self.caption.setPlainText(text) self.caption.setProperty("caption_path", str(caption_path)) decision = "unreviewed" if self.current_folder and pixmap.isNull() is False: decision = self.store.review(self.current_folder).decisions.get(str(path.resolve()), "unreviewed") index = self.decision.findData(decision) self.decision.blockSignals(True) self.decision.setCurrentIndex(max(0, index)) self.decision.blockSignals(False) def _save_caption(self) -> None: raw_path = str(self.caption.property("caption_path") or "") if not raw_path: return caption_path = Path(raw_path).expanduser() try: caption_path.write_text(self.caption.toPlainText().strip() + "\n", encoding="utf-8") self.summary.setText(f"Saved caption: {caption_path.name}") except OSError as exc: QMessageBox.warning(self, "Caption not saved", str(exc)) def _decision_changed(self) -> None: if not self.current_folder or not self.selected_item_path: return path = Path(self.selected_item_path) if path.suffix.casefold() not in {".jpg", ".jpeg", ".png", ".webp", ".bmp"}: return try: self.store.set_decision(self.current_folder, self.selected_item_path, str(self.decision.currentData())) self.summary.setText(f"Saved review decision for {path.name}.") self._update_cnn_status() except (OSError, ValueError) as exc: QMessageBox.warning(self, "Decision not saved", str(exc)) def _open_selected_file(self) -> None: if self.selected_item_path and Path(self.selected_item_path).exists(): QDesktopServices.openUrl(QUrl.fromLocalFile(self.selected_item_path)) def _update_cnn_status(self) -> None: if not self.current_folder: self.cnn_train.setEnabled(False) self.cnn_score.setEnabled(False) self.cnn_status.setText("Choose and scan a dataset first.") return decisions = self.store.review(self.current_folder).decisions keeps = sum(value == "keep" for value in decisions.values()) rejects = sum(value == "reject" for value in decisions.values()) checkpoint = reviewer_checkpoint(self.root_path, self.current_folder) working = bool(self._cnn_worker and self._cnn_worker.isRunning()) self.cnn_train.setEnabled(not working) self.cnn_score.setEnabled(checkpoint.is_file() and not working) trained = " Reviewer is ready." if checkpoint.is_file() else "" self.cnn_status.setText(f"{keeps} Keep · {rejects} Reject reviewed.{trained}") def _run_cnn_reviewer(self, mode: str) -> None: if self._cnn_worker and self._cnn_worker.isRunning(): return if not self.current_folder: self.cnn_status.setText("Choose and scan a dataset first.") return decisions = dict(self.store.review(self.current_folder).decisions) self.cnn_status.setText("Starting CNN reviewer…") self.cnn_train.setEnabled(False) self.cnn_score.setEnabled(False) self._cnn_worker = CnnReviewerWorker(mode, self.root_path, self.current_folder, decisions) self._cnn_worker.progress.connect(self.cnn_status.setText) self._cnn_worker.completed.connect(self._cnn_completed) self._cnn_worker.failed.connect(self._cnn_failed) self._cnn_worker.finished.connect(self._cnn_worker.deleteLater) self._cnn_worker.finished.connect(self._cnn_finished) self._cnn_worker.start() def _train_cnn_reviewer(self) -> None: self._run_cnn_reviewer("train") def _score_with_cnn_reviewer(self) -> None: self._run_cnn_reviewer("score") def _cnn_completed(self, mode: str, result: object) -> None: if mode == "train": self.cnn_status.setText( f"CNN reviewer trained with {result.kept_examples} Keep and {result.rejected_examples} Reject frames." ) self._update_cnn_status() return self.cnn_scores = {score.path: score for score in result} for row in range(self.files.rowCount()): item = self.files.item(row, 0) path = str(item.data(Qt.UserRole) if item else "") score = self.cnn_scores.get(str(Path(path).expanduser().resolve())) if path else None label = "—" if not score else f"{score.suggestion.title()} {score.keep_probability:.0%}" cell = QTableWidgetItem(label) cell.setTextAlignment(Qt.AlignCenter) self.files.setItem(row, 6, cell) self.cnn_status.setText(f"CNN suggested Keep, Reject, or Review for {len(self.cnn_scores):,} frames. Suggestions did not change your decisions.") self._update_cnn_status() def _cnn_failed(self, message: str) -> None: self.cnn_status.setText(f"CNN reviewer could not run: {message}") def _cnn_finished(self) -> None: self._cnn_worker = None self._update_cnn_status() def _choose_videos(self) -> None: files, _ = QFileDialog.getOpenFileNames( self, "Choose local videos", str(self.root_path), "Videos (*.mp4 *.mov *.mkv *.webm *.avi)", ) self.selected_videos = files self.video_summary.setText(f"{len(files)} video(s) selected." if files else "No videos selected.") def _export_transcripts(self) -> None: if self._transcript_worker and self._transcript_worker.isRunning(): self.transcript_status.setPlainText("Transcript export is already running.") return output = QFileDialog.getExistingDirectory( self, "Choose transcript dataset output", self.current_folder or str(self.root_path / "data" / "transcript_datasets"), ) if not output: return self.transcript_status.setPlainText("Preparing transcript dataset...") self._transcript_worker = TranscriptExportWorker(self.selected_videos, output) self._transcript_worker.completed.connect(self._transcript_finished) self._transcript_worker.finished.connect(self._transcript_worker.deleteLater) self._transcript_worker.finished.connect(lambda: setattr(self, "_transcript_worker", None)) self._transcript_worker.start() def _transcript_finished(self, result) -> None: self.transcript_status.setPlainText( result.message + (f"\nOutput: {result.output_folder}" if result.output_folder else "") ) class RemoteAccessPage(QWidget): def __init__(self, service: RemoteAccessService) -> None: super().__init__() self.service = service root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) root.addWidget( _page_header( "Remote Access", "Optional authenticated local-network status API for a browser or phone. Disabled by default.", ) ) card = _card() layout = QGridLayout(card) layout.setContentsMargins(18, 17, 18, 17) layout.setHorizontalSpacing(12) layout.setVerticalSpacing(10) self.enabled = QCheckBox("Enable remote access service") self.remote_mode = QComboBox() self.remote_mode.addItem("Local / Wi-Fi Only", REMOTE_MODE_LOCAL) self.remote_mode.addItem("Private Tailscale", REMOTE_MODE_TAILSCALE) self.remote_mode.addItem("Disabled", REMOTE_MODE_DISABLED) self.bind = QLineEdit() self.port = QSpinBox() self.port.setRange(1024, 65535) self.token = QLineEdit() self.token.setEchoMode(QLineEdit.PasswordEchoOnEdit) self.allow_job_control = QCheckBox("Allow remote job controls and approval changes") self.allow_job_control.setToolTip("Allows approval, pause, resume, stop and retry from devices with your access token.") self.auto_approve_training = QCheckBox("Auto-approve remote training prompts") self.status = QLabel() self.status.setWordWrap(True) self.status.setProperty("muted", True) self.qr_code = QLabel("Use phone access to generate a QR code.") self.qr_code.setAlignment(Qt.AlignCenter) self.qr_code.setMinimumSize(220, 220) self.qr_code.setStyleSheet( f"background: #ffffff; color: #00101b; border: 1px solid {COLORS['border_bright']}; border-radius: 8px;" ) self.qr_caption = QLabel() self.qr_caption.setWordWrap(True) self.qr_caption.setProperty("muted", True) self.tailscale_status = QLabel() self.tailscale_status.setWordWrap(True) self.tailscale_status.setProperty("muted", True) save = QPushButton("Save") toggle = QPushButton("Start / Stop") open_url = QPushButton("Open local test URL") phone_access = QPushButton("Use phone access") copy_phone_url = QPushButton("Copy phone URL") start_tailscale = QPushButton("Start private Tailscale") stop_tailscale = QPushButton("Stop private Tailscale") regenerate = QPushButton("New token") layout.addWidget(self.enabled, 0, 0, 1, 2) layout.addWidget(QLabel("Remote mode"), 1, 0) layout.addWidget(self.remote_mode, 1, 1) layout.addWidget(QLabel("Bind address"), 2, 0) layout.addWidget(self.bind, 2, 1) layout.addWidget(QLabel("Port"), 3, 0) layout.addWidget(self.port, 3, 1) layout.addWidget(QLabel("Token"), 4, 0) layout.addWidget(self.token, 4, 1) layout.addWidget(self.allow_job_control, 5, 0, 1, 2) layout.addWidget(self.auto_approve_training, 6, 0, 1, 2) layout.addWidget(save, 7, 0) layout.addWidget(toggle, 7, 1) layout.addWidget(regenerate, 8, 0) layout.addWidget(open_url, 8, 1) layout.addWidget(phone_access, 9, 0) layout.addWidget(copy_phone_url, 9, 1) layout.addWidget(start_tailscale, 10, 0) layout.addWidget(stop_tailscale, 10, 1) layout.addWidget(self.tailscale_status, 11, 0, 1, 2) layout.addWidget(self.qr_code, 12, 0, 1, 2) layout.addWidget(self.qr_caption, 13, 0, 1, 2) layout.addWidget(self.status, 14, 0, 1, 2) root.addWidget(card) root.addStretch() save.clicked.connect(self._save) toggle.clicked.connect(self._toggle) open_url.clicked.connect(self._open_status_url) phone_access.clicked.connect(self._enable_phone_access) copy_phone_url.clicked.connect(self._copy_phone_url) start_tailscale.clicked.connect(self._start_tailscale) stop_tailscale.clicked.connect(self._stop_tailscale) regenerate.clicked.connect(self._regenerate) self.refresh() def refresh(self) -> None: settings = self.service.settings() self.enabled.setChecked(bool(settings["enabled"])) mode_index = self.remote_mode.findData(settings.get("remote_mode", REMOTE_MODE_LOCAL)) self.remote_mode.setCurrentIndex(max(0, mode_index)) self.bind.setText(str(settings["bind_address"])) self.port.setValue(int(settings["port"])) self.token.setText(str(settings["token"])) self.allow_job_control.setChecked(bool(settings["allow_job_control"])) self.auto_approve_training.setChecked(bool(settings.get("auto_approve_training", False))) if not hasattr(self, "_status_reader"): self._status_reader = BackgroundRead(self) self._status_reader.ready.connect(self._status_loaded) self._status_reader.failed.connect(lambda error: self.status.setText(f"Could not refresh connection status: {error}")) service = self.service self._status_reader.request(lambda: (settings, service.phone_test_url(), service.tailscale_status(), service.tailscale_url()), force=True) def _status_loaded(self, result: object) -> None: settings, phone_url, tailscale, tailscale_url = result if settings != self.service.settings(): self.refresh() return scope = remote_scope(str(settings["bind_address"])) mode = str(settings.get("remote_mode", REMOTE_MODE_LOCAL)) self.bind.setEnabled(mode != REMOTE_MODE_TAILSCALE) tailscale_lines = [ f"Tailscale: {'installed' if tailscale.installed else 'not installed'}", f"Status: {'connected' if tailscale.connected else 'disconnected'}", ] if tailscale.device_name: tailscale_lines.append(f"Device: {tailscale.device_name}") if tailscale.tailscale_ip: tailscale_lines.append(f"Private IP: {tailscale.tailscale_ip}") if tailscale_url: tailscale_lines.append(f"Private URL: {tailscale_url}") elif mode == REMOTE_MODE_TAILSCALE: tailscale_lines.append("Private URL appears after Tailscale is installed, connected, and Serve is started.") tailscale_lines.append(tailscale.message) self.tailscale_status.setText("\n".join(tailscale_lines)) phone_hint = ( f" Phone URL: {phone_url}" if phone_url else " For the phone dashboard and QR code, use the button below while your phone is on the same Wi-Fi." ) self.status.setText( ( f"Running at {self.service.url()} · Scope: {scope}. " "Use Open local test URL on this computer, scan the QR code on your phone, or send the token as a Bearer token from another device. " "Dangerous actions are unavailable remotely." + phone_hint ) if self.service.running else ( f"Stopped · Scope when started: {scope}. Keep 127.0.0.1 for this device only. " "Remote clients can view status, system usage, and queue state." + phone_hint ) ) self._refresh_qr(phone_url) def _save(self) -> bool: bind = self.bind.text().strip() or "127.0.0.1" was_running = self.service.running mode = str(self.remote_mode.currentData() or REMOTE_MODE_LOCAL) enabled = self.enabled.isChecked() and mode != REMOTE_MODE_DISABLED if mode == REMOTE_MODE_TAILSCALE: bind = "127.0.0.1" if enabled and mode == REMOTE_MODE_LOCAL and bind not in {"127.0.0.1", "localhost"}: answer = QMessageBox.question( self, "Enable local-network access", "This can expose ADAM status to other devices on your network. Continue only on a trusted network.", QMessageBox.Yes | QMessageBox.No, QMessageBox.No, ) if answer != QMessageBox.Yes: return False self.service.save_settings( { "enabled": enabled, "remote_mode": mode, "bind_address": bind, "port": self.port.value(), "token": self.token.text().strip(), "allow_job_control": self.allow_job_control.isChecked(), "auto_approve_training": self.auto_approve_training.isChecked(), } ) if was_running: self.service.stop() if enabled: try: self.service.start() except (OSError, RuntimeError) as exc: self.status.setText(f"Remote access settings were saved, but restart failed: {exc}") return False self.refresh() return True def _toggle(self) -> None: if self.service.running: self.service.stop() self.refresh() return self.enabled.setChecked(True) if not self._save(): return try: self.service.start() self.refresh() except (OSError, RuntimeError) as exc: self.status.setText(f"Remote access could not start: {exc}") def _open_status_url(self) -> None: QDesktopServices.openUrl(QUrl(self.service.local_test_url())) def _enable_phone_access(self) -> None: self.enabled.setChecked(True) self.remote_mode.setCurrentIndex(max(0, self.remote_mode.findData(REMOTE_MODE_LOCAL))) self.bind.setText("0.0.0.0") if self._save() and not self.service.running: try: self.service.start() except (OSError, RuntimeError) as exc: self.status.setText(f"Remote access could not start: {exc}") return self.refresh() def _copy_phone_url(self) -> None: url = self.service.phone_test_url() if not url: self.status.setText("No phone URL yet. Choose Use phone access, then keep your phone on the same Wi-Fi.") return QApplication.clipboard().setText(url) self.status.setText(f"Copied phone URL: {url}") def _start_tailscale(self) -> None: self.enabled.setChecked(True) self.remote_mode.setCurrentIndex(max(0, self.remote_mode.findData(REMOTE_MODE_TAILSCALE))) self.bind.setText("127.0.0.1") if not self._save(): return if not self.service.running: try: self.service.start() except (OSError, RuntimeError) as exc: self.status.setText(f"ADAM Remote could not start for Tailscale: {exc}") return ok, message = self.service.start_tailscale_serve() self.status.setText(message) self.refresh() def _stop_tailscale(self) -> None: answer = QMessageBox.question( self, "Stop Tailscale Serve", "This resets Tailscale Serve forwarding on this PC. ADAM will keep running locally. Continue?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No, ) if answer != QMessageBox.Yes: return ok, message = self.service.stop_tailscale_serve() self.status.setText(message) self.refresh() def _refresh_qr(self, url: str) -> None: if not url: self.qr_code.setPixmap(QPixmap()) self.qr_code.setText("Use phone access to generate a QR code.") self.qr_caption.setText("The QR code appears here after ADAM is available to devices on your Wi-Fi.") return pixmap = self._qr_pixmap(url) if pixmap is None: self.qr_code.setPixmap(QPixmap()) self.qr_code.setText("QR package not installed") self.qr_caption.setText("Install ADAM requirements, then restart the app to generate phone QR codes.") return self.qr_code.setText("") self.qr_code.setPixmap(pixmap) self.qr_caption.setText("Scan this code to open the ADAM mobile dashboard on your phone.") @staticmethod def _qr_pixmap(url: str) -> QPixmap | None: try: import qrcode except ImportError: return None image = qrcode.make(url).convert("RGB") buffer = BytesIO() image.save(buffer, format="PNG") pixmap = QPixmap() if not pixmap.loadFromData(buffer.getvalue(), "PNG"): return None return pixmap.scaled(220, 220, Qt.KeepAspectRatio, Qt.FastTransformation) def _regenerate(self) -> None: from adam.remote_access import default_remote_settings self.token.setText(str(default_remote_settings()["token"])) self._save() class ToolsPage(QWidget): setup_requested = Signal() def __init__( self, registry: ToolRegistry, tool_folders: ToolFolderManager, ) -> None: super().__init__() self.registry = registry self.tool_folders = tool_folders root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) title_row = QHBoxLayout() title_row.addWidget( _page_header( "Tool registry", "ADAM can execute only these registered backends. Disabled entries are safe placeholders.", ), 1, ) reload_button = QPushButton("Reload registry") reload_button.clicked.connect(self.reload) title_row.addWidget(reload_button, 0, Qt.AlignTop) root.addLayout(title_row) info = _card() info_layout = QHBoxLayout(info) info_layout.setContentsMargins(16, 12, 16, 12) info_icon = QLabel("i") info_icon.setAlignment(Qt.AlignCenter) info_icon.setFixedSize(25, 25) info_icon.setStyleSheet( f"border-radius: 12px; color: {COLORS['blue_2']}; " f"border: 1px solid {COLORS['blue']}; font-weight: 700;" ) info_text = QLabel( "Demo tools prove orchestration without downloading data or training. " "Connect a Python function or script in config/tools.json to replace a demo backend." ) info_text.setWordWrap(True) info_text.setProperty("muted", True) info_layout.addWidget(info_icon) info_layout.addWidget(info_text, 1) configure_demo = QPushButton("Configure demo tools") configure_demo.clicked.connect(self.setup_requested) info_layout.addWidget(configure_demo) root.addWidget(info) self.mode_summary = QLabel() self.mode_summary.setProperty("muted", True) root.addWidget(self.mode_summary) self.table = QTableWidget(0, 6) self.table.setHorizontalHeaderLabels( ["TOOL", "CATEGORY", "BACKEND", "MODE", "CONFIRM", "STATUS"] ) self.table.setAlternatingRowColors(True) self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) self.table.verticalHeader().hide() header = self.table.horizontalHeader() header.setSectionResizeMode(0, QHeaderView.Stretch) for column in range(1, 6): header.setSectionResizeMode(column, QHeaderView.ResizeToContents) self.table.setToolTip( "Edit config/tools.json to point entries at your existing Python backends." ) root.addWidget(self.table, 1) self.reload() def reload(self) -> None: try: self.registry.load() except Exception as exc: QMessageBox.warning(self, "Registry error", str(exc)) return tools = self.registry.all() real_count = sum(tool.enabled and not tool.demo for tool in tools) demo_count = sum(tool.enabled and tool.demo for tool in tools) disabled_count = sum(not tool.enabled for tool in tools) self.mode_summary.setText( f"{real_count} real · {demo_count} demo · {disabled_count} not configured. " "Demo steps create transparent placeholders and never produce trained weights." ) folder_statuses = self.tool_folders.scan_all() self.table.setRowCount(len(tools)) for row, tool in enumerate(tools): folder_status = folder_statuses.get(tool.id) detected = bool(folder_status and folder_status.valid) backend_type = ( "External folder" if detected and not tool.enabled else str(tool.backend.get("type", "unconfigured")).title() ) if detected and tool.demo: status_text = "Demo active · folder detected" elif detected and not tool.enabled: status_text = "Detected · adapter pending" elif tool.enabled: status_text = "Ready" else: status_text = "Not configured" values = [ f"{tool.name}\n{tool.description}", tool.category, backend_type, "Demo" if tool.demo else "Real", "Required" if tool.requires_confirmation else "No", status_text, ] for column, value in enumerate(values): item = QTableWidgetItem(value) if column: item.setTextAlignment(Qt.AlignCenter) if column == 5: item.setForeground( Qt.green if tool.enabled else ( Qt.cyan if detected else Qt.gray ) ) if column == 3: item.setForeground(Qt.yellow if tool.demo else Qt.green) if folder_status and folder_status.path: item.setToolTip( f"{folder_status.path}\n{folder_status.message}" ) self.table.setItem(row, column, item) self.table.setRowHeight(row, 54) class SystemPage(QWidget): def __init__(self) -> None: super().__init__() root = QVBoxLayout(self) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) root.addWidget( _page_header( "System monitor", "Live local telemetry for resource planning and training oversight.", ) ) metrics = QGridLayout() metrics.setHorizontalSpacing(12) metrics.setVerticalSpacing(12) self.cpu = MetricCard("CPU", COLORS["blue"]) self.ram = MetricCard("Memory", COLORS["purple"]) self.gpu = MetricCard("GPU", COLORS["green"]) self.vram = MetricCard("VRAM", COLORS["orange"]) metrics.addWidget(self.cpu, 0, 0) metrics.addWidget(self.ram, 0, 1) metrics.addWidget(self.gpu, 1, 0) metrics.addWidget(self.vram, 1, 1) root.addLayout(metrics) training = _card() training_layout = QVBoxLayout(training) training_layout.setContentsMargins(18, 17, 18, 17) training_layout.addWidget(_card_title("TRAINING MONITOR")) self.training_status = QLabel("No active training job") self.training_status.setStyleSheet("font-size: 18px; font-weight: 650;") self.training_progress = QProgressBar() self.training_progress.setRange(0, 100) self.resource_warning = QLabel() self.resource_warning.setWordWrap(True) self.training_log = QPlainTextEdit() self.training_log.setReadOnly(True) self.training_log.setMaximumHeight(145) training_hint = QLabel( "When a registered trainer runs, job progress, current step, logs, and " "output status are visible here and in Jobs." ) training_hint.setProperty("muted", True) training_hint.setWordWrap(True) training_layout.addWidget(self.training_status) training_layout.addWidget(self.training_progress) training_layout.addWidget(self.resource_warning) training_layout.addWidget(training_hint) training_layout.addWidget(self.training_log) training_layout.addStretch() root.addWidget(training, 1) def update_snapshot(self, snapshot: SystemSnapshot) -> None: self.cpu.update_metric( f"{snapshot.cpu_percent:.0f}%", "Current processor load", snapshot.cpu_percent, ) self.ram.update_metric( f"{snapshot.memory_percent:.0f}%", f"{snapshot.memory_used_gb:.1f} / {snapshot.memory_total_gb:.1f} GB", snapshot.memory_percent, ) temperature = ( f"{snapshot.gpu_temperature:.0f}°C" if snapshot.gpu_temperature is not None else "Temperature unavailable" ) self.gpu.update_metric( f"{snapshot.gpu_percent:.0f}%", f"{snapshot.gpu_name} · {temperature}", snapshot.gpu_percent, ) self.vram.update_metric( f"{snapshot.vram_percent:.0f}%", f"{snapshot.vram_used_gb:.1f} / {snapshot.vram_total_gb:.1f} GB", snapshot.vram_percent, ) warnings = [] if snapshot.vram_percent >= 92: warnings.append( "VRAM is nearly full; watch for an out-of-memory failure." ) if snapshot.gpu_temperature is not None and snapshot.gpu_temperature >= 85: warnings.append("GPU temperature is high; cooling may be needed.") self.resource_warning.setText(" · ".join(warnings)) self.resource_warning.setStyleSheet( f"color: {COLORS['orange'] if warnings else COLORS['muted']};" ) def set_active_job(self, job: Job | None) -> None: if job and any(step.tool_id.endswith("trainer") for step in job.plan.steps): self.training_status.setText( f"{job.plan.project_name} · {job.progress}% · {job.status.value}" ) self.training_progress.setValue(job.progress) self.training_log.setPlainText("\n".join(job.logs[-12:])) self.training_log.verticalScrollBar().setValue( self.training_log.verticalScrollBar().maximum() ) else: self.training_status.setText("No active training job") self.training_progress.setValue(0) self.training_log.clear() class ExternalToolDialog(QDialog): connector_saved = Signal() def __init__(self, root_path: Path, parent: QWidget | None = None) -> None: super().__init__(parent) self.root_path = root_path self.store = ExternalToolStore(root_path) self.analysis = ToolAnalysis("") self.scan_worker: ToolScanWorker | None = None self.setWindowTitle("Add External Tool") self.setMinimumSize(760, 680) root = QVBoxLayout(self) root.setSpacing(10) root.addWidget( _page_header( "External Tool Connector", "ADAM reads the selected files without running them, then explains compatibility and safety concerns.", ) ) folder_row = QHBoxLayout() self.folder = QLineEdit() self.folder.setPlaceholderText("Choose the external program folder…") browse = QPushButton("Browse") browse.clicked.connect(self._browse) self.scan_button = QPushButton("Scan safely") self.scan_button.setProperty("primary", True) self.scan_button.clicked.connect(self._scan) folder_row.addWidget(self.folder, 1) folder_row.addWidget(browse) folder_row.addWidget(self.scan_button) root.addLayout(folder_row) selection = QGridLayout() self.entry = QComboBox() self.config_files = QListWidget() self.config_files.setMaximumHeight(90) self.config_files.setSelectionMode(QAbstractItemView.MultiSelection) selection.addWidget(QLabel("Training entry script"), 0, 0) selection.addWidget(self.entry, 0, 1) selection.addWidget(QLabel("Important config files"), 1, 0, Qt.AlignTop) selection.addWidget(self.config_files, 1, 1) root.addLayout(selection) self.entry.currentTextChanged.connect(self._reanalyze) self.config_files.itemSelectionChanged.connect(self._reanalyze) identity = QGridLayout() self.tool_name = QLineEdit() self.tool_name.setPlaceholderText("Example: APVD Model Trainer") self.description = QLineEdit() self.description.setPlaceholderText("What this program trains or produces") self.arguments = QLineEdit() self.arguments.setPlaceholderText("Detected arguments, comma separated") self.required = QLineEdit() self.required.setPlaceholderText("Required arguments, comma separated") for row, (label, widget) in enumerate( ( ("Tool name", self.tool_name), ("Description", self.description), ("Command-line inputs", self.arguments), ("Required inputs", self.required), ) ): identity.addWidget(QLabel(label), row, 0) identity.addWidget(widget, row, 1) root.addLayout(identity) self.score = QLabel("Compatibility: not scanned") self.score.setStyleSheet("font-size: 20px; font-weight: 700;") root.addWidget(self.score) self.report = QPlainTextEdit() self.report.setReadOnly(True) self.report.setMinimumHeight(245) root.addWidget(self.report, 1) disclaimer = QLabel( "The rating is a static compatibility review, not a guarantee that third-party " "code is harmless. Every run remains approval-gated." ) disclaimer.setWordWrap(True) disclaimer.setProperty("muted", True) root.addWidget(disclaimer) self.buttons = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Save) self.buttons.button(QDialogButtonBox.Save).setText("Register external tool") self.buttons.button(QDialogButtonBox.Save).setEnabled(False) self.buttons.accepted.connect(self._save) self.buttons.rejected.connect(self.reject) root.addWidget(self.buttons) def _browse(self) -> None: selected = QFileDialog.getExistingDirectory( self, "Choose external tool folder", self.folder.text() or str(Path.home()) ) if selected: self.folder.setText(selected) self._scan() def _scan(self) -> None: folder = self.folder.text().strip() if self.scan_worker and self.scan_worker.isRunning(): return self.scan_button.setEnabled(False) self.scan_button.setText("Scanning…") self.report.setPlainText("Scanning the selected folder safely…") self.buttons.button(QDialogButtonBox.Save).setEnabled(False) self.buttons.button(QDialogButtonBox.Cancel).setEnabled(False) self.scan_worker = ToolScanWorker(folder) self.scan_worker.scanned.connect(self._scan_finished) self.scan_worker.failed.connect(self._scan_failed) self.scan_worker.finished.connect(self._scan_worker_finished) self.scan_worker.start() def _scan_finished(self, analysis: object) -> None: if not isinstance(analysis, ToolAnalysis): self._scan_failed("The folder scan returned an unexpected result.") return self.analysis = analysis self.entry.blockSignals(True) self.entry.clear() self.entry.addItems(self.analysis.entry_candidates) if self.analysis.selected_entry: self.entry.setCurrentText(self.analysis.selected_entry) self.entry.blockSignals(False) self.config_files.blockSignals(True) self.config_files.clear() self.config_files.addItems(self.analysis.config_files) self.config_files.blockSignals(False) if not self.tool_name.text().strip() and self.analysis.folder: self.tool_name.setText(Path(self.analysis.folder).name) self._reanalyze() def _scan_failed(self, message: str) -> None: self.report.setPlainText(f"The folder could not be scanned:\n\n{message}") def _scan_worker_finished(self) -> None: self.scan_button.setEnabled(True) self.scan_button.setText("Scan safely") self.buttons.button(QDialogButtonBox.Cancel).setEnabled(True) if self.scan_worker: self.scan_worker.deleteLater() self.scan_worker = None def closeEvent(self, event: QCloseEvent) -> None: if self.scan_worker and self.scan_worker.isRunning(): self.report.setPlainText( "Please wait for the safe folder scan to finish before closing this window." ) event.ignore() return super().closeEvent(event) def _reanalyze(self) -> None: if not self.analysis.folder: return configs = [item.text() for item in self.config_files.selectedItems()] self.analysis = analyze_selection(self.analysis, self.entry.currentText(), configs) self.arguments.setText(", ".join(self.analysis.arguments)) self.required.setText(", ".join(self.analysis.required_arguments)) color = ( COLORS["green"] if self.analysis.score >= 8 else COLORS["orange"] if self.analysis.score >= 5 else COLORS["red"] ) self.score.setText(f"Compatibility & safety rating: {self.analysis.score}/10") self.score.setStyleSheet(f"font-size: 20px; font-weight: 700; color: {color};") report = [ f"Entry script: {self.analysis.selected_entry or 'Not detected'}", f"Dataset format: {self.analysis.dataset_format}", f"Output: {self.analysis.output_behavior}", f"Checkpoints: {self.analysis.checkpoint_behavior}", f"Progress: {self.analysis.progress_behavior}", f"Resume training: {self.analysis.resume_behavior}", "", "Why ADAM gave this rating:", *[f" + {reason}" for reason in self.analysis.reasons], ] if self.analysis.warnings: report.extend(["", "Warnings:", *[f" ! {warning}" for warning in self.analysis.warnings]]) self.report.setPlainText("\n".join(report)) self.buttons.button(QDialogButtonBox.Save).setEnabled( bool(self.analysis.selected_entry and Path(self.analysis.folder).is_dir()) ) @staticmethod def _field_list(text: str) -> list[str]: values = [] for value in text.split(","): normalized = value.strip().lstrip("-").replace("-", "_") if normalized and normalized.replace("_", "").isalnum() and normalized not in values: values.append(normalized) return values def _save(self) -> None: name = self.tool_name.text().strip() if not name: QMessageBox.warning(self, "Tool name required", "Give this external tool a name.") return arguments = self._field_list(self.arguments.text()) required = [ value for value in self._field_list(self.required.text()) if value in arguments ] try: self.store.save_connector( name=name, description=self.description.text(), analysis=self.analysis, arguments=arguments, required_arguments=required, ) except (OSError, ValueError) as exc: QMessageBox.warning(self, "Could not register tool", str(exc)) return self.connector_saved.emit() self.accept() class SettingsPage(QWidget): saved = Signal() def __init__( self, config: ConfigManager, tool_folders: ToolFolderManager, ) -> None: super().__init__() self.config = config self.tool_folders = tool_folders self.folder_edits: dict[str, QLineEdit] = {} self.folder_statuses: dict[str, QLabel] = {} outer = QVBoxLayout(self) outer.setContentsMargins(0, 0, 0, 0) scroll = QScrollArea() scroll.setWidgetResizable(True) scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scroll.viewport().setStyleSheet(f"background: {COLORS['bg']};") content = QWidget() content.setStyleSheet(f"background: {COLORS['bg']};") root = QVBoxLayout(content) root.setContentsMargins(24, 20, 24, 17) root.setSpacing(12) scroll.setWidget(content) outer.addWidget(scroll) root.addWidget( _page_header( "Settings", "Local provider, safety gates, and notification preferences.", ) ) columns = QHBoxLayout() columns.setSpacing(12) provider_card = _card() provider_card.setMinimumHeight(300) provider_layout = QVBoxLayout(provider_card) provider_layout.setContentsMargins(18, 17, 18, 17) provider_layout.setSpacing(10) provider_layout.addWidget(_card_title("PLANNING MODEL")) provider_layout.addWidget(QLabel("Provider")) self.provider = QComboBox() self.provider.addItem("Ollama (local)", "ollama") self.provider.addItem("Manual safe planner", "manual") index = self.provider.findData(config.get("provider")) self.provider.setCurrentIndex(max(0, index)) provider_layout.addWidget(self.provider) provider_layout.addWidget(QLabel("Ollama URL")) self.ollama_url = QLineEdit(str(config.get("ollama_url"))) provider_layout.addWidget(self.ollama_url) provider_layout.addWidget(QLabel("Model")) self.ollama_model = QLineEdit(str(config.get("ollama_model"))) provider_layout.addWidget(self.ollama_model) provider_layout.addWidget(QLabel("Chat response detail")) self.ollama_chat_response_length = QComboBox() self.ollama_chat_response_length.addItem("Automatic", "automatic") self.ollama_chat_response_length.addItem("Short", "short") self.ollama_chat_response_length.addItem("Balanced", "balanced") self.ollama_chat_response_length.addItem("Detailed", "detailed") response_length_index = self.ollama_chat_response_length.findData( str(config.get("ollama_chat_response_length", "automatic")) ) self.ollama_chat_response_length.setCurrentIndex(max(0, response_length_index)) self.ollama_chat_response_length.setToolTip( "Automatic uses a small response for simple questions and more room for image reviews, explanations, and planning." ) provider_layout.addWidget(self.ollama_chat_response_length) provider_layout.addWidget(QLabel("Maximum response length")) self.ollama_chat_max_tokens = QSpinBox() self.ollama_chat_max_tokens.setRange(64, 4096) self.ollama_chat_max_tokens.setSingleStep(64) self.ollama_chat_max_tokens.setValue(int(config.get("ollama_chat_max_tokens", 1024))) self.ollama_chat_max_tokens.setSuffix(" tokens") self.ollama_chat_max_tokens.setToolTip( "Hard limit for a Chat Mode reply. Automatic detail stays within this value." ) provider_layout.addWidget(self.ollama_chat_max_tokens) self.web_search_enabled = QCheckBox("Enable web search in Chat Mode") self.web_search_enabled.setChecked(bool(config.get("web_search_enabled", True))) self.web_search_enabled.setToolTip( "ADAM searches only when you explicitly ask it to search or ask for current information." ) provider_layout.addWidget(self.web_search_enabled) self.web_link_reading_enabled = QCheckBox("Enable controlled link reading") self.web_link_reading_enabled.setChecked(bool(config.get("web_link_reading_enabled", True))) self.web_link_reading_enabled.setToolTip( "When explicitly asked, ADAM reads up to three public pages and gives Ollama short text extracts." ) provider_layout.addWidget(self.web_link_reading_enabled) test_row = QHBoxLayout() self.test_status = QLabel("Connection not tested") self.test_status.setProperty("muted", True) test_button = QPushButton("Test Ollama") test_button.clicked.connect(self.test_ollama) test_row.addWidget(self.test_status, 1) test_row.addWidget(test_button) provider_layout.addLayout(test_row) provider_layout.addStretch() safety_card = _card() safety_card.setMinimumHeight(300) safety_layout = QVBoxLayout(safety_card) safety_layout.setContentsMargins(18, 17, 18, 17) safety_layout.setSpacing(13) safety_layout.addWidget(_card_title("SAFETY & CONTROL")) safety_note = QLabel( "The execution allow-list and confirmation gates are architectural " "controls and cannot be disabled by an LLM." ) safety_note.setWordWrap(True) safety_note.setProperty("muted", True) safety_layout.addWidget(safety_note) self.long_tasks = QCheckBox("Ask before long tasks") self.long_tasks.setChecked(bool(config.get("ask_before_long_tasks"))) self.trusted_automation = QCheckBox( "Trusted mode: auto-start registered dataset + DDPM workflows" ) self.trusted_automation.setChecked( bool(config.get("trusted_dataset_ddpm_automation")) ) self.ollama_proposed_actions = QCheckBox( "Let the planning model propose registered actions" ) self.ollama_proposed_actions.setChecked( bool(config.get("ollama_proposed_actions", True)) ) self.ollama_proposed_actions.setToolTip( "The model can only propose a plan in Trainer Mode. ADAM validates every tool and setting, then still requires approval when needed." ) self.desktop_notifications = QCheckBox("Desktop notifications") self.desktop_notifications.setChecked(bool(config.get("desktop_notifications"))) self.sound_notifications = QCheckBox("Notification sounds") self.sound_notifications.setChecked(bool(config.get("sound_notifications"))) safety_layout.addWidget(self.long_tasks) safety_layout.addWidget(self.trusted_automation) safety_layout.addWidget(self.ollama_proposed_actions) safety_layout.addWidget(self.desktop_notifications) safety_layout.addWidget(self.sound_notifications) safety_layout.addWidget(QLabel("High-volume dataset threshold")) self.dataset_threshold = QSpinBox() self.dataset_threshold.setRange(1, 100_000) self.dataset_threshold.setValue( int(config.get("max_dataset_images_without_confirmation")) ) self.dataset_threshold.setSuffix(" images") safety_layout.addWidget(self.dataset_threshold) safety_layout.addStretch() columns.addWidget(provider_card, 1) columns.addWidget(safety_card, 1) root.addLayout(columns, 1) folders_card = _card() folders_card.setMinimumHeight(340) folders_layout = QGridLayout(folders_card) folders_layout.setContentsMargins(18, 15, 18, 15) folders_layout.setHorizontalSpacing(12) folders_layout.setVerticalSpacing(8) folders_title_row = QHBoxLayout() folders_title_row.addWidget(_card_title("TOOL FOLDERS")) folders_title_row.addStretch() scan_button = QPushButton("Scan folders") scan_button.clicked.connect(self.scan_tool_folders) folders_title_row.addWidget(scan_button) folders_layout.addLayout(folders_title_row, 0, 0, 1, 2) hint = QLabel( "Point ADAM at your existing programs. The code stays in its original " "folder; ADAM stores only the path and detected entry points." ) hint.setProperty("muted", True) hint.setWordWrap(True) folders_layout.addWidget(hint, 1, 0, 1, 2) for index, definition in enumerate(self.tool_folders.definitions.values()): column = index % 2 row = 2 + index // 2 folders_layout.addWidget( self._build_folder_field(definition.tool_id, definition.name), row, column, ) root.addWidget(folders_card) external_card = _card() external_layout = QVBoxLayout(external_card) external_layout.setContentsMargins(18, 15, 18, 15) external_header = QHBoxLayout() external_header.addWidget(_card_title("EXTERNAL TOOLS")) external_header.addStretch() add_external = QPushButton("Add external tool…") add_external.setProperty("primary", True) add_external.clicked.connect(self._open_external_tool) external_header.addWidget(add_external) external_layout.addLayout(external_header) external_hint = QLabel( "Connect Python training programs without changing ADAM's code. ADAM statically " "reviews the selected entry script, reports a 1–10 rating, and keeps every run approval-gated." ) external_hint.setWordWrap(True) external_hint.setProperty("muted", True) external_layout.addWidget(external_hint) self.external_tools_status = QLabel() self.external_tools_status.setWordWrap(True) external_layout.addWidget(self.external_tools_status) root.addWidget(external_card) self._refresh_external_tools() save = QPushButton("Save settings") save.setProperty("primary", True) save.clicked.connect(self.save) root.addWidget(save, 0, Qt.AlignRight) QTimer.singleShot(0, self.scan_tool_folders) def _open_external_tool(self) -> None: dialog = ExternalToolDialog(self.config.root, self) dialog.connector_saved.connect(self._external_tool_saved) dialog.exec() def _external_tool_saved(self) -> None: self._refresh_external_tools() self.saved.emit() def _refresh_external_tools(self) -> None: tools = ExternalToolStore(self.config.root).load() if not tools: self.external_tools_status.setText("No external tools registered yet.") return summaries = [] for tool in tools: analysis = tool.get("analysis", {}) score = analysis.get("score", "?") if isinstance(analysis, dict) else "?" summaries.append(f"{tool.get('name', 'Unnamed tool')} · {score}/10 · confirmation required") self.external_tools_status.setText("\n".join(summaries)) def save(self) -> None: folder_values = { tool_id: edit.text().strip() for tool_id, edit in self.folder_edits.items() } self.config.update( { "provider": self.provider.currentData(), "ollama_url": self.ollama_url.text().strip(), "ollama_model": self.ollama_model.text().strip(), "ollama_chat_max_tokens": self.ollama_chat_max_tokens.value(), "ollama_chat_response_length": self.ollama_chat_response_length.currentData(), "ollama_proposed_actions": self.ollama_proposed_actions.isChecked(), "web_search_enabled": self.web_search_enabled.isChecked(), "web_link_reading_enabled": self.web_link_reading_enabled.isChecked(), "ask_before_long_tasks": self.long_tasks.isChecked(), "trusted_dataset_ddpm_automation": self.trusted_automation.isChecked(), "desktop_notifications": self.desktop_notifications.isChecked(), "sound_notifications": self.sound_notifications.isChecked(), "max_dataset_images_without_confirmation": self.dataset_threshold.value(), } ) self.tool_folders.update(folder_values) self.scan_tool_folders() self.saved.emit() self.test_status.setText("Settings saved") self.test_status.setStyleSheet(f"color: {COLORS['green']};") def test_ollama(self) -> None: self.test_status.setText("Checking…") client = OllamaClient( self.ollama_url.text().strip(), self.ollama_model.text().strip(), ) models = client.list_models(timeout=2.0) configured_model = self.ollama_model.text().strip() if configured_model in models: self.test_status.setText(f"Ready · {configured_model} is installed") self.test_status.setStyleSheet(f"color: {COLORS['green']};") elif models: self.test_status.setText( f"Model not installed · available: {', '.join(models[:3])}" ) self.test_status.setStyleSheet(f"color: {COLORS['orange']};") else: self.test_status.setText( "Ollama service is not reachable · safe planner will be used" ) self.test_status.setStyleSheet(f"color: {COLORS['orange']};") def _build_folder_field(self, tool_id: str, name: str) -> QFrame: field = QFrame() field.setProperty("innerCard", True) layout = QVBoxLayout(field) layout.setContentsMargins(10, 8, 10, 8) layout.setSpacing(5) name_label = QLabel(name) name_label.setStyleSheet("font-size: 11px; font-weight: 650;") row = QHBoxLayout() edit = QLineEdit(self.tool_folders.get(tool_id)) edit.setPlaceholderText("Choose the program folder…") edit.setToolTip("The existing program is not copied or modified.") browse = QPushButton("Browse") browse.setFixedWidth(72) browse.clicked.connect( lambda _checked=False, key=tool_id: self._browse_folder(key) ) row.addWidget(edit, 1) row.addWidget(browse) status = QLabel("Not scanned") status.setProperty("muted", True) status.setStyleSheet("font-size: 10px;") self.folder_edits[tool_id] = edit self.folder_statuses[tool_id] = status layout.addWidget(name_label) layout.addLayout(row) layout.addWidget(status) return field def _browse_folder(self, tool_id: str) -> None: current = self.folder_edits[tool_id].text().strip() selected = QFileDialog.getExistingDirectory( self, f"Choose {self.tool_folders.definitions[tool_id].name} folder", current or str(Path.home()), ) if selected: self.folder_edits[tool_id].setText(selected) self.tool_folders.set(tool_id, selected) self._show_folder_status(self.tool_folders.scan(tool_id)) self.saved.emit() def scan_tool_folders(self) -> None: self.tool_folders.update( { tool_id: edit.text().strip() for tool_id, edit in self.folder_edits.items() } ) for status in self.tool_folders.scan_all().values(): self._show_folder_status(status) def refresh_tool_folders(self) -> None: for tool_id, edit in self.folder_edits.items(): edit.setText(self.tool_folders.get(tool_id)) self.scan_tool_folders() def _show_folder_status(self, status: ToolFolderStatus) -> None: label = self.folder_statuses.get(status.tool_id) if not label: return label.setText(status.message) color = ( COLORS["green"] if status.valid else COLORS["red"] if status.path else COLORS["muted"] ) label.setStyleSheet(f"font-size: 10px; color: {color};") class MainWindow(QMainWindow): PAGE_COMMAND = 0 PAGE_CHAT_HISTORY = 1 PAGE_STUDIO = 2 PAGE_DATASET_LAB = 3 PAGE_EXPERIMENTS = 4 PAGE_GENERATIONS = 5 PAGE_SHOWCASE = 6 PAGE_JOBS = 7 PAGE_TOOLS = 8 PAGE_SYSTEM = 9 PAGE_REMOTE = 10 PAGE_SETTINGS = 11 PAGE_VIDEO_LORA = 12 PAGE_OASIS_PLAYER = 13 PAGE_MODEL_INTELLIGENCE = 14 def __init__( self, root_path: Path, planner: Planner, registry: ToolRegistry, jobs: JobManager, config: ConfigManager, monitor: SystemMonitor, tool_folders: ToolFolderManager, ) -> None: super().__init__() self.root_path = root_path self.jobs = jobs self.config = config self.monitor = monitor self.remote_service = RemoteAccessService(config, jobs, monitor, planner) self.setWindowTitle("ADAM — AI Development and Automation Manager") self.resize(1480, 900) self.setMinimumSize(1120, 760) self.setStyleSheet(APP_STYLESHEET) self.tray_icon: QSystemTrayIcon | None = None logo_path = self.root_path / "assets" / "adam_atom.png" if logo_path.exists(): self.setWindowIcon(QIcon(str(logo_path))) if QSystemTrayIcon.isSystemTrayAvailable() and logo_path.exists(): self.tray_icon = QSystemTrayIcon(QIcon(str(logo_path)), self) self.tray_icon.setToolTip("ADAM · AI Workflow Manager") self.tray_icon.show() root = QWidget() root.setObjectName("Root") root_layout = QHBoxLayout(root) root_layout.setContentsMargins(0, 0, 0, 0) root_layout.setSpacing(0) root_layout.addWidget(self._build_sidebar()) content = QWidget() content_layout = QVBoxLayout(content) content_layout.setContentsMargins(0, 0, 0, 0) content_layout.setSpacing(0) self.stack = QStackedWidget() self.command_page = CommandCenterPage( planner, jobs, config, tool_folders, root_path, self.remote_service, ) self.command_scroll = QScrollArea() self.command_scroll.setWidgetResizable(True) self.command_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.command_scroll.setFrameShape(QFrame.NoFrame) self.command_scroll.setWidget(self.command_page) self.jobs_page = JobsPage(jobs) self.studio_page = StudioPage(root_path, jobs, jobs.assets, config) self.dataset_lab_page = DatasetLabPage(root_path) self.experiment_page = ExperimentTrackerPage(jobs.experiments) self.generations_page = GenerationsPage( root_path, registry, jobs, jobs.assets, config ) self.showcase_page = ShowcasePage( root_path, registry, jobs, jobs.assets, config ) self.video_lora_page = VideoLoraPage(root_path, registry, jobs, jobs.assets, config) self.video_lora_page.open_jobs_requested.connect(self._open_video_jobs) self.oasis_player_page = OasisPlayerPage(root_path, jobs.assets, config) self.model_intelligence_page = ModelIntelligencePage(root_path, jobs.experiments) self.tools_page = ToolsPage(registry, tool_folders) self.system_page = SystemPage() self.remote_page = RemoteAccessPage(self.remote_service) self.settings_page = SettingsPage(config, tool_folders) self.chat_history_page = ChatHistoryPage(self.command_page.history_store) for page in ( self.command_scroll, self.chat_history_page, self.studio_page, self.dataset_lab_page, self.experiment_page, self.generations_page, self.showcase_page, self.jobs_page, self.tools_page, self.system_page, self.remote_page, self.settings_page, self.video_lora_page, self.oasis_player_page, self.model_intelligence_page, ): self.stack.addWidget(page) content_layout.addWidget(self.stack, 1) content_layout.addWidget(self._build_status_bar()) root_layout.addWidget(content, 1) self.setCentralWidget(root) self.settings_page.saved.connect(self.command_page.refresh_provider_badge) self.settings_page.saved.connect(self.tools_page.reload) self.tools_page.setup_requested.connect(lambda: self._switch_page(self.PAGE_SETTINGS)) self.command_page.tool_folders_changed.connect( self.settings_page.refresh_tool_folders ) self.command_page.tool_folders_changed.connect(self.tools_page.reload) self.command_page.open_jobs_requested.connect(lambda: self._switch_page(self.PAGE_JOBS)) self.command_page.open_dataset_lab_requested.connect(lambda: self._switch_page(self.PAGE_DATASET_LAB)) self.command_page.open_experiments_requested.connect(lambda: self._switch_page(self.PAGE_EXPERIMENTS)) self.command_page.open_remote_requested.connect(lambda: self._switch_page(self.PAGE_REMOTE)) self.command_page.history_changed.connect(self.chat_history_page.refresh) self.chat_history_page.open_requested.connect(self._open_saved_conversation) self.experiment_page.clone_requested.connect(self._clone_experiment_request) self.model_intelligence_page.plan_requested.connect(self._plan_from_intelligence) self.model_intelligence_page.open_experiments_requested.connect( lambda: self._switch_page(self.PAGE_EXPERIMENTS) ) self.jobs.active_changed.connect(self.system_page.set_active_job) self.jobs.job_updated.connect(self._update_system_job) self.experiment_refresh_timer = QTimer(self) self.experiment_refresh_timer.setInterval(1000) self.experiment_refresh_timer.setSingleShot(True) self.experiment_refresh_timer.timeout.connect(self._refresh_visible_experiments) self.jobs.job_updated.connect(self._schedule_experiment_refresh) self.jobs.notification.connect(self._show_notification) self.studio_page.plan_requested.connect(self._plan_from_studio) self._page_refresh_timer = QTimer(self) self._page_refresh_timer.setSingleShot(True) self._page_refresh_timer.setInterval(30) self._page_refresh_timer.timeout.connect(self._refresh_current_page) self._switch_page(self.PAGE_COMMAND) self.monitor_timer = QTimer(self) self.monitor_timer.timeout.connect(self._refresh_monitor) self.monitor_timer.start(1500) self._refresh_monitor() if self.remote_service.settings().get("enabled"): QTimer.singleShot(500, self._start_saved_remote_access) if any(job.status == JobStatus.INTERRUPTED for job in self.jobs.jobs): QTimer.singleShot(350, self._offer_recovery) def _build_sidebar(self) -> QFrame: sidebar = QFrame() sidebar.setObjectName("Sidebar") sidebar.setFixedWidth(230) outer = QVBoxLayout(sidebar) outer.setContentsMargins(0, 0, 0, 0) scroll = QScrollArea() scroll.setObjectName("SidebarScroll") scroll.setWidgetResizable(True) scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) content = QWidget() layout = QVBoxLayout(content) layout.setSizeConstraint(QVBoxLayout.SetMinimumSize) scroll.setWidget(content) outer.addWidget(scroll) layout.setContentsMargins(0, 20, 0, 16) layout.setSpacing(3) brand = QWidget() brand_layout = QHBoxLayout(brand) brand_layout.setContentsMargins(0, 0, 0, 18) brand_layout.setSpacing(7) logo = QLabel() pixmap = QPixmap(str(self.root_path / "assets" / "adam_atom.png")) if not pixmap.isNull(): logo.setPixmap(pixmap) logo.setScaledContents(True) logo.setFixedSize(66, 66) logo.setAlignment(Qt.AlignCenter) names = QVBoxLayout() names.setSpacing(0) app_name = QLabel("ADAM") app_name.setObjectName("AppName") subtitle = QLabel("AI WORKFLOW\nMANAGER") subtitle.setStyleSheet( f"color: {COLORS['blue_2']}; font-size: 9px; font-weight: 700; " "letter-spacing: 1px;" ) names.addWidget(app_name) names.addWidget(subtitle) brand_layout.addWidget(logo) brand_layout.addLayout(names) layout.addWidget(brand) section = QLabel(" WORKSPACE") section.setStyleSheet( f"color: #557083; font-size: 9px; font-weight: 700; " "letter-spacing: 1.5px; padding: 8px 16px;" ) layout.addWidget(section) nav_items = [ ("COMMAND CENTER", self.PAGE_COMMAND), ("CHAT HISTORY", self.PAGE_CHAT_HISTORY), ("TRAINING STUDIO", self.PAGE_STUDIO), ("DATASET LAB", self.PAGE_DATASET_LAB), ("EXPERIMENT TRACKER", self.PAGE_EXPERIMENTS), ("GENERATIONS", self.PAGE_GENERATIONS), ("SHOWCASE VIDEO", self.PAGE_SHOWCASE), ("VIDEO LORA", self.PAGE_VIDEO_LORA), ("OASIS PLAYER", self.PAGE_OASIS_PLAYER), ("MODEL INTELLIGENCE", self.PAGE_MODEL_INTELLIGENCE), ("JOBS / HISTORY", self.PAGE_JOBS), ("TOOL REGISTRY", self.PAGE_TOOLS), ("SYSTEM MONITOR", self.PAGE_SYSTEM), ("REMOTE ACCESS", self.PAGE_REMOTE), ("SETTINGS", self.PAGE_SETTINGS), ] self.nav_buttons: list[QPushButton] = [] for text, index in nav_items: button = QPushButton(text) button.setProperty("nav", True) button.setProperty("pageIndex", index) button.clicked.connect(lambda _checked=False, value=index: self._switch_page(value)) self.nav_buttons.append(button) layout.addWidget(button) quick_title = QLabel(" QUICK ACCESS") quick_title.setStyleSheet( f"color: #557083; font-size: 9px; font-weight: 700; " "letter-spacing: 1.5px; padding: 10px 16px 3px 16px;" ) layout.addWidget(quick_title) for icon, title, action in ( ("▦", "Create Dataset", "dataset"), ("◉", "LoRA Trainer", "lora"), ("◎", "DDPM Trainer", "ddpm"), ("⌁", "Flow Matching", "flow"), ("▤", "Dataset Lab", "dataset_lab"), ("▥", "Compare Runs", "experiments"), ("▧", "Image Generator", "generations"), ("▣", "Video Generator", "video"), ): button = QPushButton(f"{icon} {title}") button.setProperty("quick", True) button.clicked.connect( lambda _checked=False, value=action: self._quick_access(value) ) layout.addWidget(button) layout.addStretch(1) safety = QFrame() safety.setProperty("innerCard", True) safety_layout = QVBoxLayout(safety) safety_layout.setContentsMargins(12, 11, 12, 11) safety_layout.setSpacing(4) safe_title = QLabel("● APPROVAL SETTINGS") safe_title.setStyleSheet( f"color: {COLORS['green']}; font-size: 10px; font-weight: 700;" ) safe_body = QLabel() self.safety_summary = safe_body safe_body.setWordWrap(True) safe_body.setProperty("muted", True) safe_body.setStyleSheet("font-size: 11px;") safety_layout.addWidget(safe_title) safety_layout.addWidget(safe_body) layout.addWidget(safety, 0) version = QLabel("ADAM 0.1.0 · LOCAL") version.setAlignment(Qt.AlignCenter) version.setStyleSheet("color: #40596a; font-size: 9px; padding-top: 10px;") layout.addWidget(version) layout.setContentsMargins(12, 20, 12, 16) return sidebar def _schedule_experiment_refresh(self, _job: Job) -> None: if ( (self.experiment_page.isVisible() or self.model_intelligence_page.isVisible()) and not self.experiment_refresh_timer.isActive() ): self.experiment_refresh_timer.start() def _refresh_visible_experiments(self) -> None: if self.experiment_page.isVisible(): self.experiment_page.refresh() if self.model_intelligence_page.isVisible(): self.model_intelligence_page.refresh_if_stale() def _build_status_bar(self) -> QFrame: bar = QFrame() bar.setObjectName("TopBar") bar.setFixedHeight(34) layout = QHBoxLayout(bar) layout.setContentsMargins(16, 0, 18, 0) layout.setSpacing(18) self.bottom_status = QLabel("● READY") self.bottom_status.setStyleSheet( f"color: {COLORS['green']}; font-size: 10px; font-weight: 700;" ) self.bottom_cpu = QLabel("CPU —") self.bottom_ram = QLabel("RAM —") self.bottom_gpu = QLabel("GPU —") self.bottom_vram = QLabel("VRAM —") for label in ( self.bottom_cpu, self.bottom_ram, self.bottom_gpu, self.bottom_vram, ): label.setProperty("muted", True) label.setStyleSheet("font-size: 10px;") layout.addWidget(self.bottom_status) layout.addStretch() layout.addWidget(self.bottom_cpu) layout.addWidget(self.bottom_ram) layout.addWidget(self.bottom_gpu) layout.addWidget(self.bottom_vram) return bar def _switch_page(self, index: int) -> None: if not hasattr(self, "stack"): return self.stack.setCurrentIndex(index) # Paint the selected workspace first, and discard refreshes for tabs # passed over during rapid navigation. self._page_refresh_timer.start() for button in self.nav_buttons: active = button.property("pageIndex") == index if button.property("navActive") != active: button.setProperty("navActive", active) button.style().unpolish(button) button.style().polish(button) def _refresh_current_page(self) -> None: index = self.stack.currentIndex() if index == self.PAGE_STUDIO: self.studio_page.refresh() elif index == self.PAGE_DATASET_LAB: self.dataset_lab_page.folder.setFocus() elif index == self.PAGE_EXPERIMENTS: self.experiment_page.refresh() elif index == self.PAGE_GENERATIONS: self.generations_page.refresh() elif index == self.PAGE_SHOWCASE: self.showcase_page.refresh() elif index == self.PAGE_VIDEO_LORA: self.video_lora_page.refresh() elif index == self.PAGE_OASIS_PLAYER: self.oasis_player_page.refresh() elif index == self.PAGE_MODEL_INTELLIGENCE: self.model_intelligence_page.refresh_if_stale() elif index == self.PAGE_REMOTE: self.remote_page.refresh() elif index == self.PAGE_COMMAND: self.command_page.refresh_remote_access() if index == self.PAGE_CHAT_HISTORY: self.chat_history_page.refresh() def _open_saved_conversation(self, conversation: dict) -> None: self.command_page.open_conversation(conversation) self._switch_page(self.PAGE_COMMAND) def _open_video_jobs(self) -> None: if self.video_lora_page.active_id: self.jobs_page.selected_job_id = self.video_lora_page.active_id self.jobs_page.refresh() self._switch_page(self.PAGE_JOBS) def _clone_experiment_request(self, request: str) -> None: if not request: return self._switch_page(self.PAGE_COMMAND) self.command_page.submit(request) def _plan_from_intelligence(self, request: str) -> None: """Send a coach suggestion through the normal reviewed planning path.""" if not request: return self._switch_page(self.PAGE_COMMAND) self.command_page.submit(request) def _quick_access(self, action: str) -> None: if action == "generations": self._switch_page(self.PAGE_GENERATIONS) return if action == "video": self._switch_page(self.PAGE_SHOWCASE) return if action == "dataset_lab": self._switch_page(self.PAGE_DATASET_LAB) return if action == "experiments": self._switch_page(self.PAGE_EXPERIMENTS) return self._switch_page(self.PAGE_COMMAND) if action == "dataset": self.command_page.submit("Adam, collect a dataset") elif action == "lora": self.command_page.submit("Adam, train a LoRA model") elif action == "ddpm": self.command_page.submit("Adam, train a DDPM model") elif action == "flow": self.command_page.submit("Adam, train a Flow Matching model") def _plan_from_studio(self, request: str) -> None: self._switch_page(self.PAGE_COMMAND) self.command_page.submit(request) def _refresh_monitor(self) -> None: remote = self.remote_service.settings() approval = "Remote auto-approval on" if remote.get("auto_approve_training") else "Remote approval required" local = "Long-task prompts on" if self.config.get("ask_before_long_tasks", True) else "Long-task prompts off" self.safety_summary.setText(f"{local}\n{approval}") snapshot = self.monitor.snapshot() self.jobs.supervise(snapshot) self.system_page.update_snapshot(snapshot) self.command_page.update_snapshot(snapshot) self.bottom_cpu.setText(f"CPU {snapshot.cpu_percent:.0f}%") self.bottom_ram.setText(f"RAM {snapshot.memory_percent:.0f}%") self.bottom_gpu.setText(f"GPU {snapshot.gpu_percent:.0f}%") self.bottom_vram.setText(f"VRAM {snapshot.vram_percent:.0f}%") active = self.jobs.active_job if active: self.bottom_status.setText( f"● {active.status.value.upper()} · {active.plan.project_name}" ) self.bottom_status.setStyleSheet( f"color: {COLORS['blue_2']}; font-size: 10px; font-weight: 700;" ) else: self.bottom_status.setText("● READY") self.bottom_status.setStyleSheet( f"color: {COLORS['green']}; font-size: 10px; font-weight: 700;" ) def _update_system_job(self, job: Job) -> None: if self.jobs.active_job and job.id == self.jobs.active_job.id: self.system_page.set_active_job(job) def _show_notification(self, title: str, message: str) -> None: self.statusBar().showMessage(f"{title}: {message}", 6000) if self.config.get("desktop_notifications") and self.tray_icon: self.tray_icon.showMessage( title, message, QSystemTrayIcon.Information, 6000, ) if self.config.get("sound_notifications"): QApplication.beep() def _start_saved_remote_access(self) -> None: try: self.remote_service.start() self.remote_page.refresh() except OSError as exc: self.remote_page.status.setText(f"Remote access is enabled, but it could not start: {exc}") def _offer_recovery(self) -> None: interrupted = [ job for job in self.jobs.jobs if job.status == JobStatus.INTERRUPTED ] if not interrupted: return choice = QMessageBox.question( self, "Interrupted work found", f"ADAM found {len(interrupted)} job(s) interrupted by a previous " "shutdown. Open Jobs to review logs and retry safely?", QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes, ) if choice == QMessageBox.Yes: self._switch_page(4) def closeEvent(self, event: QCloseEvent) -> None: if self.tray_icon: self.tray_icon.hide() self.remote_service.stop() self.studio_page.shutdown() self.oasis_player_page.shutdown() super().closeEvent(event)