flashstudio 0.0.1__py3-none-any.whl

flashstudio/pages/dashboard/overview/quick_actions.py

@@ -0,0 +1,28 @@
+"""Dashboard — quick action buttons section."""
+
+import streamlit as st
+
+
+def render_quick_actions():
+    ac1, ac2, ac3 = st.columns(3)
+    with ac1:
+        if st.button("Upload Data", use_container_width=True, key="dash_goto_data"):
+            st.session_state["current_step"] = 1
+            st.rerun()
+        if st.button("Configure Model", use_container_width=True, key="dash_goto_model"):
+            st.session_state["current_step"] = 2
+            st.rerun()
+    with ac2:
+        if st.button("Start Training", use_container_width=True, type="primary", key="dash_goto_train"):
+            st.session_state["current_step"] = 3
+            st.rerun()
+        if st.button("Export Model", use_container_width=True, key="dash_goto_export"):
+            st.session_state["current_step"] = 4
+            st.rerun()
+    with ac3:
+        if st.button("Run Inference", use_container_width=True, key="dash_goto_infer"):
+            st.session_state["current_step"] = 5
+            st.rerun()
+        if st.button("Projects", use_container_width=True, key="dash_goto_proj"):
+            st.session_state["show_project_manager"] = True
+            st.rerun()

flashstudio/pages/dashboard/overview/recent_runs.py

@@ -0,0 +1,99 @@
+"""Dashboard — recent runs section."""
+
+import os
+import re
+import time
+import glob as glob_module
+import streamlit as st
+from flashstudio.pages.dashboard._common import (
+    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,
+)
+
+
+def render_recent_runs():
+    from flashstudio.components.project_manager import get_active_project, get_project_dir
+
+    user_save_dir = st.session_state.get("save_dir", "")
+
+    candidates = []
+    active_proj = get_active_project()
+    if active_proj:
+        candidates.append(os.path.join(get_project_dir(active_proj["id"]), "runs"))
+    if user_save_dir and user_save_dir != DEFAULT_SAVE_DIR:
+        candidates.append(user_save_dir)
+    candidates.append(DEFAULT_SAVE_DIR)
+    ws = None
+    for c in candidates:
+        c = os.path.abspath(c)
+        if os.path.isdir(c):
+            ws = c
+            break
+
+    if not ws:
+        st.caption("No workspace found. Start training to create runs.")
+        return
+
+    dirs = sorted(
+        [d for d in os.listdir(ws) if os.path.isdir(os.path.join(ws, d))],
+        key=lambda d: os.path.getmtime(os.path.join(ws, d)), reverse=True,
+    )[:MAX_DISPLAY_RUNS]
+
+    if not dirs:
+        st.caption("No runs yet. Go to Training to start your first run.")
+        return
+
+    for name in dirs:
+        rd = os.path.join(ws, name)
+        has_best = (os.path.isfile(os.path.join(rd, CKPT_BEST))
+                    or os.path.isfile(os.path.join(rd, CKPT_BEST_INFERENCE)))
+        has_final = (os.path.isfile(os.path.join(rd, CKPT_FINAL_INFERENCE))
+                     or os.path.isfile(os.path.join(rd, CKPT_FINAL_FP16)))
+        status = "Done" if (has_best or has_final) else "\u2014"
+        info = ""
+        csv_path = os.path.join(rd, TRAINING_LOG_CSV)
+        if os.path.isfile(csv_path):
+            try:
+                import csv as _csv
+                with open(csv_path, "r") as _f:
+                    rows = list(_csv.DictReader(_f))
+                if rows:
+                    vals = [float(r.get("mAP@0.5", 0)) for r in rows if r.get("mAP@0.5", "").strip()]
+                    if vals:
+                        info = f"mAP {max(vals):.3f}"
+            except Exception:
+                pass
+        if not info:
+            from flashstudio.constants import TRAINING_LOG_GLOB
+            log_files = glob_module.glob(os.path.join(rd, TRAINING_LOG_GLOB))
+            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:
+                        for _ln in _f.readlines()[-10:]:
+                            bm = re.search(r"Best mAP@0\.5:\s*([\d.]+)", _ln)
+                            if bm:
+                                info = f"mAP {bm.group(1)}"
+                except OSError:
+                    pass
+
+        mtime = os.path.getmtime(rd)
+        date_str = time.strftime("%b %d, %H:%M", time.localtime(mtime))
+        status_color = COLOR_SUCCESS if (has_best or has_final) else COLOR_TEXT_MUTED
+
+        st.markdown(
+            f'<div style="display:flex;justify-content:space-between;align-items:center;'
+            f'font-size:0.85rem;padding:0.4rem 0;border-bottom:1px solid {COLOR_BORDER};">'
+            f'<div>'
+            f'<span style="font-weight:600;color:{COLOR_TEXT_PRIMARY};">{name[:25]}</span>'
+            f'<span style="color:{COLOR_TEXT_MUTED};font-size:0.75rem;margin-left:0.5rem;">{date_str}</span>'
+            f'</div>'
+            f'<div style="display:flex;gap:0.8rem;align-items:center;">'
+            f'<span style="color:{COLOR_TEXT_SECONDARY};">{info}</span>'
+            f'<span style="color:{status_color};font-weight:600;">{status}</span>'
+            f'</div></div>',
+            unsafe_allow_html=True,
+        )

