flashstudio 0.0.1__py3-none-any.whl

flashstudio/pages/training/monitor/run_meta.py

@@ -0,0 +1,165 @@
+"""Run metadata extraction for the monitor tab."""
+
+import os
+import re
+import glob as glob_module
+
+from flashstudio.constants import (
+    CKPT_BEST_INFERENCE, CKPT_BEST, CKPT_LAST_INFERENCE,
+    CKPT_LAST, CKPT_FINAL_INFERENCE, CKPT_FINAL_FP16,
+    TRAINING_LOG_CSV, format_bytes,
+)
+
+
+def _get_run_meta(run_dir: str) -> dict:
+    """Extract metadata from a training run for display."""
+    import time
+
+    name = os.path.basename(run_dir)
+    meta = {
+        "display_name": name,
+        "status": "unknown",
+        "date": "",
+        "epochs": "?",
+        "mAP": None,
+        "model": "",
+        "dataset": "",
+        "size": "",
+    }
+
+    # Date from folder modification time
+    try:
+        mtime = os.path.getmtime(run_dir)
+        meta["date"] = time.strftime("%b %d %H:%M", time.localtime(mtime))
+    except OSError:
+        pass
+
+    # Folder size
+    try:
+        total = 0
+        for dirpath, _dirs, files in os.walk(run_dir):
+            for f in files:
+                total += os.path.getsize(os.path.join(dirpath, f))
+        meta["size"] = format_bytes(total)
+    except OSError:
+        pass
+
+    # Status: check for checkpoints
+    has_final = (os.path.isfile(os.path.join(run_dir, CKPT_FINAL_INFERENCE))
+                 or os.path.isfile(os.path.join(run_dir, CKPT_FINAL_FP16)))
+    has_best = (os.path.isfile(os.path.join(run_dir, CKPT_BEST_INFERENCE))
+                or os.path.isfile(os.path.join(run_dir, CKPT_BEST)))
+    has_last = (os.path.isfile(os.path.join(run_dir, CKPT_LAST))
+                or os.path.isfile(os.path.join(run_dir, CKPT_LAST_INFERENCE)))
+    from flashstudio.constants import TRAINING_LOG_GLOB
+    log_files = glob_module.glob(os.path.join(run_dir, TRAINING_LOG_GLOB))
+    has_log = bool(log_files)
+    has_csv = os.path.isfile(os.path.join(run_dir, TRAINING_LOG_CSV))
+
+    if has_final:
+        meta["status"] = "Complete"
+    elif has_best and has_last:
+        # Check log for "Training Complete!" to distinguish complete vs in-progress
+        completed_in_log = False
+        if log_files:
+            try:
+                with open(max(log_files, key=lambda p: os.path.getsize(p)), "r", encoding="utf-8", errors="replace") as _f:
+                    _tail = _f.readlines()[-5:]
+                completed_in_log = any("Training Complete!" in l for l in _tail)
+            except OSError:
+                pass
+        meta["status"] = "Complete" if completed_in_log else "In Progress"
+    elif has_last and (has_log or has_csv):
+        meta["status"] = "In Progress"
+    elif has_log or has_csv:
+        meta["status"] = "Started"
+    else:
+        meta["status"] = "Empty"
+
+    # Extract model/epochs from log header (use largest log file)
+    if log_files:
+        try:
+            best_log = max(log_files, key=lambda p: os.path.getsize(p))
+            with open(best_log, "r", encoding="utf-8", errors="replace") as f:
+                header_lines = f.readlines()[:30]
+            for line in header_lines:
+                lc = line.strip()
+                # FlashDet format: "Model Size: FlashDet-N"
+                if "Model Size:" in lc and not meta["model"]:
+                    meta["model"] = lc.split("Model Size:")[-1].strip()
+                # Older/pico format: "Model: p, Input: (320, 320)"
+                if not meta["model"]:
+                    mm = re.search(r"Model:\s*(\w+),\s*Input:\s*\((\d+),\s*(\d+)\)", lc)
+                    if mm:
+                        meta["model"] = f"{mm.group(1)} ({mm.group(2)}x{mm.group(3)})"
+                # Input size on separate line: "Input Size: (320, 320)"
+                if "Input Size:" in lc and not meta.get("input_size"):
+                    ism = re.search(r"Input Size:\s*\((\d+),\s*(\d+)\)", lc)
+                    if ism:
+                        meta["input_size"] = f"{ism.group(1)}x{ism.group(2)}"
+                # Epochs on own line: "Epochs: 1000"
+                if "Epochs:" in lc and meta["epochs"] == "?":
+                    em = re.search(r"Epochs:\s*(\d+)", lc)
+                    if em:
+                        meta["epochs"] = em.group(1)
+                # Also: "Epochs: 100, Batch: 16, LR: 0.001" (compact format)
+                if "Batch Size:" in lc and not meta.get("batch_size"):
+                    bm = re.search(r"Batch Size:\s*(\d+)", lc)
+                    if bm:
+                        meta["batch_size"] = bm.group(1)
+                # Device
+                if "Device:" in lc and not meta.get("device"):
+                    meta["device"] = lc.split("Device:")[-1].strip()
+        except OSError:
+            pass
+
+    # Fallback: parse training_log.csv for epoch count and mAP
+    csv_path = os.path.join(run_dir, TRAINING_LOG_CSV)
+    if os.path.isfile(csv_path) and meta["epochs"] == "?":
+        try:
+            import csv
+            with open(csv_path, "r") as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+            if rows:
+                meta["epochs"] = len(rows)
+                mAP_vals = []
+                for r in rows:
+                    v = r.get("mAP@0.5") or r.get("val_mAP") or ""
+                    if isinstance(v, str) and v.strip():
+                        try:
+                            mAP_vals.append(float(v))
+                        except ValueError:
+                            pass
+                if mAP_vals and max(mAP_vals) > 0 and not meta["mAP"]:
+                    meta["mAP"] = max(mAP_vals)
+        except Exception:
+            pass
+
+    # Fallback: parse log tail for "Best mAP@0.5:" and epoch count
+    if (meta["epochs"] == "?" or not meta["mAP"]) and log_files:
+        try:
+            best_log = max(log_files, key=lambda p: os.path.getsize(p))
+            with open(best_log, "r", encoding="utf-8", errors="replace") as f:
+                tail = f.readlines()[-20:]
+            for line in tail:
+                bm = re.search(r"Best mAP@0\.5:\s*([\d.]+)", line)
+                if bm and not meta["mAP"]:
+                    meta["mAP"] = float(bm.group(1))
+            if meta["epochs"] == "?":
+                for line in tail:
+                    em = re.search(r"Epoch (\d+)/(\d+)", line)
+                    if em:
+                        meta["epochs"] = em.group(1)
+        except OSError:
+            pass
+
+    # Build enriched display name
+    parts = [name]
+    if meta["model"]:
+        parts.append(meta["model"])
+    if meta["mAP"]:
+        parts.append(f"mAP={meta['mAP']:.3f}")
+    meta["display_name"] = " | ".join(parts) if len(parts) > 1 else name
+
+    return meta

