supervisely 6.73.418__py3-none-any.whl → 6.73.420__py3-none-any.whl

supervisely/nn/tracker/botsort_tracker.py

@@ -0,0 +1,259 @@
+import supervisely as sly
+from supervisely.nn.tracker.base_tracker import BaseTracker
+from supervisely.nn.tracker.botsort.tracker.mc_bot_sort import BoTSORT
+from supervisely import Annotation, VideoAnnotation
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import List, Dict, Tuple, Any, Optional
+import numpy as np
+import yaml
+import os
+from pathlib import Path
+from supervisely import logger
+
+
+@dataclass
+class TrackedObject:
+    """
+    Data class representing a tracked object in a single frame.
+    
+    Args:
+        track_id: Unique identifier for the track
+        det_id: Detection ID for mapping back to original annotation
+        bbox: Bounding box coordinates in format [x1, y1, x2, y2]
+        class_name: String class name
+        class_sly_id: Supervisely class ID (from ObjClass.sly_id)
+        score: Confidence score of the detection/track
+    """
+    track_id: int
+    det_id: int
+    bbox: List[float]  # [x1, y1, x2, y2]
+    class_name: str
+    class_sly_id: Optional[int]  # Supervisely class ID
+    score: float
+
+
+class BotSortTracker(BaseTracker):
+    
+    def __init__(self, settings: dict = None, device: str = None):
+        super().__init__(settings=settings, device=device)
+        
+        # Load default settings from YAML file
+        self.settings = self._load_default_settings()
+        
+        # Override with user settings if provided
+        if settings:
+            self.settings.update(settings)
+        
+        args = SimpleNamespace(**self.settings)
+        args.device = self.device
+            
+        self.tracker = BoTSORT(args=args)
+        
+        # State for accumulating results
+        self.frame_tracks = []
+        self.obj_classes = {}   # class_id -> ObjClass
+        self.current_frame = 0
+        self.class_ids = {}  # class_name -> class_id mapping
+        self.frame_shape = () 
+
+    def _load_default_settings(self) -> dict:
+        """Load default settings from YAML file in the same directory."""
+        current_dir = Path(__file__).parent
+        config_path = current_dir / "botsort/botsort_config.yaml"
+        
+        with open(config_path, 'r', encoding='utf-8') as file:
+            return yaml.safe_load(file)
+
+    def update(self, frame: np.ndarray, annotation: Annotation) -> List[Dict[str, Any]]:
+        """Update tracker and return list of matches for current frame."""
+        self.frame_shape = frame.shape[:2]
+        self._update_obj_classes(annotation)
+        detections = self._convert_annotation(annotation)
+        output_stracks, detection_track_map = self.tracker.update(detections, frame)
+        tracks = self._stracks_to_tracks(output_stracks, detection_track_map)
+        
+        # Store tracks for VideoAnnotation creation
+        self.frame_tracks.append(tracks)
+        self.current_frame += 1
+        
+        matches = []
+        for pair in detection_track_map:
+            det_id = pair["det_id"]
+            track_id = pair["track_id"]
+
+            if track_id is not None:
+                match = {
+                    "track_id": track_id,
+                    "label": annotation.labels[det_id]
+                }
+                matches.append(match)
+            
+        return matches
+    
+    def reset(self) -> None:
+        super().reset()
+        self.frame_tracks = []
+        self.obj_classes = {}
+        self.current_frame = 0
+        self.class_ids = {}
+        self.frame_shape = ()
+
+    def track(self, frames: List[np.ndarray], annotations: List[Annotation]) -> VideoAnnotation:
+        """Track objects through sequence of frames and return VideoAnnotation."""
+        if len(frames) != len(annotations):
+            raise ValueError("Number of frames and annotations must match")
+        
+        self.reset()
+        
+        # Process each frame
+        for frame_idx, (frame, annotation) in enumerate(zip(frames, annotations)):
+            self.current_frame = frame_idx
+            self.update(frame, annotation)
+        
+        # Convert accumulated tracks to VideoAnnotation
+        return self._create_video_annotation()
+        
+    def _convert_annotation(self, annotation: Annotation) -> np.ndarray:
+        """Convert Supervisely annotation to BoTSORT detection format."""
+        detections_list = []
+
+        for label in annotation.labels:
+            if label.tags.get("confidence", None) is not None:
+                confidence = label.tags.get("confidence").value
+            elif label.tags.get("conf", None) is not None:
+                confidence = label.tags.get("conf").value
+            else:
+                confidence = 1.0
+                logger.debug(
+                    f"Label {label.obj_class.name} does not have confidence tag, using default value 1.0"
+                )
+
+            rectangle = label.geometry.to_bbox()
+            
+            class_name = label.obj_class.name
+            class_id = self.class_ids[class_name]
+            
+            detection = [
+                rectangle.left,    # x1
+                rectangle.top,     # y1 
+                rectangle.right,   # x2
+                rectangle.bottom,  # y2   
+                confidence,        # score
+                class_id,          # class_id as number
+            ]
+            detections_list.append(detection)
+
+        if detections_list:
+            return np.array(detections_list, dtype=np.float32)
+        else:
+            return np.zeros((0, 6), dtype=np.float32)
+    
+    def _stracks_to_tracks(self, output_stracks, detection_track_map) -> List[TrackedObject]:
+        """Convert BoTSORT output tracks to TrackedObject dataclass instances."""
+        tracks = []
+        
+        id_to_name = {v: k for k, v in self.class_ids.items()}
+        
+        track_id_to_det_id = {}
+        for pair in detection_track_map:
+            det_id = pair["det_id"]
+            track_id = pair["track_id"]
+            track_id_to_det_id[track_id] = det_id 
+        
+        for strack in output_stracks:
+            # BoTSORT may store class info in different attributes
+            # Try to get class_id from various possible sources
+            class_id = 0  # default
+            
+            if hasattr(strack, 'cls') and strack.cls != -1:
+                # cls should contain the numeric ID we passed in
+                class_id = int(strack.cls)
+            elif hasattr(strack, 'class_id'):
+                class_id = int(strack.class_id)
+            
+            class_name = id_to_name.get(class_id, "unknown")
+            
+            # Get Supervisely class ID from stored ObjClass
+            class_sly_id = None
+            if class_name in self.obj_classes:
+                obj_class = self.obj_classes[class_name]
+                class_sly_id = obj_class.sly_id
+            
+            track = TrackedObject(
+                track_id=strack.track_id,
+                det_id=track_id_to_det_id.get(strack.track_id),
+                bbox=strack.tlbr.tolist(),  # [x1, y1, x2, y2]
+                class_name=class_name,
+                class_sly_id=class_sly_id,
+                score=getattr(strack, 'score', 1.0)
+            )
+            tracks.append(track)
+        
+        return tracks
+        
+    def _update_obj_classes(self, annotation: Annotation):
+        """Extract and store object classes from annotation."""
+        for label in annotation.labels:
+            class_name = label.obj_class.name
+            if class_name not in self.obj_classes:
+                self.obj_classes[class_name] = label.obj_class
+        
+            if class_name not in self.class_ids:
+                self.class_ids[class_name] = len(self.class_ids)
+
+
+    def _create_video_annotation(self) -> VideoAnnotation:
+        """Convert accumulated tracking results to Supervisely VideoAnnotation."""
+        img_h, img_w = self.frame_shape
+        video_objects = {}  # track_id -> VideoObject
+        frames = []
+        
+        for frame_idx, tracks in enumerate(self.frame_tracks):
+            frame_figures = []
+            
+            for track in tracks:
+                track_id = track.track_id
+                bbox = track.bbox  # [x1, y1, x2, y2]
+                class_name = track.class_name
+                
+                # Clip bbox to image boundaries
+                x1, y1, x2, y2 = bbox
+                dims = np.array([img_w, img_h, img_w, img_h]) - 1
+                x1, y1, x2, y2 = np.clip([x1, y1, x2, y2], 0, dims)
+                
+                # Get or create VideoObject
+                if track_id not in video_objects:
+                    obj_class = self.obj_classes.get(class_name)
+                    if obj_class is None:
+                        continue  # Skip if class not found
+                    video_objects[track_id] = sly.VideoObject(obj_class)
+                
+                video_object = video_objects[track_id]
+                rect = sly.Rectangle(top=y1, left=x1, bottom=y2, right=x2)
+                frame_figures.append(sly.VideoFigure(video_object, rect, frame_idx))
+            
+            frames.append(sly.Frame(frame_idx, frame_figures))
+
+        objects = list(video_objects.values())
+
+        
+        return VideoAnnotation(
+            img_size=self.frame_shape,
+            frames_count=len(self.frame_tracks),
+            objects=sly.VideoObjectCollection(objects),
+            frames=sly.FrameCollection(frames)
+        )
+        
+    @property    
+    def video_annotation(self) -> VideoAnnotation:
+        """Return the accumulated VideoAnnotation."""
+        if not self.frame_tracks:
+            error_msg = (
+                "No tracking data available. "
+                "Please run tracking first using track() method or process frames with update()."
+            )
+            raise ValueError(error_msg)
+                
+        return self._create_video_annotation()