flashstudio/pages/dashboard/overview/tab.py

@@ -0,0 +1,35 @@
+"""Dashboard overview — orchestrates all overview sections."""
+
+import streamlit as st
+from flashstudio.pages.dashboard.overview.project_banner import render_project_banner
+from flashstudio.pages.dashboard.overview.metrics import render_metrics
+from flashstudio.pages.dashboard.overview.pipeline_status import render_pipeline_status
+from flashstudio.pages.dashboard.overview.quick_actions import render_quick_actions
+from flashstudio.pages.dashboard.overview.recent_runs import render_recent_runs
+
+
+def render_overview(project, stats):
+    from flashstudio.utils.device import get_gpu_info
+
+    gpu = get_gpu_info()
+
+    if project:
+        render_project_banner(project)
+
+    render_metrics(gpu, stats)
+
+    left, right = st.columns(2)
+
+    with left:
+        with st.container(border=True):
+            st.markdown("#### Pipeline Status")
+            render_pipeline_status()
+
+    with right:
+        with st.container(border=True):
+            st.markdown("#### Quick Actions")
+            render_quick_actions()
+
+    with st.container(border=True):
+        st.markdown("#### Recent Runs")
+        render_recent_runs()

flashstudio/pages/dashboard/page.py

@@ -0,0 +1,17 @@
+"""FlashStudio — Dashboard."""
+
+from flashstudio.components.styles import render_page_header
+from flashstudio.pages.dashboard.overview.tab import render_overview
+
+
+def render_dashboard():
+    from flashstudio.components.project_manager import get_active_project, get_project_stats
+    from flashstudio.utils import show_flashes
+
+    render_page_header("", "Dashboard")
+    show_flashes()
+
+    project = get_active_project()
+    stats = get_project_stats(project["id"]) if project else None
+
+    render_overview(project, stats)

