flashstudio 0.0.1__py3-none-any.whl

flashstudio/constants.py

@@ -0,0 +1,245 @@
+"""FlashStudio — Centralized constants. Single source of truth for all magic values."""
+
+import os
+
+# ════════════════════════════════════════
+# FILE EXTENSIONS
+# ════════════════════════════════════════
+
+IMG_EXTENSIONS = (".jpg", ".jpeg", ".png", ".bmp", ".webp")
+IMG_EXTENSIONS_ALL = (".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tiff")
+VIDEO_EXTENSIONS = (".mp4", ".avi", ".mov", ".mkv")
+WEIGHT_EXTENSIONS = (".pt", ".pth", ".onnx", ".engine")
+ARCHIVE_EXTENSIONS = (".zip", ".tar", ".gz", ".tar.gz", ".tgz")
+
+# ════════════════════════════════════════
+# CHECKPOINT FILE NAMES
+# ════════════════════════════════════════
+
+CKPT_BEST_INFERENCE = "model_best_inference.pth"
+CKPT_BEST = "checkpoint_best.pth"
+CKPT_LAST_INFERENCE = "model_last_inference.pth"
+CKPT_LAST = "checkpoint_last.pth"
+CKPT_FINAL_INFERENCE = "model_final_inference.pth"
+CKPT_FINAL_FP16 = "model_final_fp16.pth"
+CKPT_BEST_FP16 = "model_best_fp16.pth"
+
+COMPLETE_MARKERS = (CKPT_FINAL_INFERENCE, CKPT_FINAL_FP16, CKPT_BEST_INFERENCE, CKPT_BEST)
+BEST_WEIGHT_PRIORITY = [CKPT_BEST_INFERENCE, CKPT_BEST, CKPT_FINAL_INFERENCE, CKPT_FINAL_FP16]
+
+TRAINING_LOG_CSV = "training_log.csv"
+
+# ════════════════════════════════════════
+# PATHS
+# ════════════════════════════════════════
+
+# Project root: FlashStudio/ directory (parent of flashstudio/ package)
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PROJECT_ROOT = _PROJECT_ROOT
+
+DEFAULT_SAVE_DIR = os.path.join(_PROJECT_ROOT, "flashstudio_workspaces")
+DEFAULT_DATA_DIR = os.path.join(_PROJECT_ROOT, "data")
+NETWORK_CHECK_URL = "http://images.cocodataset.org"
+NETWORK_CHECK_TIMEOUT = 5
+
+# ════════════════════════════════════════
+# COLORS (for bounding boxes, visualization)
+# ════════════════════════════════════════
+
+BBOX_COLORS_RGB = [
+    (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0),
+    (255, 0, 255), (0, 255, 255), (128, 0, 0), (0, 128, 0),
+]
+
+BBOX_COLORS_HEX = [
+    "#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FFEAA7",
+    "#DDA0DD", "#98D8C8", "#F7DC6F", "#BB8FCE", "#85C1E9",
+]
+
+# Theme colors
+COLOR_PRIMARY = "#7C3AED"
+COLOR_SUCCESS = "#10B981"
+COLOR_WARNING = "#F59E0B"
+COLOR_ERROR = "#EF4444"
+COLOR_TEXT_PRIMARY = "#1A1A2E"
+COLOR_TEXT_SECONDARY = "#6B7280"
+COLOR_TEXT_MUTED = "#9CA3AF"
+COLOR_TEXT_BODY = "#4B5563"
+COLOR_BORDER = "#F0F0F5"
+COLOR_BG_HIGHLIGHT = "#F5F3FF"
+
+# ════════════════════════════════════════
+# INFERENCE DEFAULTS
+# ════════════════════════════════════════
+
+INFER_CONF_THRESHOLD = 0.25
+INFER_NMS_THRESHOLD = 0.45
+INFER_IMG_SIZE = 640
+INFER_NUM_CLASSES = 80
+INFER_MAX_FRAMES = 300
+INFER_STREAM_DURATION = 60
+INFER_FRAME_SKIP = 1
+INFER_DISPLAY_WIDTH = 650
+INFER_DEFAULT_RESOLUTION = (640, 480)
+
+# ════════════════════════════════════════
+# EXPORT DEFAULTS
+# ════════════════════════════════════════
+
+EXPORT_IMG_SIZES = [320, 416, 640]
+EXPORT_OPSET_MIN = 11
+EXPORT_OPSET_MAX = 18
+EXPORT_OPSET_DEFAULT = 13
+EXPORT_FORMATS = ["ONNX", "TorchScript"]
+
+EXPORT_WEIGHT_MAP = {
+    "Best (inference)": [CKPT_BEST_INFERENCE, CKPT_BEST],
+    "Best (FP16)": [CKPT_BEST_FP16],
+    "Last": [CKPT_LAST_INFERENCE, CKPT_LAST],
+}
+
+# ════════════════════════════════════════
+# TRAINING DEFAULTS (mirrors DEFAULTS in utils)
+# ════════════════════════════════════════
+
+TRAIN_EPOCHS = 100
+TRAIN_BATCH_SIZE = 16
+TRAIN_LR = 1e-3
+TRAIN_IMG_SIZE = 320
+TRAIN_WEIGHT_DECAY = 0.05
+TRAIN_WARMUP_EPOCHS = 3
+TRAIN_PATIENCE = 50
+TRAIN_NUM_WORKERS = 4
+TRAIN_GRAD_ACCUM = 1
+TRAIN_VAL_INTERVAL = 5
+TRAIN_LR_FINAL_RATIO = 0.1
+
+BATCH_SIZE_OPTIONS = [2, 4, 8, 16, 32, 64, 128]
+IMG_SIZE_OPTIONS = [320, 416, 640]
+
+AUTOREFRESH_INTERVAL_MS = 5000
+MAX_DISPLAY_RUNS = 8
+VIS_QUEUE_SIZE = 3
+
+VIS_DIR_NAMES = ("visualizations", "plots", "vis")
+VIS_SKIP_FILE = "latest_visualization.jpg"
+GT_VERIFICATION_DIR = "gt_verification"
+GT_REPORT_FILE = "verification_report.json"
+GT_SUMMARY_FILE = "verification_summary.txt"
+TRAINING_LOG_GLOB = "train_*.log"
+ONNX_MODEL_FILE = "model.onnx"
+ONNX_DATA_FILE = "model.onnx.data"
+CONFIG_YAML_FILE = "config.yaml"
+RESULTS_JSON_FILE = "results.json"
+
+# ════════════════════════════════════════
+# MODEL ARCHITECTURE
+# ════════════════════════════════════════
+
+DEFAULT_MODEL_ARCH = "FlashDet-Pico"
+DEFAULT_ARCH_FAMILY = "FlashDet (recommended)"
+MODEL_SIZE_DEFAULT = "n"
+
+ARCH_FAMILIES = ["FlashDet (recommended)", "YOLOv8", "YOLOv9", "YOLOv10", "YOLOv11", "YOLOX"]
+OPTIMIZERS = ["AdamW", "SGD", "MuSGD"]
+DEFAULT_OPTIMIZER = "AdamW"
+LORA_VARIANTS = ["standard", "dora", "lora_plus", "adalora", "ortho", "lora_fa"]
+LORA_RANK_DEFAULT = 8
+LORA_ALPHA_DEFAULT = 16.0
+LORA_DROPOUT_DEFAULT = 0.05
+LORA_TARGETS_DEFAULT = ["backbone", "fpn"]
+QLORA_DTYPE_DEFAULT = "int8"
+CHUNKED_LOSS_CHUNK_SIZE = 1024
+DEFAULT_FINETUNE_STRATEGY = "Full fine-tune"
+DEFAULT_PRETRAIN_OPTION = "COCO pretrained"
+
+FLASHDET_MODELS = {
+    "FlashDet-Pico": {"size": "p", "params": "~298K", "speed": "Ultra-fast", "backbone": "LiteBackbone(0.5x)", "neck": "PicoNeck(64ch)", "head": "E2EDualHead", "for": "Edge/Mobile"},
+    "FlashDet-Nano": {"size": "n", "params": "~790K", "speed": "Very fast", "backbone": "FlashBB(stem=32)", "neck": "PicoNeck(96ch)", "head": "E2EDualHead", "for": "IoT"},
+    "FlashDet-Small": {"size": "s", "params": "~1.8M", "speed": "Fast", "backbone": "FlashBB(stem=48)", "neck": "PicoNeck(128ch)", "head": "E2EDualHead", "for": "General"},
+    "FlashDet-Medium": {"size": "m", "params": "~3.6M", "speed": "Balanced", "backbone": "FlashBB(stem=64)", "neck": "PicoNeck(192ch)", "head": "E2EDualHead", "for": "Accuracy"},
+    "FlashDet-Large": {"size": "l", "params": "~5.8M", "speed": "Accurate", "backbone": "FlashBB(stem=80)", "neck": "PicoNeck(256ch)", "head": "E2EDualHead", "for": "Accuracy"},
+    "FlashDet-X": {"size": "x", "params": "~9.0M", "speed": "Max acc", "backbone": "FlashBB(stem=96)", "neck": "PicoNeck(320ch)", "head": "E2EDualHead", "for": "Server"},
+}
+
+# ════════════════════════════════════════
+# ZONE DRAWING DEFAULTS
+# ════════════════════════════════════════
+
+ZONE_MAX_X = 1920
+ZONE_MAX_Y = 1080
+ZONE_DEFAULT_LINE = [(100, 240), (540, 240)]
+ZONE_DEFAULT_POLYGON = "100,100\n500,100\n500,400\n100,400"
+
+# ════════════════════════════════════════
+# FONT
+# ════════════════════════════════════════
+
+def _resolve_font_path():
+    """Find a usable TrueType font across platforms, with env override."""
+    env = os.environ.get("FLASHSTUDIO_FONT_PATH", "")
+    if env and os.path.isfile(env):
+        return env
+    candidates = [
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",       # Debian/Ubuntu
+        "/usr/share/fonts/dejavu-sans-fonts/DejaVuSans-Bold.ttf",      # Fedora/RHEL
+        "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",                    # Arch
+        "/System/Library/Fonts/Helvetica.ttc",                         # macOS
+        "C:\\Windows\\Fonts\\arial.ttf",                               # Windows
+    ]
+    for c in candidates:
+        if os.path.isfile(c):
+            return c
+    return ""
+
+FONT_PATH = _resolve_font_path()
+FONT_PATH_LINUX = FONT_PATH  # backward compat alias
+FONT_SIZE_DEFAULT = 14
+
+# ════════════════════════════════════════
+# UI LIMITS
+# ════════════════════════════════════════
+
+MAX_PREVIEW_COLS = 4
+MAX_PREVIEW_IMAGES = 6
+MAX_WEIGHTS_DISPLAY = 4
+SIDEBAR_LABEL_TRUNCATE = 20
+GPU_NAME_TRUNCATE = 18
+DATASET_NAME_TRUNCATE = 18
+
+# ════════════════════════════════════════
+# COCO CLASSES (standard 80-class COCO)
+# ════════════════════════════════════════
+
+COCO_CLASSES = [
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck",
+    "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",
+    "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra",
+    "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
+    "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove",
+    "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup",
+    "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange",
+    "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
+    "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse",
+    "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",
+    "refrigerator", "book", "clock", "vase", "scissors", "teddy bear",
+    "hair drier", "toothbrush",
+]
+
+# ════════════════════════════════════════
+# SIZE FORMATTING THRESHOLDS
+# ════════════════════════════════════════
+
+SIZE_GB = 1_073_741_824
+SIZE_MB = 1_048_576
+SIZE_KB = 1024
+
+
+def format_bytes(total_bytes: int) -> str:
+    """Format byte count to human-readable string."""
+    if total_bytes > SIZE_GB:
+        return f"{total_bytes / SIZE_GB:.1f} GB"
+    elif total_bytes > SIZE_MB:
+        return f"{total_bytes / SIZE_MB:.0f} MB"
+    else:
+        return f"{total_bytes / SIZE_KB:.0f} KB"

