flashstudio 0.0.1__py3-none-any.whl

flashstudio/pages/data/upload/tab.py

@@ -0,0 +1,156 @@
+"""Upload tab — file upload, class configuration, and format conversion hint."""
+
+import os
+import streamlit as st
+
+from flashstudio.pages.data._common import (
+    _HAS_FLASHDET, _auto_detect_classes,
+)
+from flashstudio.pages.data.helpers import _extract_upload, _convert_to_coco
+
+try:
+    from flashdet.data import detect_dataset_format
+except ImportError:
+    detect_dataset_format = None
+
+
+def _render_upload():
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.container(border=True):
+            st.markdown("#### Train")
+            train_upload = st.file_uploader("ZIP/TAR", type=["zip", "tar", "gz"], key="train_data_upload")
+            if train_upload:
+                st.session_state["dataset_name"] = train_upload.name
+                if st.button("Extract", key="extract_train", use_container_width=True, type="primary"):
+                    _extract_upload(train_upload, "train")
+            manual_train = st.text_input(
+                "Images dir", placeholder="/path/to/train/",
+                value=st.session_state.get("train_img_path", ""),
+                key="_train_img_input",
+            )
+            if manual_train:
+                st.session_state["train_img_path"] = manual_train
+
+    with col2:
+        with st.container(border=True):
+            st.markdown("#### Val")
+            val_upload = st.file_uploader("ZIP/TAR", type=["zip", "tar", "gz"], key="val_data_upload")
+            if val_upload:
+                if st.button("Extract", key="extract_val", use_container_width=True, type="primary"):
+                    _extract_upload(val_upload, "val")
+            manual_val = st.text_input(
+                "Images dir", placeholder="/path/to/valid/",
+                value=st.session_state.get("val_img_path", ""),
+                key="_val_img_input",
+            )
+            if manual_val:
+                st.session_state["val_img_path"] = manual_val
+
+    st.selectbox("Format", ["COCO JSON", "Pascal VOC", "YOLO TXT"], key="ann_format")
+
+    # ── Classes section ──
+    _render_class_config()
+
+    _render_conversion_hint()
+
+
+def _render_class_config():
+    """Render class configuration: auto-detect from annotation, load from .txt, or manual edit."""
+    from flashstudio.utils import flash
+
+    with st.container(border=True):
+        st.markdown("#### Classes")
+
+        # Auto-detect button + .txt upload in one row
+        cc1, cc2, cc3 = st.columns([2, 2, 1])
+        with cc1:
+            if st.button("Auto-detect from annotation", key="btn_auto_classes",
+                         use_container_width=True, type="primary"):
+                detected = _auto_detect_classes()
+                if detected:
+                    st.session_state["class_names"] = "\n".join(detected)
+                    st.session_state["num_classes"] = len(detected)
+                    flash(f"Detected {len(detected)} classes from annotation", "success")
+                    st.rerun()
+                else:
+                    flash("No classes found — load a dataset with COCO annotations first", "warning")
+                    st.rerun()
+
+        with cc2:
+            cls_file = st.file_uploader("Load classes.txt", type=["txt"],
+                                        key="class_txt_upload", label_visibility="collapsed")
+            if cls_file:
+                content = cls_file.read().decode("utf-8", errors="ignore")
+                names = [line.strip() for line in content.strip().split("\n") if line.strip()]
+                if names:
+                    st.session_state["class_names"] = "\n".join(names)
+                    st.session_state["num_classes"] = len(names)
+                    flash(f"Loaded {len(names)} classes from file", "success")
+                    st.rerun()
+
+        with cc3:
+            nc = st.session_state.get("num_classes", 0)
+            st.metric("Count", nc if nc else "—")
+
+        # Auto-detect on first load if classes not set
+        current_classes = st.session_state.get("class_names", "")
+        if isinstance(current_classes, list):
+            current_classes = "\n".join(current_classes)
+        if not current_classes.strip() and st.session_state.get("train_img_path"):
+            detected = _auto_detect_classes()
+            if detected:
+                st.session_state["class_names"] = "\n".join(detected)
+                st.session_state["num_classes"] = len(detected)
+
+        # Editable text area
+        _cv = st.session_state.get("class_names", "")
+        if isinstance(_cv, list):
+            _cv = "\n".join(_cv)
+        class_text = st.text_area(
+            "Class names (one per line)",
+            value=_cv,
+            height=100,
+            key="_class_names_input",
+            placeholder="person\ncar\nbicycle\n...",
+        )
+        if class_text != _cv:
+            names = [n.strip() for n in class_text.strip().split("\n") if n.strip()]
+            st.session_state["class_names"] = "\n".join(names)
+            st.session_state["num_classes"] = len(names)
+
+        # Download button for current classes
+        if current_classes.strip():
+            st.download_button(
+                "Download classes.txt",
+                current_classes.strip() + "\n",
+                file_name="classes.txt",
+                mime="text/plain",
+                use_container_width=True,
+            )
+
+
+def _render_conversion_hint():
+    train_path = st.session_state.get("train_img_path", "")
+    if not train_path or not os.path.isdir(train_path):
+        return
+    ann_format = st.session_state.get("ann_format", "COCO JSON")
+    detected = st.session_state.get("detected_format", "")
+    needs = "YOLO" in ann_format or "VOC" in ann_format or detected in ("txt", "voc")
+    if not needs:
+        coco_ann = os.path.join(train_path, "_annotations.coco.json")
+        if not os.path.isfile(coco_ann) and _HAS_FLASHDET:
+            parent = os.path.dirname(train_path)
+            det_fmt = detect_dataset_format(parent)
+            if det_fmt in ("txt", "voc"):
+                needs = True
+                st.session_state["detected_format"] = det_fmt
+    if needs:
+        c1, c2 = st.columns([1, 4])
+        with c1:
+            if st.button("Convert to COCO", type="primary", key="manual_convert", use_container_width=True):
+                source = os.path.dirname(train_path) if os.path.basename(train_path) in ("images", "train") else train_path
+                tfmt = "txt" if "YOLO" in ann_format or detected == "txt" else "voc"
+                _convert_to_coco(source, "train", tfmt)
+        with c2:
+            st.caption(f"Format detected: **{detected or ann_format}** → auto-convert to COCO JSON")

