singlebehaviorlab 2.1.0__tar.gz → 2.3.0__tar.gz

{singlebehaviorlab-2.1.0/singlebehaviorlab.egg-info → singlebehaviorlab-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: singlebehaviorlab
-Version: 2.1.0
+Version: 2.3.0
 Summary: Semi-automated behavioral video annotation, training, and analysis tool
 Author: Almir Aljovic
 Maintainer: Almir Aljovic
@@ -200,6 +200,8 @@ Run `singlebehaviorlab <command> --help` for the full flag list on each subcomma
 > **Full CLI reference:** [**CLI.md**](CLI.md) — detailed per-command docs, file-format reference, Python API, and troubleshooting.
 >
 > **Notebook demos:** [**demo/**](demo/) — two Jupyter notebooks walking through behavior sequencing and segmentation/clustering end-to-end. Drop your own demo video + prompts into `demo/data/` and step through the cells.
+>
+> **Try it in Colab — no install needed:** [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/alms93/SingleBehaviorLab/blob/main/demo/colab_segmentation_clustering.ipynb) Runs the full segmentation + clustering pipeline on a bundled demo video in a free Colab GPU runtime. Install takes ~5–10 minutes; the pipeline itself finishes in a few minutes.
 
 ---
 

{singlebehaviorlab-2.1.0 → singlebehaviorlab-2.3.0}/README.md

@@ -133,6 +133,8 @@ Run `singlebehaviorlab <command> --help` for the full flag list on each subcomma
 > **Full CLI reference:** [**CLI.md**](CLI.md) — detailed per-command docs, file-format reference, Python API, and troubleshooting.
 >
 > **Notebook demos:** [**demo/**](demo/) — two Jupyter notebooks walking through behavior sequencing and segmentation/clustering end-to-end. Drop your own demo video + prompts into `demo/data/` and step through the cells.
+>
+> **Try it in Colab — no install needed:** [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/alms93/SingleBehaviorLab/blob/main/demo/colab_segmentation_clustering.ipynb) Runs the full segmentation + clustering pipeline on a bundled demo video in a free Colab GPU runtime. Install takes ~5–10 minutes; the pipeline itself finishes in a few minutes.
 
 ---
 

{singlebehaviorlab-2.1.0 → singlebehaviorlab-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "singlebehaviorlab"
-version = "2.1.0"
+version = "2.3.0"
 description = "Semi-automated behavioral video annotation, training, and analysis tool"
 readme = "README.md"
 license = { file = "LICENSE" }

{singlebehaviorlab-2.1.0 → singlebehaviorlab-2.3.0}/singlebehaviorlab/__init__.py

@@ -19,7 +19,7 @@ or videoprism. Each symbol triggers its underlying backend module only on
 first access.
 """
 
-__version__ = "2.1.0"
+__version__ = "2.3.0"
 __author__ = "Almir Aljovic"
 
 # Mapping of public name → (backend module, attribute name).
@@ -35,6 +35,8 @@ _PUBLIC_API = {
     "infer": ("singlebehaviorlab.backend.inference", "run_inference_on_video"),
     "train": ("singlebehaviorlab.backend.training_runner", "run_training_session"),
     "load_config": ("singlebehaviorlab.config", "load_config"),
+    "load_demo": ("singlebehaviorlab.demo", "load_demo"),
+    "DEMOS": ("singlebehaviorlab.demo", "DEMOS"),
 }
 
 __all__ = ["__version__", "__author__", *sorted(_PUBLIC_API)]

singlebehaviorlab-2.3.0/singlebehaviorlab/backend/segments.py

@@ -0,0 +1,257 @@
+"""Mutable segment list that drives the interactive timeline editor.
+
+Segments are the single source of truth: per-frame label arrays, CSV rows,
+and SVG rectangles are all derived from them. Editing operations enforce
+non-overlap and boundary constraints, and every mutation is tracked by an
+undo/redo stack.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+import numpy as np
+
+__all__ = ["Segment", "SegmentsModel"]
+
+UNDO_LIMIT = 50
+
+
+@dataclass
+class Segment:
+    class_idx: int
+    start: int
+    end: int
+    confidence: float = 1.0
+
+    @property
+    def length(self) -> int:
+        return max(0, self.end - self.start)
+
+    def to_dict(self) -> dict:
+        return {
+            "class": self.class_idx,
+            "start": self.start,
+            "end": self.end,
+            "confidence": self.confidence,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Segment":
+        return cls(
+            class_idx=int(d["class"]),
+            start=int(d["start"]),
+            end=int(d["end"]),
+            confidence=float(d.get("confidence", 1.0)),
+        )
+
+
+class SegmentsModel:
+    """Ordered, non-overlapping segment list with undo/redo."""
+
+    def __init__(
+        self,
+        segments: list[dict] | list[Segment],
+        classes: list[str],
+        total_frames: int,
+        orig_fps: float = 30.0,
+    ):
+        self.classes = list(classes)
+        self.total_frames = max(0, total_frames)
+        self.orig_fps = float(orig_fps)
+
+        raw = []
+        for s in segments:
+            raw.append(s if isinstance(s, Segment) else Segment.from_dict(s))
+        raw.sort(key=lambda s: s.start)
+        self._segments: list[Segment] = raw
+        self._undo: list[list[Segment]] = []
+        self._redo: list[list[Segment]] = []
+
+    @property
+    def segments(self) -> list[Segment]:
+        return self._segments
+
+    def __len__(self) -> int:
+        return len(self._segments)
+
+    def __getitem__(self, idx: int) -> Segment:
+        return self._segments[idx]
+
+    def _snapshot(self) -> None:
+        self._undo.append(copy.deepcopy(self._segments))
+        if len(self._undo) > UNDO_LIMIT:
+            self._undo.pop(0)
+        self._redo.clear()
+
+    def _clamp(self, val: int) -> int:
+        return max(0, min(self.total_frames, val))
+
+    def _prev_end(self, idx: int) -> int:
+        return self._segments[idx - 1].end if idx > 0 else 0
+
+    def _next_start(self, idx: int) -> int:
+        if idx < len(self._segments) - 1:
+            return self._segments[idx + 1].start
+        return self.total_frames
+
+    # ------------------------------------------------------------------ undo
+
+    @property
+    def can_undo(self) -> bool:
+        return len(self._undo) > 0
+
+    @property
+    def can_redo(self) -> bool:
+        return len(self._redo) > 0
+
+    def undo(self) -> bool:
+        if not self._undo:
+            return False
+        self._redo.append(copy.deepcopy(self._segments))
+        self._segments = self._undo.pop()
+        return True
+
+    def redo(self) -> bool:
+        if not self._redo:
+            return False
+        self._undo.append(copy.deepcopy(self._segments))
+        self._segments = self._redo.pop()
+        return True
+
+    # --------------------------------------------------------------- editing
+
+    def resize(self, idx: int, edge: Literal["left", "right"], delta: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        self._snapshot()
+
+        if edge == "left":
+            new_start = self._clamp(seg.start + delta)
+            new_start = max(new_start, self._prev_end(idx))
+            if new_start >= seg.end:
+                new_start = seg.end - 1
+            seg.start = new_start
+        else:
+            new_end = self._clamp(seg.end + delta)
+            new_end = min(new_end, self._next_start(idx))
+            if new_end <= seg.start:
+                new_end = seg.start + 1
+            seg.end = new_end
+        return True
+
+    def move(self, idx: int, delta: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        length = seg.length
+        lo = self._prev_end(idx)
+        hi = self._next_start(idx)
+        if hi - lo < length:
+            return False
+        self._snapshot()
+        new_start = self._clamp(seg.start + delta)
+        new_start = max(new_start, lo)
+        if new_start + length > hi:
+            new_start = hi - length
+        seg.start = new_start
+        seg.end = new_start + length
+        return True
+
+    def reclass(self, idx: int, new_class_idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        if new_class_idx < 0 or new_class_idx >= len(self.classes):
+            return False
+        self._snapshot()
+        self._segments[idx].class_idx = new_class_idx
+        return True
+
+    def delete(self, idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        self._snapshot()
+        self._segments.pop(idx)
+        return True
+
+    def split(self, idx: int, at_frame: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        if at_frame <= seg.start or at_frame >= seg.end:
+            return False
+        self._snapshot()
+        left = Segment(seg.class_idx, seg.start, at_frame, seg.confidence)
+        right = Segment(seg.class_idx, at_frame, seg.end, seg.confidence)
+        self._segments[idx:idx + 1] = [left, right]
+        return True
+
+    def merge_with_next(self, idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments) - 1:
+            return False
+        self._snapshot()
+        left = self._segments[idx]
+        right = self._segments[idx + 1]
+        left.end = right.end
+        self._segments.pop(idx + 1)
+        return True
+
+    # -------------------------------------------------------- derived outputs
+
+    def to_frame_labels(self) -> np.ndarray:
+        labels = np.full(self.total_frames, -1, dtype=np.int32)
+        for seg in self._segments:
+            labels[seg.start:seg.end] = seg.class_idx
+        return labels
+
+    def to_dicts(self) -> list[dict]:
+        return [s.to_dict() for s in self._segments]
+
+    def to_csv_rows(self) -> list[dict]:
+        rows = []
+        for seg in self._segments:
+            if seg.class_idx < 0 or seg.class_idx >= len(self.classes):
+                name = f"class_{seg.class_idx}"
+            else:
+                name = self.classes[seg.class_idx]
+            fps = max(1e-6, self.orig_fps)
+            rows.append({
+                "Behavior": name,
+                "Start Time (s)": round(seg.start / fps, 4),
+                "End Time (s)": round(seg.end / fps, 4),
+                "Start Frame": seg.start,
+                "End Frame": seg.end,
+                "Duration (s)": round(seg.length / fps, 4),
+                "Confidence": round(seg.confidence, 4),
+            })
+        return rows
+
+    @classmethod
+    def from_frame_labels(
+        cls,
+        labels: np.ndarray,
+        classes: list[str],
+        total_frames: int,
+        orig_fps: float = 30.0,
+        confidences: Optional[np.ndarray] = None,
+    ) -> "SegmentsModel":
+        """Build from a per-frame label array (e.g. argmax output)."""
+        segments: list[Segment] = []
+        if len(labels) == 0:
+            return cls([], classes, total_frames, orig_fps)
+        current_class = int(labels[0])
+        start = 0
+        for i in range(1, len(labels)):
+            if int(labels[i]) != current_class:
+                if current_class >= 0:
+                    conf = float(confidences[start:i].mean()) if confidences is not None else 1.0
+                    segments.append(Segment(current_class, start, i, conf))
+                current_class = int(labels[i])
+                start = i
+        if current_class >= 0:
+            conf = float(confidences[start:].mean()) if confidences is not None else 1.0
+            segments.append(Segment(current_class, start, len(labels), conf))
+        return cls(segments, classes, total_frames, orig_fps)

singlebehaviorlab-2.3.0/singlebehaviorlab/demo.py

@@ -0,0 +1,131 @@
+"""Downloadable demo datasets for trying SingleBehaviorLab end-to-end.
+
+Each entry in :data:`DEMOS` maps a short name to a list of ``(filename, url)``
+pairs. :func:`load_demo` downloads the listed files into a local cache
+directory and returns a dict mapping logical asset names to absolute paths,
+so the pipeline functions can be called directly on the returned values::
+
+    import singlebehaviorlab as sbl
+
+    demo = sbl.load_demo("segmentation_clustering")
+    sbl.segment(demo["video"], demo["prompts"], "masks.h5")
+
+The asset URLs are pinned to a released tag so existing notebooks keep
+working when ``main`` moves forward.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+__all__ = ["DEMOS", "DemoAsset", "load_demo"]
+
+
+_TAG = "v2.1.0"
+_RAW_BASE = f"https://raw.githubusercontent.com/alms93/SingleBehaviorLab/{_TAG}"
+
+
+@dataclass(frozen=True)
+class DemoAsset:
+    """One file that belongs to a demo dataset."""
+
+    key: str              # logical name, e.g. "video" or "prompts"
+    filename: str         # on-disk filename under the cache directory
+    url: str              # remote URL to download from
+
+
+DEMOS: dict[str, list[DemoAsset]] = {
+    "segmentation_clustering": [
+        DemoAsset(
+            key="video",
+            filename="Demo_video.mp4",
+            url=f"{_RAW_BASE}/demo/data/segmentation_clustering/Demo_video.mp4",
+        ),
+        DemoAsset(
+            key="prompts",
+            filename="sam2_prompts.json",
+            url=f"{_RAW_BASE}/demo/data/segmentation_clustering/sam2_prompts.json",
+        ),
+    ],
+}
+
+
+def _default_cache_dir() -> Path:
+    override = os.environ.get("SBL_DEMO_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+    return Path.home() / ".cache" / "singlebehaviorlab" / "demos"
+
+
+def _download_with_progress(url: str, dest: Path) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = dest.with_suffix(dest.suffix + ".part")
+    try:
+        from tqdm.auto import tqdm as _tqdm
+    except Exception:
+        _tqdm = None  # type: ignore[assignment]
+
+    if _tqdm is None:
+        with urllib.request.urlopen(url) as response, open(tmp_path, "wb") as f:
+            shutil.copyfileobj(response, f)
+    else:
+        with urllib.request.urlopen(url) as response:
+            total = int(response.headers.get("Content-Length") or 0) or None
+            with _tqdm(
+                total=total,
+                unit="B",
+                unit_scale=True,
+                unit_divisor=1024,
+                desc=dest.name,
+                leave=False,
+            ) as bar:
+                with open(tmp_path, "wb") as f:
+                    while True:
+                        chunk = response.read(1024 * 64)
+                        if not chunk:
+                            break
+                        f.write(chunk)
+                        bar.update(len(chunk))
+    tmp_path.replace(dest)
+
+
+def load_demo(
+    name: str = "segmentation_clustering",
+    *,
+    destination: Optional[str | os.PathLike[str]] = None,
+    force: bool = False,
+) -> dict[str, str]:
+    """Download (or reuse a cached copy of) a demo dataset.
+
+    Args:
+        name: Registered demo name. Currently ``"segmentation_clustering"``
+            is the only entry; more will follow as additional demos land.
+        destination: Optional override for the cache directory. Defaults to
+            ``$SBL_DEMO_DIR`` if set, otherwise
+            ``~/.cache/singlebehaviorlab/demos/``.
+        force: Re-download even if the files already exist locally.
+
+    Returns:
+        A dict mapping each asset's ``key`` to an absolute path on disk, e.g.
+        ``{"video": "/root/.cache/.../Demo_video.mp4", "prompts": "..."}``.
+    """
+    if name not in DEMOS:
+        available = ", ".join(sorted(DEMOS.keys()))
+        raise KeyError(f"Unknown demo '{name}'. Available demos: {available}")
+
+    cache_root = Path(destination).expanduser().resolve() if destination else _default_cache_dir()
+    demo_dir = cache_root / name
+    demo_dir.mkdir(parents=True, exist_ok=True)
+
+    paths: dict[str, str] = {}
+    for asset in DEMOS[name]:
+        target = demo_dir / asset.filename
+        if force or not target.exists() or target.stat().st_size == 0:
+            _download_with_progress(asset.url, target)
+        paths[asset.key] = str(target)
+    return paths

{singlebehaviorlab-2.1.0 → singlebehaviorlab-2.3.0}/singlebehaviorlab/gui/inference_popups.py

@@ -821,193 +821,6 @@ class FrameSegmentPopupDialog(QDialog):
         add_segment_btn.clicked.connect(add_segment_chunks_to_training)
         training_layout.addWidget(add_segment_btn)
 
-        transition_len_row = QHBoxLayout()
-        transition_len_row.addWidget(QLabel("Transition clip frames:"))
-        transition_len_spin = QSpinBox()
-        transition_len_spin.setRange(2, 64)
-        transition_len_spin.setValue(int(self._widget.clip_length_spin.value()))
-        transition_len_spin.setToolTip("Number of sampled frames to save for this transition clip.")
-        transition_len_row.addWidget(transition_len_spin)
-        transition_len_row.addWidget(QLabel("Ignore ±frames:"))
-        transition_ignore_spin = QSpinBox()
-        transition_ignore_spin.setRange(0, 8)
-        transition_ignore_spin.setValue(1)
-        transition_ignore_spin.setToolTip(
-            "Frames around the exact boundary set to None (ignored during frame loss)."
-        )
-        transition_len_row.addWidget(transition_ignore_spin)
-        training_layout.addLayout(transition_len_row)
-
-        def _safe_label_token(label_text: str) -> str:
-            token = str(label_text or "").strip().replace(" ", "_").replace("/", "_").replace("\\", "_")
-            while "__" in token:
-                token = token.replace("__", "_")
-            return token.strip("_") or "class"
-
-        def _extract_transition_clip(left_seg: dict, right_seg: dict, boundary_name: str):
-            try:
-                left_idx = int(left_seg.get("class", -1))
-                right_idx = int(right_seg.get("class", -1))
-                if not (0 <= left_idx < len(self._widget.classes) and 0 <= right_idx < len(self._widget.classes)):
-                    QMessageBox.warning(self, "Invalid class", "Could not resolve neighboring segment labels.")
-                    return
-
-                left_label = self._widget.classes[left_idx]
-                right_label = self._widget.classes[right_idx]
-                clip_len = int(transition_len_spin.value())
-                if clip_len <= 1:
-                    QMessageBox.warning(self, "Invalid clip length", "Transition clip length must be >= 2.")
-                    return
-                ignore_half = int(max(0, transition_ignore_spin.value()))
-
-                clips_dir = self._widget._get_clips_dir()
-                annotation_manager = AnnotationManager(self._widget._get_annotation_file())
-                annotation_manager.add_class(left_label)
-                annotation_manager.add_class(right_label)
-
-                frame_interval = int(max(1, self._widget._get_saved_frame_interval(self._widget.video_path, orig_fps)))
-                boundary_frame = int((int(left_seg["end"]) + int(right_seg["start"])) // 2)
-                center_idx = clip_len // 2
-                clip_start_vid_frame = max(0, boundary_frame - center_idx * frame_interval)
-
-                cap_local = cv2.VideoCapture(self._widget.video_path)
-                if not cap_local.isOpened():
-                    QMessageBox.warning(self, "Error", "Could not open video file.")
-                    return
-                cap_local.set(cv2.CAP_PROP_POS_FRAMES, clip_start_vid_frame)
-                frames = []
-                sampled_video_frames = []
-                read_ctr = 0
-                while len(frames) < clip_len:
-                    ret, frame = cap_local.read()
-                    if not ret:
-                        break
-                    if read_ctr % frame_interval == 0:
-                        frames.append(frame.copy())
-                        sampled_video_frames.append(int(clip_start_vid_frame + read_ctr))
-                    read_ctr += 1
-                cap_local.release()
-
-                if not frames:
-                    QMessageBox.warning(self, "No frames", "Could not extract transition clip frames.")
-                    return
-
-                if len(frames) < clip_len:
-                    last_frame = frames[-1]
-                    last_idx = sampled_video_frames[-1]
-                    while len(frames) < clip_len:
-                        frames.append(last_frame.copy())
-                        last_idx += frame_interval
-                        sampled_video_frames.append(int(last_idx))
-
-                left_end = int(left_seg["end"]) - ignore_half * frame_interval
-                right_start = int(right_seg["start"]) + ignore_half * frame_interval
-                frame_labels = []
-                for vf in sampled_video_frames:
-                    if vf <= left_end:
-                        frame_labels.append(left_label)
-                    elif vf >= right_start:
-                        frame_labels.append(right_label)
-                    else:
-                        frame_labels.append(None)
-
-                if left_label not in frame_labels:
-                    frame_labels[0] = left_label
-                if right_label not in frame_labels:
-                    frame_labels[-1] = right_label
-
-                non_none = [x for x in frame_labels if x is not None]
-                primary_label = left_label
-                if non_none:
-                    left_count = sum(1 for x in non_none if x == left_label)
-                    right_count = sum(1 for x in non_none if x == right_label)
-                    primary_label = left_label if left_count >= right_count else right_label
-
-                video_basename = self._widget._video_basename()
-                left_tok = _safe_label_token(left_label)
-                right_tok = _safe_label_token(right_label)
-                clip_filename = (
-                    f"{video_basename}_transition_{left_tok}_to_{right_tok}_"
-                    f"frame_{clip_start_vid_frame}_len_{clip_len}.mp4"
-                )
-                clip_path = os.path.join(clips_dir, clip_filename)
-                clip_path = self._widget._unique_clip_path(clip_path)
-
-                target_fps = int(self._widget.target_fps_spin.value())
-                save_clip(frames, clip_path, target_fps)
-                if not os.path.exists(clip_path) or os.path.getsize(clip_path) == 0:
-                    QMessageBox.warning(self, "Save failed", "Failed to save transition clip.")
-                    return
-
-                clip_id = self._widget._clip_path_to_id(clip_path, clips_dir)
-                meta = {
-                    "source_video": os.path.basename(self._widget.video_path),
-                    "source_frame": int(clip_start_vid_frame),
-                    "target_fps": int(target_fps),
-                    "clip_length": int(clip_len),
-                    "added_from_inference_transition": True,
-                    "transition_direction": boundary_name,
-                    "transition_from_label": left_label,
-                    "transition_to_label": right_label,
-                    "transition_boundary_frame": int(boundary_frame),
-                    "transition_ignore_half_frames": int(ignore_half),
-                }
-                used_clip_id = annotation_manager.add_clip(clip_id, primary_label, meta=meta)
-                annotation_manager.set_frame_labels(used_clip_id, frame_labels)
-
-                n_left = sum(1 for x in frame_labels if x == left_label)
-                n_right = sum(1 for x in frame_labels if x == right_label)
-                n_ignored = sum(1 for x in frame_labels if x is None)
-                self._widget.log_text.append(
-                    f"Added transition clip ({boundary_name}): {left_label}->{right_label}, "
-                    f"frames={clip_len}, labels=({n_left}/{n_right}/ignored={n_ignored})"
-                )
-                QMessageBox.information(
-                    self,
-                    "Transition clip added",
-                    f"Saved transition training clip.\n\n"
-                    f"From: {left_label}\n"
-                    f"To: {right_label}\n"
-                    f"Direction: {boundary_name}\n"
-                    f"Clip: {os.path.basename(clip_path)}\n"
-                    f"Frame labels: {n_left} left, {n_right} right, {n_ignored} ignored",
-                )
-            except Exception as e:
-                QMessageBox.critical(self, "Error", f"Failed to add transition clip:\n{str(e)}")
-
-        transition_btn_row = QHBoxLayout()
-        prev_transition_btn = QPushButton("Add prev -> current transition clip")
-        next_transition_btn = QPushButton("Add current -> next transition clip")
-        prev_transition_btn.setStyleSheet("background-color: #4b7bec; color: white; font-weight: bold; padding: 5px;")
-        next_transition_btn.setStyleSheet("background-color: #4b7bec; color: white; font-weight: bold; padding: 5px;")
-
-        has_prev_seg = self._segment_idx is not None and self._segment_idx > 0
-        has_next_seg = self._segment_idx is not None and self._segment_idx < (len(self._widget.aggregated_segments) - 1)
-        prev_transition_btn.setEnabled(has_prev_seg)
-        next_transition_btn.setEnabled(has_next_seg)
-        prev_transition_btn.setToolTip("Create one fixed-length transition clip around the previous->current boundary.")
-        next_transition_btn.setToolTip("Create one fixed-length transition clip around the current->next boundary.")
-
-        def _add_prev_transition():
-            if not has_prev_seg:
-                return
-            prev_seg = self._widget.aggregated_segments[self._segment_idx - 1]
-            curr_seg = self._widget.aggregated_segments[self._segment_idx]
-            _extract_transition_clip(prev_seg, curr_seg, "prev_to_current")
-
-        def _add_next_transition():
-            if not has_next_seg:
-                return
-            curr_seg = self._widget.aggregated_segments[self._segment_idx]
-            next_seg = self._widget.aggregated_segments[self._segment_idx + 1]
-            _extract_transition_clip(curr_seg, next_seg, "current_to_next")
-
-        prev_transition_btn.clicked.connect(_add_prev_transition)
-        next_transition_btn.clicked.connect(_add_next_transition)
-        transition_btn_row.addWidget(prev_transition_btn)
-        transition_btn_row.addWidget(next_transition_btn)
-        training_layout.addLayout(transition_btn_row)
-
         training_group.setLayout(training_layout)
         layout.addWidget(training_group)