supervisely/project/project.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import gc
 import io
 import json
 import os
@@ -26,6 +27,7 @@ from typing import (
 
 import aiofiles
 import numpy as np
+from PIL import Image as PILImage
 from tqdm import tqdm
 
 import supervisely as sly
@@ -3333,7 +3335,6 @@ class Project:
 
         return train_items, val_items
 
-
     @staticmethod
     def download(
         api: Api,
@@ -5612,6 +5613,7 @@ async def _download_project_async(
         blob_files_to_download = {}
         blob_images = []
 
+        sly.logger.info("Calculating images to download...", extra={"dataset": dataset.name})
         async for image_batch in all_images:
             for image in image_batch:
                 if images_ids is None or image.id in images_ids:
@@ -5621,7 +5623,7 @@ async def _download_project_async(
                     if download_blob_files and image.related_data_id is not None:
                         blob_files_to_download[image.related_data_id] = image.download_id
                         blob_images.append(image)
-                    elif image.size < switch_size:
+                    elif image.size is not None and image.size < switch_size:
                         small_images.append(image)
                     else:
                         large_images.append(image)
@@ -5655,16 +5657,55 @@ async def _download_project_async(
                             ds_progress(1)
                 return to_download
 
-            async def run_tasks_with_delay(tasks, delay=0.1):
-                created_tasks = []
-                for task in tasks:
-                    created_task = asyncio.create_task(task)
-                    created_tasks.append(created_task)
-                    await asyncio.sleep(delay)
+            async def run_tasks_with_semaphore_control(task_list: list, delay=0.05):
+                """
+                Execute tasks with semaphore control - create tasks only as semaphore permits become available.
+                task_list - list of coroutines or callables that create tasks
+                """
+                random.shuffle(task_list)
+                running_tasks = set()
+                max_concurrent = getattr(semaphore, "_value", 10)
+
+                task_iter = iter(task_list)
+                completed_count = 0
+
+                while True:
+                    # Add new tasks while we have capacity
+                    while len(running_tasks) < max_concurrent:
+                        try:
+                            task_gen = next(task_iter)
+                            if callable(task_gen):
+                                task = asyncio.create_task(task_gen())
+                            else:
+                                task = asyncio.create_task(task_gen)
+                            running_tasks.add(task)
+                            await asyncio.sleep(delay)
+                        except StopIteration:
+                            break
+
+                    if not running_tasks:
+                        break
+
+                    # Wait for at least one task to complete
+                    done, running_tasks = await asyncio.wait(
+                        running_tasks, return_when=asyncio.FIRST_COMPLETED
+                    )
+
+                    # Process completed tasks
+                    for task in done:
+                        completed_count += 1
+                        try:
+                            await task
+                        except Exception as e:
+                            logger.error(f"Task error: {e}")
+
+                    # Clear the done set - this should be enough for memory cleanup
+                    done.clear()
+
                 logger.debug(
-                    f"{len(created_tasks)} tasks have been created for dataset ID: {dataset.id}, Name: {dataset.name}"
+                    f"{completed_count} tasks have been completed for dataset ID: {dataset.id}, Name: {dataset.name}"
                 )
-                return created_tasks
+                return completed_count
 
             # Download blob files if required
             if download_blob_files and len(blob_files_to_download) > 0:
@@ -5728,19 +5769,24 @@ async def _download_project_async(
                             progress_cb=ds_progress,
                         )
                         offset_tasks.append(offset_task)
-                    created_tasks = await run_tasks_with_delay(offset_tasks, 0.05)
-                    await asyncio.gather(*created_tasks)
+                    await run_tasks_with_semaphore_control(offset_tasks, 0.05)
 
             tasks = []
-            # Check which images need to be downloaded
-            small_images = await check_items(small_images)
-            large_images = await check_items(large_images)
+            if resume_download is True:
+                sly.logger.info("Checking existing images...", extra={"dataset": dataset.name})
+                # Check which images need to be downloaded
+                small_images = await check_items(small_images)
+                large_images = await check_items(large_images)
 
             # If only one small image, treat it as a large image for efficiency
             if len(small_images) == 1:
                 large_images.append(small_images.pop())
 
             # Create batch download tasks
+            sly.logger.debug(
+                f"Downloading {len(small_images)} small images in batch number {len(small_images) // batch_size}...",
+                extra={"dataset": dataset.name},
+            )
             for images_batch in batched(small_images, batch_size=batch_size):
                 task = _download_project_items_batch_async(
                     api=api,
@@ -5758,6 +5804,10 @@ async def _download_project_async(
                 tasks.append(task)
 
             # Create individual download tasks for large images
+            sly.logger.debug(
+                f"Downloading {len(large_images)} large images one by one...",
+                extra={"dataset": dataset.name},
+            )
             for image in large_images:
                 task = _download_project_item_async(
                     api=api,
@@ -5773,8 +5823,7 @@ async def _download_project_async(
                 )
                 tasks.append(task)
 
-            created_tasks = await run_tasks_with_delay(tasks)
-            await asyncio.gather(*created_tasks)
+            await run_tasks_with_semaphore_control(tasks)
 
         if save_image_meta:
             meta_dir = dataset_fs.meta_dir
@@ -5815,20 +5864,10 @@ async def _download_project_item_async(
 ) -> None:
     """Download image and annotation from Supervisely API and save it to the local filesystem.
     Uses parameters from the parent function _download_project_async.
+    Optimized version - uses streaming only for large images (>5MB) to avoid performance degradation.
     """
-    if save_images:
-        logger.debug(
-            f"Downloading 1 image in single mode with _download_project_item_async. ID: {img_info.id}, Name: {img_info.name}"
-        )
-        img_bytes = await api.image.download_bytes_single_async(
-            img_info.id, semaphore=semaphore, check_hash=True
-        )
-        if None in [img_info.height, img_info.width]:
-            width, height = sly.image.get_size_from_bytes(img_bytes)
-            img_info = img_info._replace(height=height, width=width)
-    else:
-        img_bytes = None
 
+    # Prepare annotation first (small data)
     if only_image_tags is False:
         ann_info = await api.annotation.download_async(
             img_info.id,
@@ -5853,13 +5892,84 @@ async def _download_project_item_async(
         tmp_ann = Annotation(img_size=(img_info.height, img_info.width), img_tags=tags)
         ann_json = tmp_ann.to_json()
 
-    dataset_fs.delete_item(img_info.name)
-    await dataset_fs.add_item_raw_bytes_async(
-        item_name=img_info.name,
-        item_raw_bytes=img_bytes if save_images is True else None,
-        ann=ann_json,
-        img_info=img_info if save_image_info is True else None,
-    )
+    # Handle image download - choose method based on estimated size
+    if save_images:
+        # Estimate size threshold: 5MB for streaming to avoid performance degradation
+        size_threshold_for_streaming = 5 * 1024 * 1024  # 5MB
+        estimated_size = getattr(img_info, "size", 0) or (
+            img_info.height * img_info.width * 3 if img_info.height and img_info.width else 0
+        )
+
+        if estimated_size > size_threshold_for_streaming:
+            # Use streaming for large images only
+            sly.logger.trace(
+                f"Downloading large image in streaming mode: {img_info.size / 1024 / 1024:.1f}MB"
+            )
+
+            # Clean up existing item first
+            dataset_fs.delete_item(img_info.name)
+
+            final_path = dataset_fs.generate_item_path(img_info.name)
+            temp_path = final_path + ".tmp"
+            await api.image.download_path_async(
+                img_info.id, temp_path, semaphore=semaphore, check_hash=True
+            )
+
+            # Get dimensions if needed
+            if None in [img_info.height, img_info.width]:
+                # Use PIL directly on the file - it will only read the minimal header needed
+                with PILImage.open(temp_path) as image:
+                    width, height = image.size
+                img_info = img_info._replace(height=height, width=width)
+
+            # Update annotation with correct dimensions if needed
+            if None in tmp_ann.img_size:
+                tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
+                ann_json = tmp_ann.to_json()
+
+            # os.rename is atomic and will overwrite the destination if it exists
+            os.rename(temp_path, final_path)
+
+            # For streaming, we save directly to filesystem, so use add_item_raw_bytes_async with None
+            await dataset_fs.add_item_raw_bytes_async(
+                item_name=img_info.name,
+                item_raw_bytes=None,  # Image already saved to disk
+                ann=ann_json,
+                img_info=img_info if save_image_info is True else None,
+            )
+        else:
+            sly.logger.trace(f"Downloading large image: {img_info.size / 1024 / 1024:.1f}MB")
+            # Use fast in-memory download for small images
+            img_bytes = await api.image.download_bytes_single_async(
+                img_info.id, semaphore=semaphore, check_hash=True
+            )
+
+            if None in [img_info.height, img_info.width]:
+                width, height = sly.image.get_size_from_bytes(img_bytes)
+                img_info = img_info._replace(height=height, width=width)
+
+            # Update annotation with correct dimensions if needed
+            if None in tmp_ann.img_size:
+                tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
+                ann_json = tmp_ann.to_json()
+
+            # Clean up existing item first, then save new one
+            dataset_fs.delete_item(img_info.name)
+            await dataset_fs.add_item_raw_bytes_async(
+                item_name=img_info.name,
+                item_raw_bytes=img_bytes,
+                ann=ann_json,
+                img_info=img_info if save_image_info is True else None,
+            )
+    else:
+        dataset_fs.delete_item(img_info.name)
+        await dataset_fs.add_item_raw_bytes_async(
+            item_name=img_info.name,
+            item_raw_bytes=None,
+            ann=ann_json,
+            img_info=img_info if save_image_info is True else None,
+        )
+
     if progress_cb is not None:
         progress_cb(1)
     logger.debug(f"Single project item has been downloaded. Semaphore state: {semaphore._value}")
@@ -5882,32 +5992,14 @@ async def _download_project_items_batch_async(
     Download images and annotations from Supervisely API and save them to the local filesystem.
     Uses parameters from the parent function _download_project_async.
     It is used for batch download of images and annotations with the bulk download API methods.
+
+    IMPORTANT: The total size of all images in a batch must not exceed 130MB, and the size of each image must not exceed 1.28MB.
     """
-    if save_images:
-        img_ids = [img_info.id for img_info in img_infos]
-        imgs_bytes = [None] * len(img_ids)
-        temp_dict = {}
-        logger.debug(
-            f"Downloading {len(img_ids)} images in bulk with _download_project_items_batch_async"
-        )
-        async for img_id, img_bytes in api.image.download_bytes_generator_async(
-            dataset_id,
-            img_ids,
-            semaphore=semaphore,
-            check_hash=True,
-        ):
-            temp_dict[img_id] = img_bytes
-        # to be sure that the order is correct
-        for idx, img_id in enumerate(img_ids):
-            imgs_bytes[idx] = temp_dict[img_id]
-        for img_info, img_bytes in zip(img_infos, imgs_bytes):
-            if None in [img_info.height, img_info.width]:
-                width, height = sly.image.get_size_from_bytes(img_bytes)
-                img_info = img_info._replace(height=height, width=width)
-    else:
-        img_ids = [img_info.id for img_info in img_infos]
-        imgs_bytes = [None] * len(img_infos)
+    img_ids = [img_info.id for img_info in img_infos]
+    img_ids_to_info = {img_info.id: img_info for img_info in img_infos}
 
+    sly.logger.trace(f"Downloading {len(img_infos)} images in batch mode.")
+    # Download annotations first
     if only_image_tags is False:
         ann_infos = await api.annotation.download_bulk_async(
             dataset_id,
@@ -5915,20 +6007,20 @@ async def _download_project_items_batch_async(
             semaphore=semaphore,
             force_metadata_for_links=not save_images,
         )
-        ann_jsons = []
+        id_to_annotation = {}
         for img_info, ann_info in zip(img_infos, ann_infos):
             try:
                 tmp_ann = Annotation.from_json(ann_info.annotation, meta)
                 if None in tmp_ann.img_size:
                     tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
-                ann_jsons.append(tmp_ann.to_json())
+                id_to_annotation[img_info.id] = tmp_ann.to_json()
             except Exception:
                 logger.error(
                     f"Error while deserializing annotation for image with ID: {img_info.id}"
                 )
                 raise
     else:
-        ann_jsons = []
+        id_to_annotation = {}
         for img_info in img_infos:
             tags = TagCollection.from_api_response(
                 img_info.tags,
@@ -5936,17 +6028,63 @@ async def _download_project_items_batch_async(
                 id_to_tagmeta,
             )
             tmp_ann = Annotation(img_size=(img_info.height, img_info.width), img_tags=tags)
-            ann_jsons.append(tmp_ann.to_json())
-    for img_info, ann_json, img_bytes in zip(img_infos, ann_jsons, imgs_bytes):
-        dataset_fs.delete_item(img_info.name)
-        await dataset_fs.add_item_raw_bytes_async(
-            item_name=img_info.name,
-            item_raw_bytes=img_bytes,
-            ann=dataset_fs.get_ann(img_info.name, meta) if ann_json is None else ann_json,
-            img_info=img_info if save_image_info is True else None,
-        )
-        if progress_cb is not None:
-            progress_cb(1)
+            id_to_annotation[img_info.id] = tmp_ann.to_json()
+
+    if save_images:
+        async for img_id, img_bytes in api.image.download_bytes_generator_async(
+            dataset_id=dataset_id, img_ids=img_ids, semaphore=semaphore, check_hash=True
+        ):
+            img_info = img_ids_to_info.get(img_id)
+            if img_info is None:
+                continue
+
+            if None in [img_info.height, img_info.width]:
+                width, height = sly.image.get_size_from_bytes(img_bytes)
+                img_info = img_info._replace(height=height, width=width)
+
+                # Update annotation if needed - use pop to get and remove at the same time
+                ann_json = id_to_annotation.pop(img_id, None)
+                if ann_json is not None:
+                    try:
+                        tmp_ann = Annotation.from_json(ann_json, meta)
+                        if None in tmp_ann.img_size:
+                            tmp_ann = tmp_ann.clone(img_size=(img_info.height, img_info.width))
+                        ann_json = tmp_ann.to_json()
+                    except Exception:
+                        pass
+            else:
+                ann_json = id_to_annotation.pop(img_id, None)
+
+            dataset_fs.delete_item(img_info.name)
+            await dataset_fs.add_item_raw_bytes_async(
+                item_name=img_info.name,
+                item_raw_bytes=img_bytes,
+                ann=ann_json,
+                img_info=img_info if save_image_info is True else None,
+            )
+
+            if progress_cb is not None:
+                progress_cb(1)
+    else:
+        for img_info in img_infos:
+            dataset_fs.delete_item(img_info.name)
+            ann_json = id_to_annotation.pop(img_info.id, None)
+            await dataset_fs.add_item_raw_bytes_async(
+                item_name=img_info.name,
+                item_raw_bytes=None,
+                ann=ann_json,
+                img_info=img_info if save_image_info is True else None,
+            )
+            if progress_cb is not None:
+                progress_cb(1)
+
+    # Clear dictionaries and force GC for large batches only
+    batch_size = len(img_infos)
+    id_to_annotation.clear()
+    img_ids_to_info.clear()
+
+    if batch_size > 50:  # Only for large batches
+        gc.collect()
 
     logger.debug(f"Batch of project items has been downloaded. Semaphore state: {semaphore._value}")
 

{supervisely-6.73.418.dist-info → supervisely-6.73.420.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.418
+Version: 6.73.420
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely
@@ -129,6 +129,8 @@ Requires-Dist: faiss-gpu; extra == "tracking"
 Requires-Dist: tabulate; extra == "tracking"
 Requires-Dist: tensorboard; extra == "tracking"
 Requires-Dist: decord; extra == "tracking"
+Requires-Dist: gdown; extra == "tracking"
+Requires-Dist: torch; extra == "tracking"
 Provides-Extra: training
 Requires-Dist: pycocotools; extra == "training"
 Requires-Dist: scikit-learn; extra == "training"