flashstudio/pages/training/monitor/tab.py

@@ -0,0 +1,142 @@
+"""Monitor tab — browse and inspect training runs."""
+
+import os
+import streamlit as st
+
+from flashstudio.constants import AUTOREFRESH_INTERVAL_MS, TRAINING_LOG_CSV
+from flashstudio.pages.training._common import _get_save_dir
+from flashstudio.pages.training.monitor.run_meta import _get_run_meta
+from flashstudio.pages.training.monitor.dashboard import _render_run_dashboard
+
+
+def _render_monitor_tab():
+    """Tab: monitor an existing training run — choose workspace, browse runs."""
+    # Auto-refresh toggle
+    auto_refresh = st.session_state.get("monitor_auto_refresh", False)
+    is_training = st.session_state.get("training_active", False) and not st.session_state.get("training_paused", False)
+    if is_training or auto_refresh:
+        try:
+            from streamlit_autorefresh import st_autorefresh
+            st_autorefresh(interval=AUTOREFRESH_INTERVAL_MS, limit=None, key="monitor_autorefresh")
+        except ImportError:
+            pass
+
+    # Monitor workspace — defaults to Save Dir from Model > Advanced
+    save_dir = _get_save_dir()
+    if "monitor_workspace" not in st.session_state:
+        st.session_state["monitor_workspace"] = save_dir
+
+    wc1, wc2, wc3, wc4 = st.columns([5, 1, 1, 1])
+    with wc1:
+        workspace = st.text_input("Workspace Path", key="monitor_workspace",
+                                  label_visibility="collapsed")
+    with wc2:
+        if st.button("Sync", key="mon_sync_btn", use_container_width=True,
+                      help="Sync with Save Dir from Model > Advanced"):
+            st.session_state["monitor_workspace"] = save_dir
+            st.rerun()
+    with wc3:
+        if st.button("Refresh", key="mon_refresh_btn", use_container_width=True):
+            st.rerun()
+    with wc4:
+        if "monitor_auto_refresh" not in st.session_state:
+            st.session_state["monitor_auto_refresh"] = is_training
+        st.toggle("Auto", key="monitor_auto_refresh")
+
+    if not os.path.isdir(workspace):
+        st.warning("Workspace not found")
+        _render_run_dashboard(None)
+        return
+
+    def _is_training_run(folder_path):
+        """Check if a folder looks like a FlashDet training run."""
+        try:
+            entries = os.listdir(folder_path)
+        except OSError:
+            return False
+        has_log = any(f.startswith("train_") and f.endswith(".log") for f in entries)
+        has_csv = TRAINING_LOG_CSV in entries
+        has_ckpt = any(f.endswith(".pth") for f in entries)
+        return has_log or has_csv or has_ckpt
+
+    # Collect training run folders (max 2 levels deep)
+    all_folders = []
+    for d in sorted(os.listdir(workspace)):
+        full = os.path.join(workspace, d)
+        if os.path.isdir(full):
+            if _is_training_run(full):
+                all_folders.append(d)
+            else:
+                try:
+                    for sd in sorted(os.listdir(full)):
+                        sf = os.path.join(full, sd)
+                        if os.path.isdir(sf) and _is_training_run(sf):
+                            all_folders.append(os.path.join(d, sd))
+                except OSError:
+                    pass
+
+    if not all_folders:
+        st.info("No runs found. Start training first.")
+        _render_run_dashboard(None)
+        return
+
+    # Sort by modification time (most recent first)
+    all_folders.sort(
+        key=lambda d: os.path.getmtime(os.path.join(workspace, d)),
+        reverse=True,
+    )
+
+    labels = []
+    for r in all_folders:
+        meta = _get_run_meta(os.path.join(workspace, r))
+        parts = [r]
+        if meta["mAP"]:
+            parts.append(f"mAP={meta['mAP']:.3f}")
+        if meta["size"]:
+            parts.append(meta["size"])
+        labels.append(" | ".join(parts))
+
+    sc1, sc2 = st.columns([7, 1])
+    with sc1:
+        selected_idx = st.selectbox("Select Run", range(len(all_folders)),
+                                    format_func=lambda i: labels[i],
+                                    key="selected_run_idx", label_visibility="collapsed")
+    selected_run = all_folders[selected_idx]
+    run_dir = os.path.join(workspace, selected_run)
+    with sc2:
+        if st.button("Del", key="delete_run_btn", help="Delete this run"):
+            st.session_state["show_delete_run"] = selected_run
+
+    if st.session_state.get("show_delete_run"):
+        dc1, dc2 = st.columns([1, 1])
+        with dc1:
+            if st.button(f"Confirm delete {st.session_state['show_delete_run']}", type="primary",
+                         key="confirm_delete_run"):
+                import shutil
+                from flashstudio.utils import flash
+                deleted_name = st.session_state["show_delete_run"]
+                shutil.rmtree(os.path.join(workspace, deleted_name), ignore_errors=True)
+                st.session_state.pop("show_delete_run", None)
+                flash(f"Deleted run `{deleted_name}`", "success")
+                st.rerun()
+        with dc2:
+            if st.button("Cancel", key="cancel_delete_run"):
+                st.session_state.pop("show_delete_run", None)
+                st.rerun()
+
+    meta = _get_run_meta(run_dir)
+    m1, m2, m3, m4, m5, m6 = st.columns(6)
+    with m1:
+        st.metric("Status", meta["status"][:10])
+    with m2:
+        st.metric("Model", (meta["model"] or "—")[:12])
+    with m3:
+        st.metric("Epochs", meta["epochs"])
+    with m4:
+        st.metric("mAP@50", f"{meta['mAP']:.3f}" if meta["mAP"] else "—")
+    with m5:
+        st.metric("Size", meta["size"] or "—")
+    with m6:
+        st.metric("Date", meta["date"][:8])
+
+    _render_run_dashboard(run_dir)