flashstudio/pages/data/verify/__init__.py

@@ -0,0 +1,3 @@
+"""Verify tab sub-package."""
+
+from flashstudio.pages.data.verify.tab import _render_verify  # noqa: F401

flashstudio/pages/data/verify/tab.py

@@ -0,0 +1,108 @@
+"""Verify tab — dataset verification and summary statistics."""
+
+import os
+import streamlit as st
+
+from flashstudio.constants import IMG_EXTENSIONS_ALL, MAX_PREVIEW_COLS
+from flashstudio.pages.data._common import _HAS_FLASHDET, _FLASHDET_INSTALL_MSG
+
+try:
+    from flashdet.data import verify_dataset, summarize_coco_root
+except ImportError:
+    pass
+
+
+def _render_verify():
+    train_path = st.session_state.get("train_img_path", "")
+    val_path = st.session_state.get("val_img_path", "")
+    if not train_path and not val_path:
+        st.info("No dataset loaded. Upload or download a dataset first.")
+        return
+
+    dataset_root = st.session_state.get("dataset_output_path", "")
+    if not dataset_root and train_path:
+        parent = os.path.dirname(os.path.normpath(train_path))
+        if os.path.isdir(parent):
+            dataset_root = parent
+
+    # FlashDet verify
+    if dataset_root and os.path.isdir(dataset_root) and _HAS_FLASHDET:
+        vc1, vc2 = st.columns([1, 5])
+        with vc1:
+            do_verify = st.button("Verify", type="primary", key="run_verify_btn", use_container_width=True)
+        with vc2:
+            st.caption(f"Root: `{dataset_root}`")
+        if do_verify or st.session_state.get("_last_verify_ok") is not None:
+            try:
+                ok = verify_dataset(dataset_root)
+                st.session_state["_last_verify_ok"] = ok
+                st.success("Verification **PASSED**") if ok else st.warning("Verification: issues detected")
+            except Exception as e:
+                st.caption(str(e)[:60])
+
+        try:
+            s = summarize_coco_root(dataset_root)
+            has_summary = s and (s.get("train_images", 0) > 0 or s.get("val_images", 0) > 0)
+            if has_summary:
+                m1, m2, m3, m4 = st.columns(4)
+                with m1:
+                    st.metric("Train", s.get("train_images", 0))
+                with m2:
+                    st.metric("Val", s.get("val_images", 0))
+                with m3:
+                    st.metric("Annotations", s.get("total_annotations", 0))
+                with m4:
+                    st.metric("Categories", s.get("num_categories", 0))
+                if s.get("class_distribution"):
+                    with st.expander("Class Distribution"):
+                        top = sorted(s["class_distribution"].items(), key=lambda x: x[1], reverse=True)[:15]
+                        st.bar_chart({n: c for n, c in top})
+                return
+        except Exception:
+            pass
+
+    if not _HAS_FLASHDET and dataset_root and os.path.isdir(dataset_root):
+        st.info(_FLASHDET_INSTALL_MSG)
+
+    # Manual count — always show this as fallback
+    ti = [f for f in os.listdir(train_path) if f.lower().endswith(IMG_EXTENSIONS_ALL)] if train_path and os.path.isdir(train_path) else []
+    vi = [f for f in os.listdir(val_path) if f.lower().endswith(IMG_EXTENSIONS_ALL)] if val_path and os.path.isdir(val_path) else []
+
+    # Count YOLO labels if present
+    train_label_dir = st.session_state.get("train_label_path", "")
+    if not train_label_dir and train_path:
+        candidate = train_path.replace("/images/", "/labels/").replace("\\images\\", "\\labels\\")
+        if os.path.isdir(candidate):
+            train_label_dir = candidate
+    train_labels = len([f for f in os.listdir(train_label_dir) if f.endswith(".txt")]) if train_label_dir and os.path.isdir(train_label_dir) else 0
+
+    m1, m2, m3, m4 = st.columns(4)
+    with m1:
+        st.metric("Train Images", len(ti))
+    with m2:
+        st.metric("Val Images", len(vi))
+    with m3:
+        st.metric("Labels", train_labels if train_labels else "—")
+    with m4:
+        status = "OK" if ti else "Empty"
+        if ti and train_labels and train_labels == len(ti):
+            status = "Complete"
+        elif ti and train_labels and train_labels != len(ti):
+            status = f"Partial ({train_labels}/{len(ti)})"
+        st.metric("Status", status)
+
+    if train_path and os.path.isdir(train_path):
+        st.caption(f"Train: `{train_path}`")
+    if val_path and os.path.isdir(val_path):
+        st.caption(f"Val: `{val_path}`")
+
+    # Sample preview
+    if ti:
+        with st.expander("Samples"):
+            cols = st.columns(min(MAX_PREVIEW_COLS, len(ti)))
+            for i, img_name in enumerate(ti[:MAX_PREVIEW_COLS]):
+                with cols[i]:
+                    try:
+                        st.image(os.path.join(train_path, img_name), caption=img_name[:15], use_container_width=True)
+                    except Exception:
+                        pass

