simple-sam2 0.1.0__py3-none-any.whl

simple_sam2/__init__.py

@@ -0,0 +1,17 @@
+"""
+simple-sam2
+===========
+
+A lightweight wrapper around Meta's SAM2 video predictor that makes
+long-video segmentation practical:
+
+- **Unified prompt API** — mix points, boxes, and masks in one call.
+- **Batch processing** — only ``batch_size`` frames in GPU memory at once.
+- **Incremental propagation** — segment, inspect, correct, and continue.
+
+"""
+
+from .service import SAM2Service
+
+__all__ = ["SAM2Service"]
+__version__ = "0.1.0"

simple_sam2/service.py

@@ -0,0 +1,720 @@
+import os
+import torch
+import numpy as np
+from pathlib import Path
+from PIL import Image
+from sam2.build_sam import build_sam2_video_predictor
+import shutil
+import cv2
+from typing import Optional, Dict, List, Tuple, Callable
+
+
+# Default storage root in cwd.
+_DEFAULT_STORAGE = str(Path.cwd() / "simple_sam2_storage")
+
+
+def _sanitize_label(label: str) -> str:
+    """Sanitize label for safe use in filenames."""
+    safe = "".join(c if c.isalnum() or c == "-" else "-" for c in label)
+    return safe[:50] if safe else "object"
+
+
+class SAM2Service:
+    """
+    A wrapper around Meta's SAM2 video predictor that adds:
+
+    1. **Unified prompt handler** — accepts points, boxes, and masks together
+       in a single call (SAM2 natively only accepts masks OR points+box).
+    2. **Incremental frame segmentation** — segment N frames at a time so the
+       user can inspect and correct before continuing (useful at occlusions).
+    3. **Batch processing for long videos** — loads only ``batch_size`` frames
+       at a time, keeping GPU/CPU memory usage constant regardless of video
+       length.
+
+    Storage layout
+    --------------
+    All files are written under ``storage_dir`` (default:
+    ``<cwd>/simple_sam2_storage``)::
+
+        simple_sam2_storage/
+        └── <video_name>/
+            ├── frames/        # extracted JPEG frames  (00000.jpg, …)
+            ├── masks/         # output PNGs            (00042_1_person.png, …)
+            └── tmp_batches/   # transient working dirs (auto-cleaned)
+
+    Quick start
+    -----------
+    ::
+
+        from simple_sam2 import SAM2Service
+
+        svc = SAM2Service(cfg="sam2.1_hiera_t.yaml", ckpt="sam2.1_hiera_tiny.pt")
+
+        info = svc.init_video("demo", video_path="clip.mp4")
+        print(info["total_frames"], info["frame_dir"], info["masks_dir"])
+
+        svc.add_prompts("demo", frame_idx=0, obj_id=1, pos_points=[[320, 240]])
+
+        n = svc.propagate_and_save(
+            "demo",
+            obj_labels={"1": "person"},
+            progress_callback=lambda p: print(f"{p:.1f}%"),
+        )
+        svc.clear_video("demo")
+    """
+
+    def __init__(
+        self,
+        cfg: str,
+        ckpt: str,
+        batch_size: int = 10,
+        storage_dir: str = _DEFAULT_STORAGE,
+    ):
+        """
+        Parameters
+        ----------
+        cfg : str
+            Path to a SAM2 YAML config file.
+            Configs live in the SAM2 repo under
+            ``sam2/configs/sam2.1/``.
+        ckpt : str
+            Path to a SAM2 checkpoint ``.pt`` file.
+            Download from https://github.com/facebookresearch/sam2#model-description
+        batch_size : int
+            Number of frames loaded into memory at once.
+            Reduce if you run out of GPU/CPU memory. Default: 10.
+        storage_dir : str
+            Root directory for all simple-sam2 data.
+            Defaults to ``simple_sam2_storage/`` in the current working
+            directory.
+        """
+        if torch.cuda.is_available():
+            self.device = "cuda"
+        elif torch.backends.mps.is_available():
+            self.device = "mps"
+        else:
+            self.device = "cpu"
+
+        self.cfg = cfg
+        self.ckpt = ckpt
+        self.batch_size = batch_size
+        self.storage_dir = storage_dir
+        self._predictor = None
+
+        self.video_metadata: Dict[str, Dict] = {}
+        self.current_batch_info: Dict[str, Dict] = {}
+        self.prompt_info: Dict[str, Dict] = {}
+
+    # ── Model loading ────────────────────────────────────────────────────────
+
+    def _get_predictor(self):
+        """Lazily build and cache the SAM2 predictor (weights loaded once)."""
+        if self._predictor is None:
+            if not os.path.exists(self.ckpt):
+                raise FileNotFoundError(
+                    f"Checkpoint not found: {self.ckpt}\n"
+                    "Download SAM2 weights from "
+                    "https://github.com/facebookresearch/sam2#model-description"
+                )
+            self._predictor = build_sam2_video_predictor(
+                config_file=self.cfg,
+                ckpt_path=self.ckpt,
+                device=self.device,
+                vos_optimized=False,
+            )
+        return self._predictor
+
+    # ── Mask conversion helpers ──────────────────────────────────────────────
+
+    @staticmethod
+    def _logits_to_uint8(logit_tensor: torch.Tensor) -> np.ndarray:
+        """Convert SAM2 logit tensor → uint8 mask (0 or 255)."""
+        mask = (logit_tensor > 0).cpu().numpy().astype("uint8") * 255
+        return np.squeeze(mask)
+
+    @staticmethod
+    def _logits_to_bool(logit_tensor: torch.Tensor) -> np.ndarray:
+        """Convert SAM2 logit tensor → boolean mask."""
+        mask = (logit_tensor > 0).cpu().numpy().astype(bool)
+        return np.squeeze(mask)
+
+    # ── Path helpers ─────────────────────────────────────────────────────────
+
+    def _video_dir(self, video_name: str) -> str:
+        return os.path.join(self.storage_dir, video_name)
+
+    def _frames_dir(self, video_name: str) -> str:
+        return os.path.join(self._video_dir(video_name), "frames")
+
+    def _masks_dir(self, video_name: str) -> str:
+        return os.path.join(self._video_dir(video_name), "masks")
+
+    def _tmp_batches_dir(self, video_name: str) -> str:
+        return os.path.join(self._video_dir(video_name), "tmp_batches")
+
+    # ── Batch / frame helpers ────────────────────────────────────────────────
+
+    def _get_batch_number(self, frame_idx: int) -> int:
+        return frame_idx // self.batch_size
+
+    def _get_batch_frame_range(self, batch_num: int, total_frames: int) -> Tuple[int, int]:
+        start = batch_num * self.batch_size
+        end = min(start + self.batch_size, total_frames)
+        return start, end
+
+    def _get_frame_files(self, frame_dir: str) -> List[str]:
+        return sorted(
+            f for f in os.listdir(frame_dir)
+            if f.lower().endswith((".jpg", ".jpeg", ".png"))
+        )
+
+    def _count_frames(self, frame_dir: str) -> int:
+        return len(self._get_frame_files(frame_dir))
+
+    def _create_batch_folder(
+        self,
+        video_name: str,
+        batch_num: int,
+        total_frames: int,
+    ) -> str:
+        """
+        Copy the frames for *batch_num* into a temp directory,
+        renumbered from 00000 so SAM2 can load them in order.
+        """
+        batch_dir = os.path.join(
+            self._tmp_batches_dir(video_name), f"batch_{batch_num}"
+        )
+        if os.path.exists(batch_dir):
+            shutil.rmtree(batch_dir)
+        os.makedirs(batch_dir, exist_ok=True)
+
+        source_dir = self._frames_dir(video_name)
+        start_frame, end_frame = self._get_batch_frame_range(batch_num, total_frames)
+        all_frames = self._get_frame_files(source_dir)
+
+        for i, frame_idx in enumerate(range(start_frame, end_frame)):
+            if frame_idx < len(all_frames):
+                src = os.path.join(source_dir, all_frames[frame_idx])
+                _, ext = os.path.splitext(all_frames[frame_idx])
+                dst = os.path.join(batch_dir, f"{i:05d}{ext}")
+                if os.path.exists(src):
+                    shutil.copy(src, dst)
+                else:
+                    print(f"Warning: source frame missing: {src}")
+
+        return batch_dir
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def _extract_frames(self, video_path: str, frame_dir: str) -> int:
+        """Extract frames from a video file into *frame_dir* using cv2."""
+        os.makedirs(frame_dir, exist_ok=True)
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise RuntimeError(f"Could not open video file: {video_path}")
+
+        frame_idx = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            out_path = os.path.join(frame_dir, f"{frame_idx:05d}.jpg")
+            cv2.imwrite(out_path, frame)
+            frame_idx += 1
+
+        cap.release()
+        if frame_idx == 0:
+            raise RuntimeError(f"No frames could be extracted from: {video_path}")
+
+        print(f"Extracted {frame_idx} frames to {frame_dir}")
+        return frame_idx
+
+    def init_video(self, video_name: str, video_path: str) -> Dict:
+        """
+        Register a video and set up its storage layout.
+
+        Frames are extracted automatically from *video_path* using cv2.
+        No model weights are loaded yet — GPU memory is only touched when
+        :meth:`add_prompts` or :meth:`propagate_and_save` is called.
+
+        Storage layout created::
+
+            simple_sam2_storage/
+            └── <video_name>/
+                ├── frames/       ← extracted frames land here
+                ├── masks/        ← propagate_and_save() writes here
+                └── tmp_batches/  ← transient; auto-managed
+
+        If frames have already been extracted (e.g. from a previous run),
+        extraction is skipped automatically.
+
+        Parameters
+        ----------
+        video_name : str
+            Unique identifier for this video used in all subsequent calls.
+        video_path : str
+            Path to the video file (.mp4, .avi, .mov, …).
+
+        Returns
+        -------
+        dict
+            ``total_frames``, ``total_batches``, ``batch_size``,
+            ``frame_dir``, ``masks_dir``.
+
+        Example
+        -------
+        ::
+
+            info = svc.init_video("clip1", video_path="/data/videos/clip1.mp4")
+            print(info["total_frames"])
+            print(info["masks_dir"])
+        """
+        video_path = str(video_path)
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file does not exist: {video_path}")
+
+        # Create the canonical folder layout.
+        frame_dir  = self._frames_dir(video_name)
+        masks_dir  = self._masks_dir(video_name)
+        tmp_dir    = self._tmp_batches_dir(video_name)
+        for d in (frame_dir, masks_dir, tmp_dir):
+            os.makedirs(d, exist_ok=True)
+
+        # Extract frames (skip if already done).
+        if self._count_frames(frame_dir) > 0:
+            print(f"Frames already extracted at {frame_dir}, reusing.")
+            total_frames = self._count_frames(frame_dir)
+        else:
+            print(f"Extracting frames from {video_path} …")
+            total_frames = self._extract_frames(video_path, frame_dir)
+
+        total_batches = (total_frames + self.batch_size - 1) // self.batch_size
+
+        self.video_metadata[video_name] = {
+            "frame_dir":    frame_dir,
+            "masks_dir":    masks_dir,
+            "total_frames": total_frames,
+            "total_batches": total_batches,
+        }
+        self.current_batch_info[video_name] = {
+            "batch_num": None,
+            "state":     None,
+            "batch_dir": None,
+        }
+        self.prompt_info[video_name] = {}
+
+        return {
+            "total_frames":  total_frames,
+            "total_batches": total_batches,
+            "batch_size":    self.batch_size,
+            "frame_dir":     frame_dir,
+            "masks_dir":     masks_dir,
+        }
+
+    def add_prompts(
+        self,
+        video_name: str,
+        frame_idx: int,
+        obj_id: int,
+        pos_points: Optional[List[List[int]]] = None,
+        neg_points: Optional[List[List[int]]] = None,
+        box: Optional[List[int]] = None,
+        binary_mask: Optional[np.ndarray] = None,
+    ) -> np.ndarray:
+        """
+        Add prompts for an object at a specific frame.
+
+        Any combination of mask, positive/negative points, and bounding box
+        is accepted in a single call. The mask is applied first (SAM2
+        requirement), then points and box refine it.
+
+        Parameters
+        ----------
+        video_name : str
+            Video registered with :meth:`init_video`.
+        frame_idx : int
+            Global frame index where the object first appears.
+        obj_id : int
+            Integer ID for this object. Use different IDs for different objects.
+        pos_points : list of [x, y], optional
+            Positive click points (include the object).
+        neg_points : list of [x, y], optional
+            Negative click points (exclude these regions).
+        box : list of [x1, y1, x2, y2], optional
+            Bounding box around the object.
+        binary_mask : np.ndarray (H, W), optional
+            Boolean or uint8 initial mask.
+
+        Returns
+        -------
+        np.ndarray
+            uint8 mask (0 or 255) for the object at *frame_idx*.
+
+        Example
+        -------
+        ::
+
+            mask = svc.add_prompts(
+                "clip1", frame_idx=0, obj_id=1,
+                pos_points=[[320, 240]],
+                box=[200, 150, 450, 380],
+            )
+        """
+        if video_name not in self.video_metadata:
+            raise RuntimeError(
+                f"Video '{video_name}' not initialised. Call init_video() first."
+            )
+
+        state, batch_frame_idx = self._batch_relative_frame_idx(video_name, frame_idx)
+        predictor = self._get_predictor()
+
+        self.prompt_info[video_name][obj_id] = {
+            "frame_idx":   frame_idx,
+            "pos_points":  pos_points,
+            "neg_points":  neg_points,
+            "box":         box,
+            "binary_mask": binary_mask.copy() if binary_mask is not None else None,
+        }
+
+        has_points = bool(
+            (pos_points and len(pos_points) > 0)
+            or (neg_points and len(neg_points) > 0)
+        )
+        has_box  = box is not None
+        has_mask = binary_mask is not None
+
+        if not has_mask and not has_points and not has_box:
+            raise ValueError(
+                "Provide at least one of: binary_mask, pos_points/neg_points, or box."
+            )
+
+        with torch.inference_mode():
+            if has_mask:
+                _, out_obj_ids, out_mask_logits = predictor.add_new_mask(
+                    inference_state=state,
+                    frame_idx=batch_frame_idx,
+                    obj_id=obj_id,
+                    mask=binary_mask.astype(bool),
+                )
+
+            if has_points or has_box:
+                all_points, all_labels = [], []
+                if pos_points:
+                    all_points.extend(pos_points)
+                    all_labels.extend([1] * len(pos_points))
+                if neg_points:
+                    all_points.extend(neg_points)
+                    all_labels.extend([0] * len(neg_points))
+
+                kwargs: Dict = dict(
+                    inference_state=state,
+                    frame_idx=batch_frame_idx,
+                    obj_id=obj_id,
+                )
+                if all_points:
+                    kwargs["points"] = np.array(all_points, dtype=np.float32)
+                    kwargs["labels"] = np.array(all_labels, dtype=np.int32)
+                if box:
+                    kwargs["box"] = np.array(box, dtype=np.float32)
+
+                _, out_obj_ids, out_mask_logits = predictor.add_new_points_or_box(**kwargs)
+
+        obj_index = list(out_obj_ids).index(obj_id) if obj_id in out_obj_ids else 0
+        return self._logits_to_uint8(out_mask_logits[obj_index])
+
+    def propagate_and_save(
+        self,
+        video_name: str,
+        out_dir: Optional[str] = None,
+        start_frame_idx: int = 0,
+        end_frame_idx: Optional[int] = None,
+        obj_labels: Optional[Dict[str, str]] = None,
+        progress_callback: Optional[Callable[[float], None]] = None,
+    ) -> int:
+        """
+        Propagate all tracked objects through the video and save masks.
+
+        Uses batch processing so memory usage stays proportional to
+        ``batch_size`` regardless of video length. Between batches, the last
+        frame's mask is carried over as the initialisation prompt for the next
+        batch.
+
+        Output filenames follow the pattern::
+
+            <frame_index>_<obj_id>_<label>.png
+            # e.g. 00042_1_person.png
+
+        Parameters
+        ----------
+        video_name : str
+            Video registered with :meth:`init_video`.
+        out_dir : str, optional
+            Directory where mask PNGs are written. Defaults to
+            ``simple_sam2_storage/<video_name>/masks/``.
+        start_frame_idx : int
+            First global frame to process. Default: 0.
+        end_frame_idx : int, optional
+            Last global frame (exclusive). Defaults to end of video.
+        obj_labels : dict, optional
+            ``{str(obj_id): "label"}`` mapping used in output filenames.
+            Example: ``{"1": "person", "2": "car"}``.
+        progress_callback : callable, optional
+            Called with a float in 0–100 after each frame is processed.
+
+        Returns
+        -------
+        int
+            Total number of mask files saved.
+
+        Example
+        -------
+        ::
+
+            n = svc.propagate_and_save(
+                "clip1",
+                obj_labels={"1": "person", "2": "car"},
+                progress_callback=lambda p: print(f"{p:.1f}%"),
+            )
+            print(f"Saved {n} masks")
+        """
+        if video_name not in self.video_metadata:
+            raise RuntimeError(
+                f"Video '{video_name}' not initialised. Call init_video() first."
+            )
+        if not self.prompt_info.get(video_name):
+            raise RuntimeError(
+                "No prompts added. Call add_prompts() before propagate_and_save()."
+            )
+
+        metadata  = self.video_metadata[video_name]
+        predictor = self._get_predictor()
+
+        # Default output to the canonical masks/ folder.
+        if out_dir is None:
+            out_dir = metadata["masks_dir"]
+        out_dir = str(out_dir)
+        os.makedirs(out_dir, exist_ok=True)
+
+        obj_labels = obj_labels or {}
+
+        total_frames   = metadata["total_frames"]
+        total_batches  = metadata["total_batches"]
+        end_frame_idx  = end_frame_idx if end_frame_idx is not None else total_frames
+        total_to_process = max(1, end_frame_idx - start_frame_idx)
+        processed_so_far = 0
+
+        start_batch = self._get_batch_number(start_frame_idx)
+        end_batch   = self._get_batch_number(min(end_frame_idx - 1, total_frames - 1))
+
+        saved: int = 0
+        last_batch_masks: Dict[int, np.ndarray] = {}
+        batch_prompt_frame: int = 0
+
+        for batch_num in range(start_batch, end_batch + 1):
+            print(f"\nProcessing batch {batch_num + 1}/{total_batches}")
+            batch_start, batch_end = self._get_batch_frame_range(batch_num, total_frames)
+            print(f"  Global frames: {batch_start} – {batch_end - 1}")
+
+            state = self._load_batch(video_name, batch_num)
+
+            for obj_id, prompt_data in self.prompt_info[video_name].items():
+                original_frame = prompt_data["frame_idx"]
+                prompt_batch   = self._get_batch_number(original_frame)
+
+                if batch_num == prompt_batch:
+                    batch_prompt_frame = original_frame - batch_start
+                    print(f"  Obj {obj_id}: original prompts at batch-frame {batch_prompt_frame}")
+                    self._apply_prompts_to_state(
+                        state, batch_prompt_frame, obj_id,
+                        prompt_data["pos_points"],
+                        prompt_data["neg_points"],
+                        prompt_data["box"],
+                        prompt_data["binary_mask"],
+                    )
+
+                elif batch_num > prompt_batch:
+                    if obj_id in last_batch_masks:
+                        print(f"  Obj {obj_id}: carried mask from previous batch → frame 0")
+                        self._apply_prompts_to_state(
+                            state, 0, obj_id,
+                            binary_mask=last_batch_masks[obj_id],
+                        )
+                    else:
+                        print(f"  Warning: obj {obj_id} has no carried mask, skipping.")
+                        continue
+
+            with torch.inference_mode():
+                for out_frame_idx, out_obj_ids, out_mask_logits in predictor.propagate_in_video(
+                    state,
+                    start_frame_idx=batch_prompt_frame if batch_num == start_batch else 0,
+                ):
+                    global_frame_idx = batch_start + out_frame_idx
+
+                    if global_frame_idx < start_frame_idx or global_frame_idx >= end_frame_idx:
+                        continue
+
+                    processed_so_far += 1
+                    if progress_callback:
+                        progress_callback(
+                            min(100.0, processed_so_far / total_to_process * 100.0)
+                        )
+
+                    for i, out_obj_id in enumerate(out_obj_ids):
+                        mask_uint8 = self._logits_to_uint8(out_mask_logits[i])
+                        label = obj_labels.get(str(out_obj_id), f"Object{out_obj_id}")
+                        fname = (
+                            f"{global_frame_idx:05d}"
+                            f"_{out_obj_id}"
+                            f"_{_sanitize_label(label)}.png"
+                        )
+                        Image.fromarray(mask_uint8).save(os.path.join(out_dir, fname))
+                        saved += 1
+
+                        # Store carry-over mask for the next batch.
+                        if out_frame_idx == (batch_end - batch_start - 1):
+                            last_batch_masks[out_obj_id] = self._logits_to_bool(
+                                out_mask_logits[i]
+                            )
+                            print(f"  Stored carry-over mask for obj {out_obj_id}")
+
+            print(f"  Running total: {saved} masks saved")
+
+            if batch_num < end_batch:
+                torch.cuda.empty_cache()
+
+        print(f"\nDone. Saved {saved} masks to: {out_dir}")
+        return saved
+
+    def clear_video(self, video_name: str, delete_storage: bool = False) -> None:
+        """
+        Free all memory and temp files associated with a video.
+
+        Parameters
+        ----------
+        video_name : str
+            Video to clear.
+        delete_storage : bool
+            If ``True``, delete the entire video directory
+            (``simple_sam2_storage/<video_name>/``) including frames, masks,
+            and tmp_batches. Default: ``False``.
+        """
+        self.current_batch_info.pop(video_name, {})
+
+        if delete_storage:
+            video_dir = self._video_dir(video_name)
+            if os.path.exists(video_dir):
+                try:
+                    shutil.rmtree(video_dir)
+                    print(f"Deleted storage directory: {video_dir}")
+                except Exception as e:
+                    print(f"Warning: could not remove storage dir {video_dir}: {e}")
+        else:
+            # Only clean up the transient tmp_batches folder.
+            tmp_dir = self._tmp_batches_dir(video_name)
+            if os.path.exists(tmp_dir):
+                try:
+                    shutil.rmtree(tmp_dir)
+                except Exception as e:
+                    print(f"Warning: could not remove tmp_batches dir {tmp_dir}: {e}")
+
+        self.video_metadata.pop(video_name, None)
+        self.prompt_info.pop(video_name, None)
+
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        print(f"Cleared '{video_name}' from memory.")
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _load_batch(self, video_name: str, batch_num: int):
+        """Load a batch into a fresh SAM2 inference state."""
+        metadata  = self.video_metadata[video_name]
+        predictor = self._get_predictor()
+
+        batch_dir   = self._create_batch_folder(
+            video_name, batch_num, metadata["total_frames"]
+        )
+        batch_frames = self._get_frame_files(batch_dir)
+        if not batch_frames:
+            raise RuntimeError(f"Batch directory is empty: {batch_dir}")
+
+        print(f"  Loading {len(batch_frames)} frames from {batch_dir}")
+
+        with torch.inference_mode():
+            state = predictor.init_state(video_path=batch_dir)
+            predictor.reset_state(state)
+
+        self.current_batch_info[video_name] = {
+            "batch_num": batch_num,
+            "state":     state,
+            "batch_dir": batch_dir,
+        }
+        return state
+
+    def _batch_relative_frame_idx(
+        self, video_name: str, frame_idx: int
+    ) -> Tuple[object, int]:
+        """Return (state, batch_local_frame_idx), loading a new batch if needed."""
+        batch_num    = self._get_batch_number(frame_idx)
+        current_info = self.current_batch_info.get(video_name, {})
+
+        if current_info.get("batch_num") != batch_num or current_info.get("state") is None:
+            state = self._load_batch(video_name, batch_num)
+        else:
+            state = current_info["state"]
+
+        start_frame, _ = self._get_batch_frame_range(
+            batch_num, self.video_metadata[video_name]["total_frames"]
+        )
+        return state, frame_idx - start_frame
+
+    def _apply_prompts_to_state(
+        self,
+        state,
+        batch_frame_idx: int,
+        obj_id: int,
+        pos_points: Optional[List[List[int]]] = None,
+        neg_points: Optional[List[List[int]]] = None,
+        box: Optional[List[int]] = None,
+        binary_mask: Optional[np.ndarray] = None,
+    ) -> None:
+        """Apply prompts to a batch state (used internally between batches)."""
+        predictor = self._get_predictor()
+        has_points = bool(
+            (pos_points and len(pos_points) > 0)
+            or (neg_points and len(neg_points) > 0)
+        )
+        has_box  = box is not None
+        has_mask = binary_mask is not None
+
+        with torch.inference_mode():
+            if has_mask:
+                predictor.add_new_mask(
+                    inference_state=state,
+                    frame_idx=batch_frame_idx,
+                    obj_id=obj_id,
+                    mask=binary_mask.astype(bool),
+                )
+
+            if has_points or has_box:
+                all_points, all_labels = [], []
+                if pos_points:
+                    all_points.extend(pos_points)
+                    all_labels.extend([1] * len(pos_points))
+                if neg_points:
+                    all_points.extend(neg_points)
+                    all_labels.extend([0] * len(neg_points))
+
+                kwargs: Dict = dict(
+                    inference_state=state,
+                    frame_idx=batch_frame_idx,
+                    obj_id=obj_id,
+                )
+                if all_points:
+                    kwargs["points"] = np.array(all_points, dtype=np.float32)
+                    kwargs["labels"] = np.array(all_labels, dtype=np.int32)
+                if box:
+                    kwargs["box"] = np.array(box, dtype=np.float32)
+
+                predictor.add_new_points_or_box(**kwargs)