flashstudio/pages/training/monitor/visualizations.py

@@ -0,0 +1,52 @@
+"""Training visualizations rendering."""
+
+import os
+import streamlit as st
+
+from flashstudio.constants import IMG_EXTENSIONS, VIS_SKIP_FILE, VIS_QUEUE_SIZE
+
+
+def _render_visualizations(run_dir):
+    """Show GT-vs-Prediction images in a FIFO queue — latest N shown, oldest dropped."""
+    vis_dir = os.path.join(run_dir, "visualizations")
+    all_images = []
+    if os.path.isdir(vis_dir):
+        for f in sorted(os.listdir(vis_dir)):
+            if f.lower().endswith(IMG_EXTENSIONS) and f != VIS_SKIP_FILE:
+                all_images.append(os.path.join(vis_dir, f))
+
+    if not all_images:
+        st.info("No visualization images yet. GT vs Prediction images appear here during training.")
+        return
+
+    queue = all_images[-VIS_QUEUE_SIZE:]
+
+    st.caption(f"Showing latest {len(queue)} of {len(all_images)} total  |  Queue drops oldest when new arrives")
+
+    cols = st.columns(VIS_QUEUE_SIZE)
+    for i, img_path in enumerate(queue):
+        fname = os.path.basename(img_path)
+        label = fname.replace(".jpg", "").replace(".png", "").replace("_", " ").title()
+        with cols[i]:
+            st.image(img_path, caption=label, use_container_width=True)
+
+
+def _render_image_grid(img_dir, description, max_images=3):
+    """Render images from a directory in a grid (max 3 by default)."""
+    if not os.path.isdir(img_dir):
+        st.info(f"Directory not found: {img_dir}")
+        return
+
+    images = sorted([f for f in os.listdir(img_dir) if f.endswith((".jpg", ".png"))])
+    if not images:
+        st.info("No images found.")
+        return
+
+    shown = images[:max_images]
+    st.caption(f"{description} — {len(shown)} images" + (f" (of {len(images)} total)" if len(images) > max_images else ""))
+
+    cols = st.columns(len(shown))
+    for i, col in enumerate(cols):
+        img_path = os.path.join(img_dir, shown[i])
+        with col:
+            st.image(img_path, caption=shown[i][:30], use_container_width=True)