flashstudio/pages/export/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio — Export page package."""
+
+from flashstudio.pages.export.page import render_export_page  # noqa: F401

flashstudio/pages/export/page.py

@@ -0,0 +1,54 @@
+"""FlashStudio — Export (zero-scroll, split layout)."""
+
+import os
+import streamlit as st
+from flashstudio.constants import (
+    EXPORT_OPSET_DEFAULT,
+    CKPT_BEST_INFERENCE, CKPT_BEST, CKPT_LAST_INFERENCE, CKPT_LAST,
+)
+
+
+def render_export_page():
+    from flashstudio.components.styles import render_page_header
+    from flashstudio.utils import show_flashes
+    render_page_header("", "Export")
+    show_flashes()
+
+    left, right = st.columns(2)
+
+    with left:
+        with st.container(border=True):
+            from flashstudio.pages.export.weights.settings import render_export_settings
+            wp, img_sz, export_fmt = render_export_settings()
+
+            if st.button(f"Export {export_fmt}", use_container_width=True, type="primary"):
+                from flashstudio.pages.export.weights.exporter import _run_export
+                _run_export(wp, img_sz, st.session_state.get("export_opset", EXPORT_OPSET_DEFAULT),
+                            st.session_state.get("export_dynamic", True),
+                            export_fmt.lower())
+
+    with right:
+        with st.container(border=True):
+            st.markdown("#### Output")
+            exported = st.session_state.get("exported_files", [])
+            if not exported:
+                st.caption("Auto-saved weights from training:")
+                for n, d in [(CKPT_BEST_INFERENCE, "Best, inference-ready"),
+                              (CKPT_BEST, "Best, full checkpoint"),
+                              (CKPT_LAST_INFERENCE, "Final, inference-ready"),
+                              (CKPT_LAST, "Final, full checkpoint")]:
+                    st.markdown(f'<span style="font-size:0.88rem;color:#4B5563;">• `{n}` — {d}</span>', unsafe_allow_html=True)
+                st.caption("Manual:")
+                st.code("flashdet export --model model.pth --output model.onnx", language="bash")
+            else:
+                for exp in exported:
+                    st.markdown(f"**{exp['format']}** · `{os.path.basename(exp.get('path', ''))}`")
+                    if exp.get("size"):
+                        st.caption(exp["size"])
+                    st.success("OK") if exp.get("success") else st.error("Failed")
+                    if exp.get("success") and os.path.isfile(exp.get("path", "")):
+                        with open(exp["path"], "rb") as f:
+                            st.download_button("Download", f, file_name=os.path.basename(exp["path"]),
+                                               key=f"dl_{exp['format']}", use_container_width=True)
+                with st.expander("Post-export"):
+                    st.code("trtexec --onnx=model.onnx --saveEngine=model.engine --fp16", language="bash")

flashstudio/pages/export/weights/__init__.py

@@ -0,0 +1,4 @@
+"""FlashStudio — Export weights sub-package."""
+
+from flashstudio.pages.export.weights.settings import render_export_settings  # noqa: F401
+from flashstudio.pages.export.weights.exporter import _run_export  # noqa: F401

flashstudio/pages/export/weights/exporter.py

@@ -0,0 +1,60 @@
+"""FlashStudio — Export engine (model export to ONNX / TorchScript)."""
+
+import os
+import streamlit as st
+from flashstudio.constants import (
+    INFER_NUM_CLASSES, MODEL_SIZE_DEFAULT,
+)
+
+
+def _run_export(weights_path, img_size, opset=13, dynamic=True, fmt="onnx"):
+    from flashstudio.utils import flash
+
+    if not weights_path or not os.path.isfile(weights_path):
+        flash(f"Weights not found: `{weights_path}`", "error")
+        st.rerun()
+        return
+
+    import torch
+    try:
+        from flashdet import get_config, build_model
+    except ImportError:
+        flash("FlashDet not installed — run `pip install flashdet`", "error")
+        st.rerun()
+        return
+
+    ext = ".onnx" if fmt == "onnx" else ".pt"
+    out = weights_path.replace(".pth", ext)
+    label = "ONNX" if fmt == "onnx" else "TorchScript"
+    with st.spinner(f"Exporting to {label}..."):
+        try:
+            ckpt = torch.load(weights_path, map_location="cpu", weights_only=False)
+            cfg = ckpt.get("config", {})
+            nc = cfg.get("num_classes", st.session_state.get("num_classes", INFER_NUM_CLASSES))
+            raw_input = cfg.get("input_size", img_size)
+            inp_scalar = raw_input[0] if isinstance(raw_input, (tuple, list)) else raw_input
+            arch = cfg.get("architecture", "flashdet")
+            config = get_config(model_size=cfg.get("model_size", MODEL_SIZE_DEFAULT), input_size=inp_scalar, num_classes=nc)
+            config.model.architecture = arch
+            model = build_model(config, architecture=arch)
+            sd = ckpt.get("model_state_dict", ckpt.get("state_dict", ckpt.get("model", ckpt)))
+            model.load_state_dict(sd, strict=False)
+            model.eval()
+            dummy = torch.randn(1, 3, inp_scalar, inp_scalar)
+
+            if fmt == "onnx":
+                dyn = {"images": {0: "batch"}, "output": {0: "batch"}} if dynamic else None
+                torch.onnx.export(model, dummy, out, opset_version=opset,
+                                  input_names=["images"], output_names=["output"],
+                                  dynamic_axes=dyn)
+            else:
+                traced = torch.jit.trace(model, dummy)
+                traced.save(out)
+
+            sz = f"{os.path.getsize(out) / (1024*1024):.1f}MB" if os.path.isfile(out) else "—"
+            st.session_state["exported_files"] = [{"format": label, "path": out, "size": sz, "success": True}]
+            flash(f"Export successful: `{os.path.basename(out)}` ({sz})", "success")
+        except Exception as e:
+            flash(f"Export failed: {e}", "error")
+            st.session_state["exported_files"] = [{"format": label, "path": out, "size": "—", "success": False}]
+    st.rerun()

flashstudio/pages/export/weights/settings.py

@@ -0,0 +1,86 @@
+"""FlashStudio — Export settings UI (weights display & config)."""
+
+import os
+import streamlit as st
+from flashstudio.constants import (
+    DEFAULT_SAVE_DIR, EXPORT_IMG_SIZES, EXPORT_OPSET_MIN,
+    EXPORT_OPSET_MAX, EXPORT_OPSET_DEFAULT, EXPORT_FORMATS,
+    EXPORT_WEIGHT_MAP, CKPT_BEST, MAX_WEIGHTS_DISPLAY,
+)
+
+
+def _get_export_save_dir():
+    """Resolve save_dir: _config_mirror > session_state > DEFAULT_SAVE_DIR."""
+    from flashstudio.utils import get_state
+    sd = get_state("save_dir")
+    return sd if sd else DEFAULT_SAVE_DIR
+
+
+def render_export_settings():
+    """Render the weights display and config UI. Returns (weights_path, img_size, export_fmt)."""
+    st.markdown("#### Weights")
+    save_dir = _get_export_save_dir()
+    if os.path.isdir(save_dir):
+        wts = []
+        for root, _dirs, files in os.walk(save_dir):
+            for f in files:
+                if f.endswith(".pth"):
+                    wts.append(os.path.join(root, f))
+        if wts:
+            cols = st.columns(min(len(wts), MAX_WEIGHTS_DISPLAY))
+            for i, wp_disp in enumerate(sorted(wts)[:MAX_WEIGHTS_DISPLAY]):
+                sz = os.path.getsize(wp_disp) / (1024 * 1024)
+                bn = os.path.basename(wp_disp)
+                if "best" in bn and "inference" in bn:
+                    lbl = "Best Inf"
+                elif "best" in bn and "fp16" in bn:
+                    lbl = "Best FP16"
+                elif "best" in bn:
+                    lbl = "Best"
+                elif "last" in bn and "inference" in bn:
+                    lbl = "Last Inf"
+                elif "last" in bn:
+                    lbl = "Last"
+                else:
+                    lbl = bn[:8]
+                with cols[i]:
+                    st.metric(lbl, f"{sz:.1f}MB")
+        else:
+            st.caption(f"No weights found in `{save_dir}`")
+    else:
+        st.caption("No save directory set. Train a model first or set `Save Dir` on Model page.")
+
+    st.markdown("#### Config")
+    src = st.radio("Source", ["Best (inference)", "Best (FP16)", "Last", "Custom"],
+                   key="weights_source", horizontal=True)
+    if src == "Custom":
+        st.text_input("Path", placeholder="model.pth", key="export_weights_path")
+
+    sd = _get_export_save_dir()
+    if src != "Custom":
+        targets = EXPORT_WEIGHT_MAP.get(src, [CKPT_BEST])
+        wp = ""
+        if os.path.isdir(sd):
+            for root, _dirs, files in os.walk(sd):
+                for target in targets:
+                    if target in files:
+                        wp = os.path.join(root, target)
+                        break
+                if wp:
+                    break
+        if not wp:
+            wp = os.path.join(sd, targets[0])
+    else:
+        wp = st.session_state.get("export_weights_path", "")
+
+    oc = st.columns(4)
+    with oc[0]:
+        export_fmt = st.selectbox("Format", EXPORT_FORMATS, key="export_format")
+    with oc[1]:
+        img_sz = st.select_slider("Img", EXPORT_IMG_SIZES, value=EXPORT_IMG_SIZES[0], key="export_img_size")
+    with oc[2]:
+        st.number_input("Opset", EXPORT_OPSET_MIN, EXPORT_OPSET_MAX, EXPORT_OPSET_DEFAULT, key="export_opset")
+    with oc[3]:
+        st.checkbox("Dynamic", True, key="export_dynamic")
+
+    return wp, img_sz, export_fmt

flashstudio/pages/inference/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio — Inference page package."""
+
+from flashstudio.pages.inference.page import render_inference_page  # noqa: F401