simple_sam2-0.1.0.dist-info/METADATA

@@ -0,0 +1,376 @@
+Metadata-Version: 2.4
+Name: simple-sam2
+Version: 0.1.0
+Summary: A lightweight wrapper around Meta SAM2 for practical long-video segmentation.
+Author-email: Varun Kolluru <your@email.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship made available under
+              the License, as indicated by a copyright notice that is included in
+              or attached to the work (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean, as submitted to the Licensor for inclusion
+              in the Work by the copyright owner or by an individual or Legal Entity
+              authorized to submit on behalf of the copyright owner. For the purposes
+              of this definition, "submitted" means any form of electronic, verbal,
+              or written communication sent to the Licensor or its representatives,
+              including but not limited to communication on electronic mailing lists,
+              source code control systems, and issue tracking systems that are managed
+              by, or on behalf of, the Licensor for the purpose of discussing and
+              improving the Work.
+        
+              "Contributor" shall mean Licensor and any Legal Entity on behalf of
+              whom a Contribution has been received by the Licensor and included
+              within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by the combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a cross-claim
+              or counterclaim in a lawsuit) alleging that the Work or any
+              Contribution embodied within the Work constitutes direct or
+              contributory patent infringement, then any patent licenses granted to
+              You under this License for that Work shall terminate as of the date
+              such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or Derivative Works
+                  a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, You must include a readable copy of the attribution
+                  notices contained within such NOTICE file, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own license statement for Your modifications and
+              may provide additional grant of rights to use, copy, modify, merge,
+              publish, distribute, sublicense, and/or sell copies of the
+              Contribution, either on an inclusive or exclusive basis, as You
+              determine appropriate, for any period, or Your discretion.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or reproducing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or exemplary damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or all other
+              commercial damages or losses), even if such Contributor has been
+              advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           Copyright 2026 Varun Kolluru
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+Project-URL: Homepage, https://github.com/varun-kolluru/simple-sam2
+Project-URL: Repository, https://github.com/varun-kolluru/simple-sam2
+Project-URL: Bug Tracker, https://github.com/varun-kolluru/simple-sam2/issues
+Keywords: sam2,segmentation,video,computer vision,meta ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: torch>=2.0
+Requires-Dist: torchvision
+Requires-Dist: numpy
+Requires-Dist: Pillow
+Requires-Dist: opencv-python>=4.8
+Dynamic: license-file
+
+# simple-sam2
+
+A lightweight Python wrapper around [Meta SAM2](https://github.com/facebookresearch/sam2) that makes long-video segmentation practical.
+
+## What this adds on top of SAM2
+
+| Problem | What simple-sam2 does |
+|---|---|
+| SAM2 only accepts mask OR points+box separately | **Unified prompt API** — pass mask, points, and box together in one call |
+| SAM2 loads the entire video into memory | **Batch processing** — only `batch_size` frames in memory at once |
+| No way to inspect/correct mid-video | **Incremental propagation** — segment N frames, check, then continue |
+
+---
+
+## Installation
+
+```bash
+# 1. Install SAM2 manually first (not on PyPI)
+pip install git+https://github.com/facebookresearch/sam2.git
+
+# 2. Then install simple-sam2
+pip install simple-sam2
+```
+
+> **Note:** SAM2 is a dependency which is installed from Meta's GitHub repo. You still need to **download the model weights** separately (see below).
+
+### Download SAM2 weights
+
+```bash
+# Tiny (fastest)
+wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_tiny.pt
+
+# Small
+wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_small.pt
+
+# Base+
+wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_base_plus.pt
+
+# Large (most accurate)
+wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt
+```
+
+The matching config files are bundled with the `sam2` package — pass the config name directly (e.g. `"sam2.1_hiera_t.yaml"`).
+
+---
+
+## Quick start
+
+```python
+from simple_sam2 import SAM2Service
+
+CONFIG  = "configs/sam2.1/sam2.1_hiera_t.yaml" # or if want to use sam2 then path is :- configs/sam2/sam2_hiera_t.yaml        
+WEIGHTS = "path/to/sam2.1_hiera_tiny.pt".      # make sure .pt file matches the config
+VIDEO   = "path/to/my_video.mp4"
+
+#Note:- you only have to download weights (.pt) files, config files are already present at configs/ dir of sam2
+
+svc = SAM2Service(cfg=CONFIG, ckpt=WEIGHTS, batch_size=10)
+```
+
+### 1. Initialise the video
+
+```python
+info = svc.init_video("demo", video_path=VIDEO)
+print(f"Video has {info['total_frames']} frames")
+print(f"Frames extracted to: {info['frame_dir']}")
+print(f"Masks will be saved to: {info['masks_dir']}")
+```
+
+This creates the following layout under `simple_sam2_storage/` in your current directory:
+
+```
+simple_sam2_storage/
+└── demo/
+    ├── frames/       ← extracted JPEG frames (00000.jpg, 00001.jpg, …)
+    ├── masks/        ← output masks written here
+    └── tmp_batches/  ← transient working dirs (auto-managed)
+```
+
+If frames are already extracted from a previous run, extraction is skipped automatically.
+
+### 2. Add prompts
+
+```python
+# Positive click only
+svc.add_prompts("demo", frame_idx=0, obj_id=1, pos_points=[[320, 240]])
+
+# Or mix points + bounding box
+svc.add_prompts(
+    "demo", frame_idx=0, obj_id=2,
+    pos_points=[[400, 300]],
+    neg_points=[[100, 100]],
+    box=[200, 150, 600, 480],
+)
+```
+
+### 3. Propagate and save
+
+```python
+n = svc.propagate_and_save(
+    "demo",
+    start_frame_idx=0,
+    end_frame_idx=5,                       # optional, defaults to end of video
+    obj_labels={"1": "person", "2": "car"},
+    progress_callback=lambda p: print(f"Progress: {p:.1f}%"),
+)
+print(f"Done! Saved {n} masks to {info['masks_dir']}")
+```
+
+Output filenames follow the pattern `<frame_index>_<obj_id>_<label>.png`:
+
+```
+masks/
+├── 00000_1_person.png
+├── 00001_1_person.png
+├── 00000_2_car.png
+...
+```
+
+### 4. Clean up
+
+```python
+svc.clear_video("demo")                    # free GPU memory
+svc.clear_video("demo", delete_storage= True)  # delete all video related frames, tmp_batches, masks
+```
+
+---
+
+## API reference
+
+### `SAM2Service(cfg, ckpt, batch_size=10, storage_dir=...)`
+
+| Parameter | Description |
+|---|---|
+| `cfg` | SAM2 YAML config name concatenated to configs/sam2.1/ for sam2.1 or configs/sam2/ for sam2 (e.g. `"configs/sam2.1/sam2.1_hiera_t.yaml"`) |
+| `ckpt` | Path to SAM2 `.pt` checkpoint file |
+| `batch_size` | Frames in memory at once. Reduce if you run out of GPU memory |
+| `storage_dir` | Root directory for all data. Defaults to `<cwd>/simple_sam2_storage` |
+
+### `init_video(video_name, video_path)`
+
+Extracts frames and sets up storage. Returns a dict with `total_frames`, `total_batches`, `batch_size`, `frame_dir`, `masks_dir`.
+
+### `add_prompts(video_name, frame_idx, obj_id, pos_points, neg_points, box, binary_mask)`
+
+All prompt types are optional — provide at least one. Returns a uint8 preview mask (0 or 255).
+
+### `propagate_and_save(video_name, out_dir, start_frame_idx, end_frame_idx, obj_labels, progress_callback)`
+
+Propagates all tracked objects and saves mask PNGs. `out_dir` defaults to `simple_sam2_storage/<video_name>/masks/`. Returns the number of files saved.
+
+### `clear_video(video_name, delete_storag=False)`
+
+Frees GPU memory and removes temp files. Pass `delete_storage= True` to also delete the extracted frames,masks directory.
+
+---
+
+## License
+
+Apache 2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).
+
+SAM2 is © Meta Platforms, Inc. and affiliates, also under Apache 2.0.