flashstudio/pages/training/page.py

@@ -0,0 +1,134 @@
+"""FlashStudio — Training Dashboard Page (reads real FlashDet workspace output)."""
+
+import os
+import streamlit as st
+
+from flashstudio.constants import COMPLETE_MARKERS
+from flashstudio.pages.training.launch.tab import _render_start_tab
+from flashstudio.pages.training.monitor.tab import _render_monitor_tab
+
+
+def _check_training_process():
+    """Check if the training subprocess is still alive; extract errors if it crashed."""
+    pid = st.session_state.get("training_pid")
+    if not pid or not st.session_state.get("training_active"):
+        return
+
+    try:
+        os.kill(pid, 0)
+        return
+    except (ProcessLookupError, PermissionError):
+        pass
+
+    log_path = st.session_state.get("training_log_file", "")
+    error_lines = []
+    last_lines = []
+    if log_path and os.path.isfile(log_path):
+        try:
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                all_lines = f.readlines()
+            last_lines = all_lines[-30:] if len(all_lines) > 30 else all_lines
+
+            in_traceback = False
+            for line in all_lines:
+                stripped = line.strip()
+                if "Traceback" in stripped:
+                    in_traceback = True
+                    error_lines = [stripped]
+                elif in_traceback:
+                    error_lines.append(stripped)
+                elif stripped.startswith("[") and "[ERROR]" in stripped:
+                    error_lines.append(stripped)
+                elif "Error:" in stripped or "Exception:" in stripped:
+                    error_lines.append(stripped)
+        except OSError:
+            pass
+
+    st.session_state["training_active"] = False
+    st.session_state["training_pid"] = None
+    fh = st.session_state.pop("_log_file_handle", None)
+    if fh and not fh.closed:
+        try:
+            fh.close()
+        except Exception:
+            pass
+
+    if error_lines:
+        st.session_state["training_status"] = "Failed"
+        st.session_state["training_error"] = "\n".join(error_lines[-15:])
+    else:
+        complete_markers = COMPLETE_MARKERS
+        run_path = st.session_state.get("active_run_path", "")
+        completed = any(
+            os.path.isfile(os.path.join(run_path, m)) for m in complete_markers
+        ) if run_path else False
+        if not completed and last_lines:
+            completed = any("Training Complete!" in l for l in last_lines)
+        if completed:
+            st.session_state["training_status"] = "Complete"
+        else:
+            tail = "".join(last_lines[-5:]).strip() if last_lines else "No log output"
+            st.session_state["training_status"] = "Stopped"
+            st.session_state["training_error"] = f"Training process exited.\n\nLast log output:\n{tail}"
+
+
+def render_training_page():
+    """Render training dashboard — ultra-compact."""
+    from flashstudio.components.styles import render_page_header
+    from flashstudio.utils import show_flashes
+    render_page_header("", "Training")
+
+    show_flashes()
+
+    if "training_active" not in st.session_state:
+        st.session_state["training_active"] = False
+        st.session_state["training_status"] = "Not started"
+    if "training_paused" not in st.session_state:
+        st.session_state["training_paused"] = False
+
+    _check_training_process()
+
+    training_err = st.session_state.pop("training_error", None)
+    if training_err:
+        lines = training_err.strip().split("\n")
+        error_summary = ""
+        for line in reversed(lines):
+            stripped = line.strip()
+            if "Error:" in stripped or "Exception:" in stripped:
+                error_summary = stripped
+                break
+            if stripped.startswith("[") and "[ERROR]" in stripped:
+                error_summary = stripped
+                break
+        if error_summary:
+            st.error(f"**Training Error:** {error_summary}")
+        else:
+            st.error("**Training failed** — see log details below")
+        with st.expander("Full error log", expanded=True):
+            st.code(training_err, language="text")
+
+    is_active = st.session_state.get("training_active", False)
+    pid = st.session_state.get("training_pid")
+    status = st.session_state.get("training_status", "")
+    if is_active:
+        if st.session_state.get("training_paused"):
+            st.warning(f"Paused (PID {pid})")
+        else:
+            st.success(f"Running (PID {pid})")
+    elif status == "Failed":
+        st.error("Training failed")
+    elif status == "Complete":
+        st.success("Training complete")
+
+    goto_monitor = st.session_state.pop("_goto_monitor", False)
+    is_active = st.session_state.get("training_active", False)
+
+    if goto_monitor or is_active:
+        tab_monitor, tab_start = st.tabs(["Monitor", "Launch"])
+    else:
+        tab_start, tab_monitor = st.tabs(["Launch", "Monitor"])
+
+    with tab_start:
+        _render_start_tab()
+    with tab_monitor:
+        _render_monitor_tab()