flashstudio/core/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio core package."""
+
+from flashstudio.core.constants import *  # noqa: F401,F403

flashstudio/core/constants.py

@@ -0,0 +1,3 @@
+"""Re-export all constants from the canonical location."""
+
+from flashstudio.constants import *  # noqa: F401,F403

flashstudio/launcher.py

@@ -0,0 +1,288 @@
+"""Launch FlashStudio UI — works locally and inside Google Colab."""
+
+import subprocess
+import sys
+import os
+import re
+import time as _time
+from pathlib import Path
+
+from flashstudio.utils.device import is_colab
+
+_STREAMLIT_CONFIG = """\
+[theme]
+primaryColor = "#7C3AED"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F8F9FB"
+textColor = "#1A1A2E"
+font = "sans serif"
+
+[server]
+headless = true
+port = 8501
+enableCORS = false
+enableXsrfProtection = false
+
+[client]
+showSidebarNavigation = false
+
+[browser]
+gatherUsageStats = false
+"""
+
+
+def _get_app_path() -> str:
+    return str(Path(__file__).parent / "app.py")
+
+
+def _ensure_streamlit_config():
+    """Write the default Streamlit config if one doesn't already exist."""
+    config_dir = Path.home() / ".streamlit"
+    config_file = config_dir / "config.toml"
+    if config_file.exists():
+        return
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_file.write_text(_STREAMLIT_CONFIG)
+
+
+def launch(port: int = 8501, share: bool = True, ngrok_token: str | None = None):
+    """Launch FlashStudio Streamlit app.
+
+    Args:
+        port: Port to run the Streamlit server on.
+        share: If True and running in Colab, creates a public tunnel
+               (works on mobile too).
+        ngrok_token: Optional ngrok auth token. If not provided, uses
+                     NGROK_TOKEN env var.
+    """
+    _ensure_streamlit_config()
+    app_path = _get_app_path()
+
+    if is_colab():
+        return _launch_colab(app_path, port, share, ngrok_token)
+    else:
+        _launch_local(app_path, port)
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Tunnel helpers
+# ---------------------------------------------------------------------------
+
+def _start_cloudflared_tunnel(port: int) -> str | None:
+    """Start a free Cloudflare tunnel (no sign-up required).
+
+    Returns the public https URL or None on failure.
+    """
+    binary = "/usr/local/bin/cloudflared"
+    if not os.path.isfile(binary):
+        try:
+            subprocess.check_call(
+                ["wget", "-q",
+                 "https://github.com/cloudflare/cloudflared/releases/latest"
+                 "/download/cloudflared-linux-amd64",
+                 "-O", binary],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+            os.chmod(binary, 0o755)
+        except Exception:
+            return None
+
+    tunnel_proc = subprocess.Popen(
+        [binary, "tunnel", "--url", f"http://localhost:{port}"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    url_re = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
+    deadline = _time.monotonic() + 20
+    while _time.monotonic() < deadline:
+        line = tunnel_proc.stderr.readline().decode("utf-8", errors="replace")
+        if not line:
+            if tunnel_proc.poll() is not None:
+                return None
+            _time.sleep(0.2)
+            continue
+        match = url_re.search(line)
+        if match:
+            return match.group(0)
+
+    return None
+
+
+def _start_ngrok_tunnel(port: int, ngrok_token: str) -> str | None:
+    """Start an ngrok tunnel. Requires an auth token."""
+    try:
+        from pyngrok import ngrok, conf
+    except ImportError:
+        try:
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", "-q", "pyngrok"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+            from pyngrok import ngrok, conf
+        except Exception:
+            return None
+    try:
+        conf.get_default().auth_token = ngrok_token
+        return str(ngrok.connect(port, "http"))
+    except Exception:
+        return None
+
+
+def _get_colab_proxy_url(port: int) -> str | None:
+    """Get Colab's built-in proxy URL (only works in the same browser session)."""
+    try:
+        from google.colab.output import eval_js
+        result = eval_js(f"google.colab.kernel.proxyPort({port})")
+        if result and str(result).startswith("http"):
+            return str(result)
+    except Exception:
+        pass
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Colab launcher
+# ---------------------------------------------------------------------------
+
+def _launch_colab(app_path: str, port: int, share: bool, ngrok_token: str | None):
+    """Launch in Google Colab with a public URL that works on any device."""
+    import urllib.request
+
+    print("  Starting FlashStudio...", end="", flush=True)
+
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "streamlit", "run", app_path,
+         "--server.port", str(port),
+         "--server.headless", "true",
+         "--server.enableCORS", "false",
+         "--server.enableXsrfProtection", "false"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    ready = False
+    for _ in range(30):
+        _time.sleep(1)
+        if proc.poll() is not None:
+            _, stderr = proc.communicate()
+            err_msg = (stderr.decode("utf-8", errors="replace")[-500:]
+                       if stderr else "Unknown error")
+            print(f"\n\n  FlashStudio failed to start:\n  {err_msg}")
+            return proc
+        try:
+            urllib.request.urlopen(
+                f"http://localhost:{port}/_stcore/health", timeout=2)
+            ready = True
+            break
+        except Exception:
+            print(".", end="", flush=True)
+
+    if ready:
+        print(" Ready!")
+    else:
+        print(" (still loading, URL may take a moment)")
+
+    # --- Obtain a public URL ---
+    # Priority: cloudflared (free, works everywhere including mobile)
+    #         > ngrok (needs token) > Colab proxy (desktop-only)
+    public_url = None
+    tunnel_type = None
+
+    if share:
+        # 1) Free Cloudflare tunnel — works on mobile, no sign-up
+        print("  Setting up public URL (works on mobile)...", end="", flush=True)
+        public_url = _start_cloudflared_tunnel(port)
+        if public_url:
+            tunnel_type = "cloudflared"
+            print(" Done!")
+
+        # 2) ngrok — if a token is available
+        if not public_url:
+            token = ngrok_token or os.environ.get("NGROK_TOKEN", "")
+            if token:
+                public_url = _start_ngrok_tunnel(port, token)
+                if public_url:
+                    tunnel_type = "ngrok"
+                    print(" Done!")
+
+        if not public_url:
+            print(" Skipped (using Colab proxy)")
+
+    # 3) Colab's built-in proxy (fallback — desktop browser only)
+    colab_proxy_url = _get_colab_proxy_url(port)
+    if not public_url:
+        public_url = colab_proxy_url
+
+    # --- Display results ---
+    print(f"\n{'=' * 60}")
+    print("  FlashStudio is running!")
+    if public_url:
+        print(f"  Open: {public_url}")
+        if tunnel_type:
+            print(f"  (works on mobile & any device)")
+        else:
+            print(f"  ⚠ This URL only works in this browser.")
+            print(f"    On mobile? Re-run with: launch(share=True)")
+    else:
+        print(f"  Port: {port}")
+        print("")
+        print("  Run this in a new cell to get the URL:")
+        print(f"    from google.colab.output import eval_js")
+        print(f"    print(eval_js('google.colab.kernel.proxyPort({port})'))")
+    print(f"{'=' * 60}\n")
+
+    # Show clickable link
+    if public_url:
+        try:
+            from IPython.display import display, HTML
+            mobile_badge = ""
+            if tunnel_type:
+                mobile_badge = (
+                    '<span style="display:inline-block;font-size:11px;'
+                    'padding:2px 8px;background:#10B981;color:white;'
+                    'border-radius:4px;margin-left:8px;vertical-align:middle;">'
+                    'Mobile Ready</span>'
+                )
+            display(HTML(
+                f'<div style="margin:8px 0;">'
+                f'<a href="{public_url}" target="_blank" '
+                f'style="display:inline-block;font-size:16px;padding:10px 24px;'
+                f'background:#7C3AED;color:white;border-radius:8px;'
+                f'text-decoration:none;font-weight:600;">'
+                f'Open FlashStudio</a>{mobile_badge}</div>'
+            ))
+        except Exception:
+            pass
+
+    # Embed Streamlit directly in the Colab cell output
+    try:
+        from google.colab import output
+        output.serve_kernel_port_as_iframe(port, height=800)
+    except Exception:
+        if not public_url:
+            try:
+                from IPython.display import display, HTML
+                display(HTML(
+                    f'<div style="padding:12px;background:#FEF3C7;'
+                    f'border-radius:8px;margin:8px 0;font-size:14px;">'
+                    f'Run in a <b>new cell</b>:<br>'
+                    f'<code style="background:#F3F4F6;padding:4px 8px;'
+                    f'border-radius:4px;">'
+                    f'from google.colab import output; '
+                    f'output.serve_kernel_port_as_iframe({port}, height=800)'
+                    f'</code></div>'
+                ))
+            except Exception:
+                pass
+
+    return proc
+
+
+def _launch_local(app_path: str, port: int):
+    """Launch locally with streamlit."""
+    subprocess.run(
+        [sys.executable, "-m", "streamlit", "run", app_path,
+         "--server.port", str(port)],
+    )

flashstudio/pages/__init__.py

@@ -0,0 +1,8 @@
+"""FlashStudio pages package — each page is a sub-package."""
+
+from flashstudio.pages.dashboard.page import render_dashboard  # noqa: F401
+from flashstudio.pages.data.page import render_data_page  # noqa: F401
+from flashstudio.pages.model.page import render_model_page  # noqa: F401
+from flashstudio.pages.training.page import render_training_page  # noqa: F401
+from flashstudio.pages.export.page import render_export_page  # noqa: F401
+from flashstudio.pages.inference.page import render_inference_page  # noqa: F401

flashstudio/pages/dashboard/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio — Dashboard page package."""
+
+from flashstudio.pages.dashboard.page import render_dashboard  # noqa: F401

flashstudio/pages/dashboard/_common.py

@@ -0,0 +1,10 @@
+"""Shared imports for the dashboard page."""
+
+from flashstudio.constants import (  # noqa: F401
+    IMG_EXTENSIONS, DEFAULT_SAVE_DIR, MAX_DISPLAY_RUNS,
+    CKPT_BEST, CKPT_BEST_INFERENCE, CKPT_FINAL_INFERENCE,
+    CKPT_FINAL_FP16, TRAINING_LOG_CSV,
+    COLOR_SUCCESS, COLOR_TEXT_PRIMARY, COLOR_TEXT_SECONDARY,
+    COLOR_TEXT_MUTED, COLOR_BORDER, COLOR_BG_HIGHLIGHT,
+    GPU_NAME_TRUNCATE, DATASET_NAME_TRUNCATE,
+)

flashstudio/pages/dashboard/overview/__init__.py

@@ -0,0 +1,3 @@
+"""Dashboard overview sub-package."""
+
+from flashstudio.pages.dashboard.overview.tab import render_overview  # noqa: F401

flashstudio/pages/dashboard/overview/metrics.py

@@ -0,0 +1,33 @@
+"""Dashboard — key metrics section (GPU, dataset, model, best mAP)."""
+
+import os
+import streamlit as st
+from flashstudio.pages.dashboard._common import (
+    IMG_EXTENSIONS,
+    GPU_NAME_TRUNCATE, DATASET_NAME_TRUNCATE,
+)
+
+
+def render_metrics(gpu, stats):
+    m1, m2, m3, m4 = st.columns(4)
+    with m1:
+        gpu_name = gpu["name"][:GPU_NAME_TRUNCATE] if gpu["available"] else "CPU only"
+        vram = f"{gpu['memory_total']:.0f} GB" if gpu["available"] else "\u2014"
+        st.metric("GPU", gpu_name, delta=f"VRAM: {vram}", delta_color="off")
+    with m2:
+        ds_name = (st.session_state.get("dataset_name") or "Not loaded")[:DATASET_NAME_TRUNCATE]
+        train_path = st.session_state.get("train_img_path", "")
+        img_count = 0
+        if train_path and os.path.isdir(train_path):
+            img_count = len([f for f in os.listdir(train_path) if f.lower().endswith(IMG_EXTENSIONS)])
+        st.metric("Dataset", ds_name, delta=f"{img_count} images", delta_color="off")
+    with m3:
+        from flashstudio.utils import get_state
+        model = get_state("model_arch")
+        model_short = model.replace("FlashDet-", "")
+        epochs = get_state("epochs")
+        st.metric("Model", model_short, delta=f"{epochs} epochs", delta_color="off")
+    with m4:
+        best_map = f"{stats['best_map']:.3f}" if stats and stats["best_map"] is not None else "\u2014"
+        runs_count = stats["runs"] if stats else 0
+        st.metric("Best mAP", best_map, delta=f"{runs_count} runs", delta_color="off")

flashstudio/pages/dashboard/overview/pipeline_status.py

@@ -0,0 +1,35 @@
+"""Dashboard — pipeline status section."""
+
+import streamlit as st
+from flashstudio.pages.dashboard._common import (
+    COLOR_SUCCESS, COLOR_TEXT_PRIMARY, COLOR_TEXT_MUTED, COLOR_BORDER,
+)
+
+
+def render_pipeline_status():
+    from flashstudio.utils import get_state
+    ds = st.session_state.get("dataset_name")
+    model = get_state("model_arch")
+    train_status = st.session_state.get("training_status", "")
+    exported = st.session_state.get("exported_files")
+
+    steps = [
+        ("Data", ds is not None, ds or "Not loaded"),
+        ("Model", model is not None, model.replace("FlashDet-", "") if model else "Not set"),
+        ("Training", train_status in ("Complete", "Running"), train_status or "Not started"),
+        ("Export", bool(exported), "Ready" if exported else "Pending"),
+    ]
+
+    for label, done, detail in steps:
+        color = COLOR_SUCCESS if done else "#D1D5DB"
+        text_color = COLOR_TEXT_PRIMARY if done else COLOR_TEXT_MUTED
+        st.markdown(
+            f'<div style="display:flex;align-items:center;gap:0.6rem;padding:0.35rem 0;'
+            f'border-bottom:1px solid {COLOR_BORDER};">'
+            f'<div style="width:10px;height:10px;border-radius:50%;background:{color};flex-shrink:0;"></div>'
+            f'<div style="flex:1;">'
+            f'<span style="font-size:0.85rem;font-weight:600;color:{text_color};">{label}</span>'
+            f'<span style="font-size:0.78rem;color:{COLOR_TEXT_MUTED};margin-left:0.5rem;">{detail}</span>'
+            f'</div></div>',
+            unsafe_allow_html=True,
+        )

flashstudio/pages/dashboard/overview/project_banner.py

@@ -0,0 +1,23 @@
+"""Dashboard — project info banner section."""
+
+import streamlit as st
+from flashstudio.pages.dashboard._common import (
+    COLOR_SUCCESS, COLOR_TEXT_PRIMARY, COLOR_TEXT_SECONDARY,
+    COLOR_TEXT_MUTED, COLOR_BG_HIGHLIGHT,
+)
+
+
+def render_project_banner(project):
+    proj_name = project.get("name", "Untitled")
+    proj_desc = project.get("description", "")
+    created = project.get("created", "")[:10]
+    modified = project.get("last_modified", "")[:10]
+    st.markdown(
+        f'<div style="background:{COLOR_BG_HIGHLIGHT};border-left:4px solid {COLOR_SUCCESS};padding:0.8rem 1rem;'
+        f'border-radius:0 8px 8px 0;margin-bottom:0.8rem;">'
+        f'<div style="font-size:1.1rem;font-weight:700;color:{COLOR_TEXT_PRIMARY};">{proj_name}</div>'
+        f'{("<div style=" + chr(34) + "font-size:0.85rem;color:" + COLOR_TEXT_SECONDARY + ";margin-top:0.2rem;" + chr(34) + ">" + proj_desc + "</div>") if proj_desc else ""}'
+        f'<div style="font-size:0.78rem;color:{COLOR_TEXT_MUTED};margin-top:0.3rem;">Created: {created} · Modified: {modified}</div>'
+        f'</div>',
+        unsafe_allow_html=True,
+    )