simple_sam2-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+simple_sam2/__init__.py,sha256=vn332po0xmxr6BDTI7u4TxlFYQ2NDniQ9i6KTYkDO1g,444
+simple_sam2/service.py,sha256=vpmy3dJZDG7J7ulc4w-ZzxF4yZTxMErtfc6MiN8EF0I,27623
+simple_sam2-0.1.0.dist-info/licenses/LICENSE,sha256=ftx_OeO8adhbEG42EcfUyU210Qs6nO2ogRBVkIoMg2U,10158
+simple_sam2-0.1.0.dist-info/licenses/NOTICE,sha256=jSAaZTpnNcH_cZ2iJRChIPPlO8XfuxyOGeGn0yi9oXc,490
+simple_sam2-0.1.0.dist-info/METADATA,sha256=vHL6_eD7J2huIt3Evwy5IbundOWK7doljnxuR2ih468,18077
+simple_sam2-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simple_sam2-0.1.0.dist-info/top_level.txt,sha256=vGsiJ1TIFnQo4fA3DcQMOJewcPOZ4A-AKhNnjTsif7I,12
+simple_sam2-0.1.0.dist-info/RECORD,,

simple_sam2-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simple_sam2-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,182 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work.
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any
+      Contribution embodied within the Work constitutes direct or
+      contributory patent infringement, then any patent licenses granted to
+      You under this License for that Work shall terminate as of the date
+      such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative Works
+          a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the attribution
+          notices contained within such NOTICE file, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Contribution, either on an inclusive or exclusive basis, as You
+      determine appropriate, for any period, or Your discretion.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Varun Kolluru
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

simple_sam2-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,12 @@
+simple-sam2
+Copyright 2026 Varun Kolluru
+
+This project is a wrapper around SAM2 (Segment Anything Model 2) by Meta AI Research.
+
+SAM2 Repository : https://github.com/facebookresearch/sam2
+SAM2 License    : Apache 2.0
+SAM2 Copyright  : Copyright (c) Meta Platforms, Inc. and affiliates.
+
+In compliance with the Apache 2.0 License, the original SAM2 license and
+copyright notice are reproduced above. This project does not redistribute
+SAM2 source code; it declares SAM2 as a pip dependency.

simple_sam2-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simple_sam2