flashstudio/utils/__init__.py

@@ -0,0 +1,152 @@
+"""FlashStudio shared utilities."""
+
+import os
+
+from flashstudio.constants import (
+    TRAIN_EPOCHS, TRAIN_BATCH_SIZE, TRAIN_LR, TRAIN_IMG_SIZE,
+    TRAIN_WEIGHT_DECAY, TRAIN_WARMUP_EPOCHS, TRAIN_PATIENCE,
+    TRAIN_NUM_WORKERS, TRAIN_GRAD_ACCUM, DEFAULT_MODEL_ARCH,
+    DEFAULT_ARCH_FAMILY, DEFAULT_SAVE_DIR,
+)
+
+# Central defaults — single source of truth, no hardcoding elsewhere
+DEFAULTS = {
+    "epochs": TRAIN_EPOCHS,
+    "batch_size": TRAIN_BATCH_SIZE,
+    "lr": TRAIN_LR,
+    "img_size": TRAIN_IMG_SIZE,
+    "weight_decay": TRAIN_WEIGHT_DECAY,
+    "warmup_epochs": TRAIN_WARMUP_EPOCHS,
+    "patience": TRAIN_PATIENCE,
+    "num_workers": TRAIN_NUM_WORKERS,
+    "grad_accum": TRAIN_GRAD_ACCUM,
+    "model_arch": DEFAULT_MODEL_ARCH,
+    "arch_family": DEFAULT_ARCH_FAMILY,
+    "save_dir": DEFAULT_SAVE_DIR,
+}
+
+
+def get_default(key: str):
+    """Get a default value for a session state key."""
+    return DEFAULTS.get(key)
+
+
+def get_state(key: str):
+    """Get a session state value with config mirror fallback.
+
+    Priority: _config_mirror > session_state > DEFAULTS.
+    Mirror is kept fresh by update_config_mirror() on every Model page render,
+    so it always holds the latest user choices.  Mirror wins over session_state
+    because Streamlit drops widget keys when navigating away, and
+    _ensure_config_in_session may re-seed stale values from the project file.
+    """
+    import streamlit as st
+    mirror = st.session_state.get("_config_mirror", {})
+    if key in mirror:
+        return mirror[key]
+    return st.session_state.get(key, DEFAULTS.get(key))
+
+
+def update_config_mirror():
+    """Sync _config_mirror with current session_state values.
+
+    Call this after Model page renders so the mirror always holds the
+    latest user choices, surviving page navigations that clear widget keys.
+    """
+    import streamlit as st
+    mirror_keys = [
+        "epochs", "batch_size", "lr", "img_size", "weight_decay",
+        "warmup_epochs", "patience", "num_workers", "grad_accum",
+        "val_interval", "lr_final_ratio", "optimizer",
+        "model_arch", "arch_family", "pico_backbone",
+        "amp", "grad_clip", "multiscale",
+        "aug_mosaic", "aug_mixup", "aug_copypaste",
+        "finetune_strategy", "pretrain_option", "custom_weights",
+        "lora_variant", "lora_rank", "lora_alpha", "lora_dropout", "lora_targets",
+        "activation_checkpointing", "activation_offloading", "optimizer_in_bwd",
+        "compile_model", "use_8bit_optimizer", "ddp", "chunked_loss", "chunk_size",
+        "save_dir", "save_best", "resume_training",
+    ]
+    mirror = st.session_state.get("_config_mirror", {})
+    for k in mirror_keys:
+        if k in st.session_state:
+            mirror[k] = st.session_state[k]
+    st.session_state["_config_mirror"] = mirror
+
+from flashstudio.utils.device import (
+    is_colab,
+    get_device,
+    get_gpu_info,
+    get_colab_runtime_type,
+    has_cuda,
+)
+from flashstudio.utils.filesystem import (
+    dir_size_bytes,
+    dir_size_str,
+    ensure_dir,
+    safe_rmtree,
+)
+from flashstudio.utils.config import (
+    build_training_config,
+    apply_training_config,
+    save_config_yaml,
+    load_config_yaml,
+)
+
+
+def flash(msg: str, kind: str = "success"):
+    """Queue a flash message to display on the next render.
+
+    kind: 'success', 'error', 'warning', 'info'
+    """
+    import streamlit as st
+    msgs = st.session_state.setdefault("_flash_messages", [])
+    msgs.append((kind, msg))
+
+
+def show_flashes():
+    """Display and clear all queued flash messages at the top of a page."""
+    import streamlit as st
+    msgs = st.session_state.pop("_flash_messages", [])
+    for kind, msg in msgs:
+        getattr(st, kind, st.info)(msg)
+
+
+def get_class_names_str() -> str:
+    """Return class names as a newline-separated string, regardless of stored type."""
+    import streamlit as st
+    raw = st.session_state.get("class_names", "")
+    if isinstance(raw, list):
+        return "\n".join(raw)
+    return str(raw)
+
+
+def get_class_names_list() -> list:
+    """Return class names as a list of strings."""
+    raw = get_class_names_str()
+    return [c.strip() for c in raw.strip().split("\n") if c.strip()]
+
+
+__all__ = [
+    "DEFAULTS",
+    "get_default",
+    "get_state",
+    "update_config_mirror",
+    "is_colab",
+    "get_device",
+    "get_gpu_info",
+    "get_colab_runtime_type",
+    "has_cuda",
+    "dir_size_bytes",
+    "dir_size_str",
+    "ensure_dir",
+    "safe_rmtree",
+    "build_training_config",
+    "apply_training_config",
+    "save_config_yaml",
+    "load_config_yaml",
+    "flash",
+    "show_flashes",
+    "get_class_names_str",
+    "get_class_names_list",
+]