flashstudio/pages/inference/_common.py

@@ -0,0 +1,76 @@
+"""Inference — shared state, constants, and utility functions."""
+
+import streamlit as st
+from flashstudio.constants import COCO_CLASSES
+
+try:
+    from flashstudio.components.zone_drawer import zone_drawer  # noqa: F401
+    _HAS_ZONE_DRAWER = True
+except ImportError:
+    _HAS_ZONE_DRAWER = False
+
+try:
+    from flashdet import Predictor, FlashTracker  # noqa: F401
+    _HAS_PREDICTOR = True
+except ImportError:
+    _HAS_PREDICTOR = False
+
+_SOLUTIONS_AVAILABLE = {}
+_solution_classes = [
+    "ObjectCounter", "RegionCounter", "SpeedEstimator", "Heatmap",
+    "SecurityAlarm", "QueueManager", "ParkingManager", "TrafficFlow",
+    "DwellTimeAnalyzer", "DistanceCalculator", "TrajectoryVisualizer",
+    "ObjectBlurrer", "CrowdDensity", "WorkoutMonitor", "ObjectCropper",
+    "AnalyticsDashboard",
+]
+for _cls_name in _solution_classes:
+    try:
+        _mod = __import__("flashdet.solutions", fromlist=[_cls_name])
+        _SOLUTIONS_AVAILABLE[_cls_name] = getattr(_mod, _cls_name)
+    except (ImportError, AttributeError):
+        pass
+
+
+SOLUTIONS = {
+    "None (Detection Only)": {"desc": "Standard object detection", "needs_zone": False},
+    "Object Counter (Line)": {"desc": "Count objects crossing line", "needs_zone": True, "zone_type": "line"},
+    "Region Counter (Polygon)": {"desc": "Count in polygon zones", "needs_zone": True, "zone_type": "polygon"},
+    "Speed Estimator": {"desc": "Estimate speed", "needs_zone": True, "zone_type": "line"},
+    "Heatmap": {"desc": "Activity heatmap", "needs_zone": False},
+    "Security Alarm (Zone)": {"desc": "Alert on zone entry", "needs_zone": True, "zone_type": "polygon"},
+    "Trajectory Visualizer": {"desc": "Motion trails", "needs_zone": False},
+    "Object Blurrer": {"desc": "Blur detections", "needs_zone": False},
+    "Queue Manager": {"desc": "Queue lengths", "needs_zone": True, "zone_type": "polygon"},
+    "Crowd Density": {"desc": "Grid density", "needs_zone": False},
+    "Parking Manager": {"desc": "Parking occupancy", "needs_zone": True, "zone_type": "polygon"},
+    "Traffic Flow": {"desc": "Traffic analysis", "needs_zone": True, "zone_type": "line"},
+    "Dwell Time Analyzer": {"desc": "Time in zones", "needs_zone": True, "zone_type": "polygon"},
+    "Distance Calculator": {"desc": "Pairwise distances", "needs_zone": False},
+    "Workout Monitor": {"desc": "Exercise reps", "needs_zone": False},
+    "Object Cropper": {"desc": "Crop detections", "needs_zone": False},
+    "Analytics Dashboard": {"desc": "Real-time stats", "needs_zone": False},
+}
+
+
+def _get_class_names():
+    """Get class names from session state, falling back to COCO."""
+    raw = st.session_state.get("class_names", "")
+    if isinstance(raw, list):
+        names = [c.strip() for c in raw if c.strip()]
+    elif isinstance(raw, str) and raw.strip():
+        names = [c.strip() for c in raw.strip().split("\n") if c.strip()]
+    else:
+        names = []
+    return names if names else COCO_CLASSES
+
+
+def _get_device_options():
+    devices = ["cpu"]
+    try:
+        import torch
+        if torch.cuda.is_available():
+            for i in range(torch.cuda.device_count()):
+                devices.append(f"cuda:{i} ({torch.cuda.get_device_name(i)})")
+    except ImportError:
+        pass
+    return devices

flashstudio/pages/inference/data/__init__.py

@@ -0,0 +1,3 @@
+"""Inference — Data tab sub-package."""
+
+from flashstudio.pages.inference.data.tab import _tab_data  # noqa: F401