flashstudio/pages/data/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio — Data page package."""
+
+from flashstudio.pages.data.page import render_data_page  # noqa: F401

flashstudio/pages/data/_common.py

@@ -0,0 +1,107 @@
+"""Shared helpers and constants for the data page."""
+
+import os
+import json
+import streamlit as st
+
+from flashstudio.constants import (
+    DEFAULT_DATA_DIR, NETWORK_CHECK_URL, NETWORK_CHECK_TIMEOUT,
+)
+
+try:
+    from flashdet import download_dataset, list_datasets  # noqa: F401
+    from flashdet.data import (  # noqa: F401
+        convert_dataset, detect_dataset_format,
+        verify_dataset, summarize_coco_root,
+    )
+    _HAS_FLASHDET = True
+except ImportError:
+    _HAS_FLASHDET = False
+
+_FLASHDET_INSTALL_MSG = "FlashDet required — install with: `pip install flashdet`"
+
+
+def _extract_classes_from_coco_json(ann_path: str) -> list[str]:
+    """Read class names from a COCO-format annotation JSON file."""
+    try:
+        with open(ann_path, encoding="utf-8") as f:
+            data = json.load(f)
+        cats = data.get("categories", [])
+        if not cats:
+            return []
+        sorted_cats = sorted(cats, key=lambda c: c.get("id", 0))
+        return [c["name"] for c in sorted_cats]
+    except (OSError, json.JSONDecodeError, KeyError, TypeError):
+        return []
+
+
+def _auto_detect_classes():
+    """Try to auto-detect classes from the loaded dataset annotation."""
+    train_path = st.session_state.get("train_img_path", "")
+    if not train_path or not os.path.isdir(train_path):
+        return []
+
+    ann_file = os.path.join(train_path, "_annotations.coco.json")
+    if not os.path.isfile(ann_file):
+        json_files = [f for f in os.listdir(train_path) if f.endswith(".json")]
+        if json_files:
+            ann_file = os.path.join(train_path, json_files[0])
+        else:
+            return []
+
+    return _extract_classes_from_coco_json(ann_file)
+
+
+def _get_native_datasets():
+    if not _HAS_FLASHDET:
+        return []
+    try:
+        return list_datasets()
+    except Exception:
+        return []
+
+
+def _check_network() -> bool:
+    import urllib.request
+    import urllib.error
+    try:
+        urllib.request.urlopen(NETWORK_CHECK_URL, timeout=NETWORK_CHECK_TIMEOUT)
+        return True
+    except (urllib.error.URLError, OSError):
+        return False
+
+
+def _dataset_already_downloaded(dataset_id: str, output_dir: str | None = None) -> str | None:
+    if output_dir is None:
+        output_dir = os.path.join(DEFAULT_DATA_DIR, dataset_id)
+    if not os.path.isdir(output_dir):
+        return None
+    t = os.path.join(output_dir, "train")
+    v = os.path.join(output_dir, "valid")
+    if not os.path.isdir(v):
+        v = os.path.join(output_dir, "val")
+    if os.path.isdir(t) and os.path.isdir(v) and os.listdir(t) and os.listdir(v):
+        return output_dir
+    return None
+
+
+EXTERNAL_DATASETS = [
+    {"name": "COCO128", "imgs": 128, "cls": 80, "sz": "7MB", "fmt": "COCO", "url": "https://github.com/ultralytics/yolov5/releases/download/v1.0/coco128.zip"},
+    {"name": "Objects365", "imgs": 5000, "cls": 365, "sz": "~2GB", "fmt": "COCO", "url": "https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/val/zhiyuan_objv2_val.json"},
+    {"name": "GlobalWheat", "imgs": 4700, "cls": 1, "sz": "~3GB", "fmt": "COCO", "url": "https://zenodo.org/record/4298502"},
+    {"name": "VisDrone", "imgs": 6471, "cls": 10, "sz": "~2GB", "fmt": "Custom", "url": "https://github.com/VisDrone/VisDrone-Dataset"},
+    {"name": "SKU-110K", "imgs": 11762, "cls": 1, "sz": "~3GB", "fmt": "CSV", "url": "https://github.com/eg4000/SKU110K_CVPR19"},
+    {"name": "WIDER Face", "imgs": 32203, "cls": 1, "sz": "~1.5GB", "fmt": "Custom", "url": "http://shuoyang1213.me/WIDERFACE/"},
+    {"name": "Cityscapes", "imgs": 5000, "cls": 30, "sz": "~11GB", "fmt": "Custom", "url": "https://www.cityscapes-dataset.com/"},
+    {"name": "BDD100K", "imgs": 100000, "cls": 10, "sz": "~6GB", "fmt": "Custom", "url": "https://bdd-data.berkeley.edu/"},
+    {"name": "KITTI", "imgs": 7481, "cls": 3, "sz": "~12GB", "fmt": "Custom", "url": "http://www.cvlibs.net/datasets/kitti/eval_object.php"},
+    {"name": "xView", "imgs": 1400, "cls": 60, "sz": "~4GB", "fmt": "GeoJSON", "url": "http://xviewdataset.org/"},
+    {"name": "OpenImages V7", "imgs": 1900000, "cls": 600, "sz": "~500GB", "fmt": "CSV", "url": "https://storage.googleapis.com/openimages/web/index.html"},
+    {"name": "LVIS v1", "imgs": 164000, "cls": 1203, "sz": "~20GB", "fmt": "COCO", "url": "https://www.lvisdataset.org/"},
+]
+
+QUICK_START = [
+    {"id": "sample", "name": "FlashDet Sample", "imgs": 50, "cls": 80, "sz": "~1GB"},
+    {"id": "coco2017-val", "name": "COCO 2017 Val", "imgs": 5000, "cls": 80, "sz": "~1GB"},
+    {"id": "voc2007", "name": "VOC 2007", "imgs": 9963, "cls": 20, "sz": "~900MB"},
+]

flashstudio/pages/data/download/__init__.py

@@ -0,0 +1,3 @@
+"""Download tab sub-package."""
+
+from flashstudio.pages.data.download.tab import _render_download  # noqa: F401

flashstudio/pages/data/download/tab.py

@@ -0,0 +1,75 @@
+"""Download tab — Quick Start, Native, and External dataset sections."""
+
+import streamlit as st
+
+from flashstudio.constants import INFER_NUM_CLASSES
+from flashstudio.pages.data._common import (
+    _get_native_datasets, _dataset_already_downloaded,
+    EXTERNAL_DATASETS, QUICK_START,
+)
+from flashstudio.pages.data.helpers import (
+    _use_existing, _run_flashdet_download, _run_external_download,
+)
+
+
+def _render_download():
+    # Quick start — compact single row each
+    st.markdown("#### Quick Start")
+    for idx, ds in enumerate(QUICK_START):
+        did = ds["id"]
+        existing = _dataset_already_downloaded(did)
+        c1, c2 = st.columns([5, 1])
+        with c1:
+            st.markdown(
+                f'<div style="font-size:0.88rem;"><b>{ds["name"]}</b> · '
+                f'{ds["imgs"]} imgs · {ds["cls"]} cls · {ds["sz"]}</div>',
+                unsafe_allow_html=True,
+            )
+        with c2:
+            label = "Use" if existing else "Get"
+            if st.button(label, key=f"qs_{idx}", use_container_width=True, type="primary"):
+                if existing:
+                    _use_existing(existing, ds)
+                else:
+                    st.session_state.update({"dataset_name": ds["name"], "dataset_classes": ds["cls"], "dataset_id": did})
+                    _run_flashdet_download(did)
+
+    st.divider()
+
+    # Native datasets
+    native = _get_native_datasets()
+    if native:
+        with st.expander(f"FlashDet Native ({len(native)} datasets)", expanded=False):
+            for i, ds in enumerate(native):
+                did = ds.get("id", ds.get("name", "").lower().replace(" ", ""))
+                existing = _dataset_already_downloaded(did)
+                c1, c2 = st.columns([5, 1])
+                with c1:
+                    st.caption(f"**{ds.get('name', did)}** · {ds.get('classes', '?')} cls")
+                with c2:
+                    if st.button("Use" if existing else "Get", key=f"nat_{i}", use_container_width=True):
+                        if existing:
+                            _use_existing(existing, ds)
+                        else:
+                            st.session_state.update({"dataset_name": ds.get("name", did), "dataset_id": did, "dataset_classes": ds.get("classes", INFER_NUM_CLASSES)})
+                            _run_flashdet_download(did)
+
+    # External
+    with st.expander(f"External Datasets ({len(EXTERNAL_DATASETS)})", expanded=False):
+        for i, ds in enumerate(EXTERNAL_DATASETS):
+            c1, c2 = st.columns([5, 1])
+            with c1:
+                st.markdown(
+                    f'<div style="font-size:0.88rem;"><b>{ds["name"]}</b> · '
+                    f'{ds["imgs"]} · {ds["cls"]} cls · {ds["sz"]} · {ds["fmt"]}</div>',
+                    unsafe_allow_html=True,
+                )
+            with c2:
+                url = ds.get("url", "")
+                is_manual = not url or "VisDrone" in url
+                if st.button("Link" if is_manual else "Get", key=f"ext_{i}", use_container_width=True):
+                    if is_manual:
+                        st.info(f"Manual: [{url}]({url})")
+                    else:
+                        st.session_state.update({"dataset_name": ds["name"], "dataset_classes": ds["cls"]})
+                        _run_external_download(ds)