vision-agent 0.2.233__py3-none-any.whl → 0.2.235__py3-none-any.whl

vision_agent/agent/vision_agent_planner_prompts_v2.py

@@ -20,7 +20,7 @@ PLAN = """
 3. Only output <finalize_plan> when you are done planning and want to end the planning process. DO NOT output <finalize_plan> with <execute_python> tags, only after OBSERVATION's.
 4. Only load/save files from {media_list} unless you specifically saved the file previously.
 5. Ensure you always call `suggestion` initially and `get_tool_for_task` to get the right tool for the subtask.
-6. Calling `plt.imshow` or `save_image` will display the image to you, use this to visually check your results.
+6. Calling `plt.imshow` or `save_image` will display the image to you so you can check your results. If you see an image after <execute_python> it's generated from your code.
 7. DO NOT hard code the answer into your code, it should be dynamic and work for any similar request.
 8. DO NOT over index on claude35_vqa, if tool output is close to claude35_vqa's output you do not need to improve the tool.
 9. You can only respond in the following format with a single <thinking>, <execute_python> or <finalize_plan> tag:

vision_agent/agent/vision_agent_planner_v2.py

@@ -97,8 +97,7 @@ def run_planning(
     media_list: List[Union[str, Path]],
     model: LMM,
 ) -> str:
-    # only keep last 10 messages for planning
-    planning = get_planning(chat[-10:])
+    planning = get_planning(chat)
     prompt = PLAN.format(
         tool_desc=PLANNING_TOOLS_DOCSTRING,
         examples=f"{EXAMPLE_PLAN1}\n{EXAMPLE_PLAN2}",
@@ -372,7 +371,7 @@ def replace_interaction_with_obs(chat: List[AgentMessage]) -> List[AgentMessage]
                 function_name = response["function_name"]
                 tool_doc = get_tool_documentation(function_name)
                 if "box_threshold" in response:
-                    tool_doc = f"Use the following function with box_threshold={response['box_threshold']}\n\n{tool_doc}"
+                    tool_doc = f"Use the following function with box_threshold={response['box_threshold']}. This tool and its parameters were chosen by the user so do not change them in your planning.\n\n{tool_doc}."
                 new_chat.append(AgentMessage(role="observation", content=tool_doc))
             except (json.JSONDecodeError, KeyError):
                 raise ValueError(f"Invalid JSON in interaction response: {chat_i}")

vision_agent/agent/vision_agent_v2.py

@@ -91,8 +91,6 @@ def maybe_run_action(
     code_interpreter: Optional[CodeInterpreter] = None,
 ) -> Optional[List[AgentMessage]]:
     extracted_chat, final_code = extract_conversation(chat)
-    # only keep last 5 messages to keep context recent and not overwhelm LLM
-    extracted_chat = extracted_chat[-5:]
     if action == "generate_or_edit_vision_code":
         # there's an issue here because coder.generate_code will send it's code_context
         # to the outside user via it's update_callback, but we don't necessarily have
@@ -125,6 +123,7 @@ def maybe_run_action(
             ],
             code="",
         )
+
         context = coder.generate_code_from_plan(
             extracted_chat, plan_context, code_interpreter=code_interpreter
         )

vision_agent/tools/tool_utils.py

@@ -270,17 +270,22 @@ def add_bboxes_from_masks(
 ) -> List[List[Dict[str, Any]]]:
     for frame_preds in all_preds:
         for preds in frame_preds:
-            if np.sum(preds["mask"]) == 0:
+            mask = preds["mask"]
+            if mask.sum() == 0:
                 preds["bbox"] = []
             else:
-                rows, cols = np.where(preds["mask"])
-                bbox = [
-                    float(np.min(cols)),
-                    float(np.min(rows)),
-                    float(np.max(cols)),
-                    float(np.max(rows)),
-                ]
-                bbox = normalize_bbox(bbox, preds["mask"].shape)
+                # Get indices where mask is True using axis operations
+                rows = np.any(mask, axis=1)
+                cols = np.any(mask, axis=0)
+
+                # Find boundaries using argmax/argmin
+                y_min = np.argmax(rows)
+                y_max = len(rows) - np.argmax(rows[::-1])
+                x_min = np.argmax(cols)
+                x_max = len(cols) - np.argmax(cols[::-1])
+
+                bbox = [float(x_min), float(y_min), float(x_max), float(y_max)]
+                bbox = normalize_bbox(bbox, mask.shape)
                 preds["bbox"] = bbox
 
     return all_preds

vision_agent/tools/tools.py

@@ -234,16 +234,24 @@ def od_sam2_video_tracking(
     od_model: ODModels,
     prompt: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 50,
     fine_tune_id: Optional[str] = None,
 ) -> Dict[str, Any]:
-    SEGMENT_SIZE = 50
-    OVERLAP = 1  # Number of overlapping frames between segments
+    chunk_length = 50 if chunk_length is None else chunk_length
+    segment_size = chunk_length
+    # Number of overlapping frames between segments
+    overlap = 1
+    # chunk_length needs to be segment_size + 1 or else on the last segment it will
+    # run the OD model again and merging will not work
+    chunk_length = chunk_length + 1
+
+    if len(frames) == 0 or not isinstance(frames, List):
+        return {"files": [], "return_data": [], "display_data": []}
 
     image_size = frames[0].shape[:2]
 
     # Split frames into segments with overlap
-    segments = split_frames_into_segments(frames, SEGMENT_SIZE, OVERLAP)
+    segments = split_frames_into_segments(frames, segment_size, overlap)
 
     def _apply_object_detection(  # inner method to avoid circular importing issues.
         od_model: ODModels,
@@ -538,7 +546,7 @@ def owlv2_sam2_instance_segmentation(
 def owlv2_sam2_video_tracking(
     prompt: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 25,
     fine_tune_id: Optional[str] = None,
 ) -> List[List[Dict[str, Any]]]:
     """'owlv2_sam2_video_tracking' is a tool that can track and segment multiple
@@ -771,7 +779,7 @@ def florence2_sam2_instance_segmentation(
 def florence2_sam2_video_tracking(
     prompt: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 25,
     fine_tune_id: Optional[str] = None,
 ) -> List[List[Dict[str, Any]]]:
     """'florence2_sam2_video_tracking' is a tool that can track and segment multiple
@@ -1110,7 +1118,7 @@ def countgd_sam2_instance_segmentation(
 def countgd_sam2_video_tracking(
     prompt: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 25,
 ) -> List[List[Dict[str, Any]]]:
     """'countgd_sam2_video_tracking' is a tool that can track and segment multiple
     objects in a video given a text prompt such as category names or referring
@@ -1322,7 +1330,7 @@ def custom_object_detection(
 def custom_od_sam2_video_tracking(
     deployment_id: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 25,
 ) -> List[List[Dict[str, Any]]]:
     """'custom_od_sam2_video_tracking' is a tool that can segment multiple objects given a
     custom model with predefined category names.
@@ -2366,7 +2374,7 @@ def agentic_sam2_instance_segmentation(
 def agentic_sam2_video_tracking(
     prompt: str,
     frames: List[np.ndarray],
-    chunk_length: Optional[int] = 10,
+    chunk_length: Optional[int] = 25,
     fine_tune_id: Optional[str] = None,
 ) -> List[List[Dict[str, Any]]]:
     """'agentic_sam2_video_tracking' is a tool that can track and segment multiple
@@ -2791,7 +2799,15 @@ def overlay_bounding_boxes(
             "Number of unique labels exceeds the number of available colors. Some labels may have the same color."
         )
 
-    color = {label: COLORS[i % len(COLORS)] for i, label in enumerate(labels)}
+    use_tracking_label = False
+    if all([":" in label for label in labels]):
+        unique_labels = set([label.split(":")[1].strip() for label in labels])
+        use_tracking_label = True
+        colors = {
+            label: COLORS[i % len(COLORS)] for i, label in enumerate(unique_labels)
+        }
+    else:
+        colors = {label: COLORS[i % len(COLORS)] for i, label in enumerate(labels)}
 
     frame_out = []
     for i, frame in enumerate(medias_int):
@@ -2802,7 +2818,7 @@ def overlay_bounding_boxes(
 
         # if more than 50 boxes use small boxes to indicate objects else use regular boxes
         if len(bboxes) > 50:
-            pil_image = _plot_counting(pil_image, bboxes, color)
+            pil_image = _plot_counting(pil_image, bboxes, colors, use_tracking_label)
         else:
             width, height = pil_image.size
             fontsize = max(12, int(min(width, height) / 40))
@@ -2817,18 +2833,20 @@ def overlay_bounding_boxes(
             )
 
             for elt in bboxes:
+                if use_tracking_label:
+                    color = colors[elt["label"].split(":")[1].strip()]
+                else:
+                    color = colors[elt["label"]]
                 label = elt["label"]
                 box = elt["bbox"]
                 scores = elt["score"]
 
                 # denormalize the box if it is normalized
                 box = denormalize_bbox(box, (height, width))
-                draw.rectangle(box, outline=color[label], width=4)
+                draw.rectangle(box, outline=color, width=4)
                 text = f"{label}: {scores:.2f}"
                 text_box = draw.textbbox((box[0], box[1]), text=text, font=font)
-                draw.rectangle(
-                    (box[0], box[1], text_box[2], text_box[3]), fill=color[label]
-                )
+                draw.rectangle((box[0], box[1], text_box[2], text_box[3]), fill=color)
                 draw.text((box[0], box[1]), text, fill="black", font=font)
 
         frame_out.append(np.array(pil_image))
@@ -2911,7 +2929,16 @@ def overlay_segmentation_masks(
     for mask_i in masks_int:
         for mask_j in mask_i:
             labels.add(mask_j["label"])
-    color = {label: COLORS[i % len(COLORS)] for i, label in enumerate(labels)}
+
+    use_tracking_label = False
+    if all([":" in label for label in labels]):
+        use_tracking_label = True
+        unique_labels = set([label.split(":")[1].strip() for label in labels])
+        colors = {
+            label: COLORS[i % len(COLORS)] for i, label in enumerate(unique_labels)
+        }
+    else:
+        colors = {label: COLORS[i % len(COLORS)] for i, label in enumerate(labels)}
 
     width, height = Image.fromarray(medias_int[0]).size
     fontsize = max(12, int(min(width, height) / 40))
@@ -2925,12 +2952,16 @@ def overlay_segmentation_masks(
         pil_image = Image.fromarray(frame.astype(np.uint8)).convert("RGBA")
         for elt in masks_int[i]:
             mask = elt["mask"]
+            if use_tracking_label:
+                color = colors[elt["label"].split(":")[1].strip()]
+            else:
+                color = colors[elt["label"]]
             label = elt["label"]
             tracking_lbl = elt.get(secondary_label_key, None)
 
             # Create semi-transparent mask overlay
             np_mask = np.zeros((pil_image.size[1], pil_image.size[0], 4))
-            np_mask[mask > 0, :] = color[label] + (255 * 0.7,)
+            np_mask[mask > 0, :] = color + (255 * 0.7,)
             mask_img = Image.fromarray(np_mask.astype(np.uint8))
             pil_image = Image.alpha_composite(pil_image, mask_img)
 
@@ -2942,7 +2973,7 @@ def overlay_segmentation_masks(
             border_mask = np.zeros(
                 (pil_image.size[1], pil_image.size[0], 4), dtype=np.uint8
             )
-            cv2.drawContours(border_mask, contours, -1, color[label] + (255,), 8)
+            cv2.drawContours(border_mask, contours, -1, color + (255,), 8)
             border_img = Image.fromarray(border_mask)
             pil_image = Image.alpha_composite(pil_image, border_img)
 
@@ -2957,7 +2988,7 @@ def overlay_segmentation_masks(
                 )
                 if x != 0 and y != 0:
                     text_box = draw.textbbox((x, y), text=text, font=font)
-                    draw.rectangle((x, y, text_box[2], text_box[3]), fill=color[label])
+                    draw.rectangle((x, y, text_box[2], text_box[3]), fill=color)
                     draw.text((x, y), text, fill="black", font=font)
         frame_out.append(np.array(pil_image))
     return_frame = frame_out[0] if len(frame_out) == 1 else frame_out
@@ -3014,6 +3045,7 @@ def _plot_counting(
     image: Image.Image,
     bboxes: List[Dict[str, Any]],
     colors: Dict[str, Tuple[int, int, int]],
+    use_tracking_label: bool = False,
 ) -> Image.Image:
     width, height = image.size
     fontsize = max(12, int(min(width, height) / 40))
@@ -3023,7 +3055,12 @@ def _plot_counting(
         fontsize,
     )
     for i, elt in enumerate(bboxes, 1):
-        label = f"{i}"
+        if use_tracking_label:
+            label = elt["label"].split(":")[0]
+            color = colors[elt["label"].split(":")[1].strip()]
+        else:
+            label = f"{i}"
+            color = colors[elt["label"]]
         box = elt["bbox"]
 
         # denormalize the box if it is normalized
@@ -3044,7 +3081,7 @@ def _plot_counting(
         text_y1 = cy + text_height / 2
 
         # Draw the rectangle encapsulating the text
-        draw.rectangle((text_x0, text_y0, text_x1, text_y1), fill=colors[elt["label"]])
+        draw.rectangle((text_x0, text_y0, text_x1, text_y1), fill=color)
 
         # Draw the text at the center of the bounding box
         draw.text(

vision_agent/utils/video_tracking.py

@@ -3,10 +3,10 @@ from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import numpy as np
+from scipy.optimize import linear_sum_assignment  # type: ignore
 
 from vision_agent.tools.tool_utils import (
     add_bboxes_from_masks,
-    nms,
     send_task_inference_request,
 )
 from vision_agent.utils.image_utils import denormalize_bbox, rle_decode_array
@@ -171,63 +171,45 @@ def _calculate_mask_iou(mask1: np.ndarray, mask2: np.ndarray) -> float:
 def _match_by_iou(
     first_param: List[Dict],
     second_param: List[Dict],
-    iou_threshold: float = 0.8,
-) -> Tuple[List[Dict], Dict[int, int]]:
-    max_id = max((item["id"] for item in first_param), default=0)
-
-    matched_new_item_indices = set()
-    id_mapping = {}
-
-    for new_index, new_item in enumerate(second_param):
-        matched_id = None
-
-        for existing_item in first_param:
+    max_id: int,
+    iou_threshold: float = 0.05,
+) -> Tuple[Dict[int, int], int]:
+    max_first_id = max((item["id"] for item in first_param), default=0)
+    max_second_id = max((item["id"] for item in second_param), default=0)
+
+    cost_matrix = np.ones((max_first_id + 1, max_second_id + 1))
+    for first_item in first_param:
+        for second_item in second_param:
             iou = _calculate_mask_iou(
-                existing_item["decoded_mask"], new_item["decoded_mask"]
+                first_item["decoded_mask"], second_item["decoded_mask"]
             )
-            if iou > iou_threshold:
-                matched_id = existing_item["id"]
-                matched_new_item_indices.add(new_index)
-                id_mapping[new_item["id"]] = matched_id
-                break
-
-        if matched_id:
-            new_item["id"] = matched_id
-        else:
-            max_id += 1
-            id_mapping[new_item["id"]] = max_id
-            new_item["id"] = max_id
-
-    unmatched_items = [
-        item for i, item in enumerate(second_param) if i not in matched_new_item_indices
-    ]
-    combined_list = first_param + unmatched_items
-
-    return combined_list, id_mapping
+            cost_matrix[first_item["id"], second_item["id"]] = 1 - iou
 
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+    id_mapping = {second_id: first_id for first_id, second_id in zip(row_ind, col_ind)}
+    first_id_to_label = {item["id"]: item["label"] for item in first_param}
 
-def _update_ids(detections: List[Dict], id_mapping: Dict[int, int]) -> None:
-    for inner_list in detections:
-        for detection in inner_list:
-            if detection["id"] in id_mapping:
-                detection["id"] = id_mapping[detection["id"]]
+    cleaned_mapping = {}
+    for elt in second_param:
+        second_id = elt["id"]
+        # if the id is not in the mapping, give it a new id
+        if second_id not in id_mapping:
+            max_id += 1
+            cleaned_mapping[second_id] = max_id
+        else:
+            first_id = id_mapping[second_id]
+            iou = 1 - cost_matrix[first_id, second_id]
+            # only map if the iou is above the threshold and the labels match
+            if iou > iou_threshold and first_id_to_label[first_id] == elt["label"]:
+                cleaned_mapping[second_id] = first_id
             else:
-                max_new_id = max(id_mapping.values(), default=0)
-                detection["id"] = max_new_id + 1
-                id_mapping[detection["id"]] = detection["id"]
+                max_id += 1
+                cleaned_mapping[second_id] = max_id
 
+    return cleaned_mapping, max_id
 
-def _convert_to_2d(detections_per_segment: List[Any]) -> List[Any]:
-    result = []
-    for i, segment in enumerate(detections_per_segment):
-        if i == 0:
-            result.extend(segment)
-        else:
-            result.extend(segment[1:])
-    return result
 
-
-def merge_segments(detections_per_segment: List[Any]) -> List[Any]:
+def merge_segments(detections_per_segment: List[Any], overlap: int = 1) -> List[Any]:
     """
     Merges detections from all segments into a unified result.
 
@@ -242,16 +224,20 @@ def merge_segments(detections_per_segment: List[Any]) -> List[Any]:
             for item in detection:
                 item["decoded_mask"] = rle_decode_array(item["mask"])
 
+    merged_result = detections_per_segment[0]
+    max_id = max((item["id"] for item in merged_result[-1]), default=0)
     for segment_idx in range(len(detections_per_segment) - 1):
-        combined_detection, id_mapping = _match_by_iou(
+        id_mapping, max_id = _match_by_iou(
             detections_per_segment[segment_idx][-1],
             detections_per_segment[segment_idx + 1][0],
+            max_id,
         )
-        _update_ids(detections_per_segment[segment_idx + 1], id_mapping)
-
-    merged_result = _convert_to_2d(detections_per_segment)
+        for frame in detections_per_segment[segment_idx + 1][overlap:]:
+            for detection in frame:
+                detection["id"] = id_mapping[detection["id"]]
+        merged_result.extend(detections_per_segment[segment_idx + 1][overlap:])
 
-    return merged_result
+    return merged_result  # type: ignore
 
 
 def post_process(
@@ -269,10 +255,26 @@ def post_process(
         Dict[str, Any]: Post-processed data including return_data and display_data.
     """
     return_data = []
-    for frame_idx, frame in enumerate(merged_detections):
+    label_remapping = {}
+    for _, frame in enumerate(merged_detections):
         return_frame_data = []
         for detection in frame:
-            label = f"{detection['id']}: {detection['label']}"
+            label = detection["label"]
+            id = detection["id"]
+
+            # Remap label IDs so for each label the IDs restart at 1. This makes it
+            # easier to count the number of instances per label.
+            if label not in label_remapping:
+                label_remapping[label] = {"max": 1, "remap": {id: 1}}
+            elif label in label_remapping and id not in label_remapping[label]["remap"]:  # type: ignore
+                max_id = label_remapping[label]["max"]
+                max_id += 1  # type: ignore
+                label_remapping[label]["remap"][id] = max_id  # type: ignore
+                label_remapping[label]["max"] = max_id
+
+            new_id = label_remapping[label]["remap"][id]  # type: ignore
+
+            label = f"{new_id}: {detection['label']}"
             return_frame_data.append(
                 {
                     "label": label,
@@ -285,7 +287,6 @@ def post_process(
         return_data.append(return_frame_data)
 
     return_data = add_bboxes_from_masks(return_data)
-    return_data = nms(return_data, iou_threshold=0.95)
 
     # We save the RLE for display purposes, re-calculting RLE can get very expensive.
     # Deleted here because we are returning the numpy masks instead

{vision_agent-0.2.233.dist-info → vision_agent-0.2.235.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vision-agent
-Version: 0.2.233
+Version: 0.2.235
 Summary: Toolset for Vision Agent
 Author: Landing AI
 Author-email: dev@landing.ai

{vision_agent-0.2.233.dist-info → vision_agent-0.2.235.dist-info}/RECORD

@@ -13,11 +13,11 @@ vision_agent/agent/vision_agent_coder_prompts_v2.py,sha256=NUMWq-Lxq5JmmyWs3C5O_
 vision_agent/agent/vision_agent_coder_v2.py,sha256=yQYcO0s4BI9pWaAQQAVtkwWa3UF5w0iLKvwpeJ6iegM,17077
 vision_agent/agent/vision_agent_planner.py,sha256=fFzjNkZBKkh8Y_oS06ATI4qz31xmIJvixb_tV1kX8KA,18590
 vision_agent/agent/vision_agent_planner_prompts.py,sha256=rYRdJthc-sQN57VgCBKrF09Sd73BSxcBdjNe6C4WNZ8,6837
-vision_agent/agent/vision_agent_planner_prompts_v2.py,sha256=U88z1Y7CifFs7t53aUrl8qjWtBYs0f_F5vyg_0VYJko,35528
-vision_agent/agent/vision_agent_planner_v2.py,sha256=NUyi57zxCmOO004_cJcCCDa4UgcKSWB1WCGuyOhhXQE,20602
+vision_agent/agent/vision_agent_planner_prompts_v2.py,sha256=JLiFZvwQFLYukgj4l-SzxSIjmJHTEkL2HSZbkjU529w,35591
+vision_agent/agent/vision_agent_planner_v2.py,sha256=wISmdTN-W1pjgZg3_aneGowI3lRQRHTSbpyeTJ79O5A,20645
 vision_agent/agent/vision_agent_prompts.py,sha256=KaJwYPUP7_GvQsCPPs6Fdawmi3AQWmWajBUuzj7gTG4,13812
 vision_agent/agent/vision_agent_prompts_v2.py,sha256=Wyxa15NOe75PefAfw3_RRwvgjg8YVqCrU7WvvWoYJpk,2733
-vision_agent/agent/vision_agent_v2.py,sha256=86_pPdkkMBk08TTFZ7zu9QG37Iz9uI8Nmt79wwm_EIA,11053
+vision_agent/agent/vision_agent_v2.py,sha256=Q96YsLovCUOd6m2Cg7EGCiHshDq65vxHsfVj7IToyls,10936
 vision_agent/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vision_agent/clients/http.py,sha256=k883i6M_4nl7zwwHSI-yP5sAgQZIDPM1nrKD6YFJ3Xs,2009
 vision_agent/clients/landing_public_api.py,sha256=lU2ev6E8NICmR8DMUljuGcVFy5VNJQ4WQkWC8WnnJEc,1503
@@ -35,8 +35,8 @@ vision_agent/tools/__init__.py,sha256=zopUrANPx7p0NGy6BxmEaYhDrj8DX8w7BLfgmCbz-m
 vision_agent/tools/meta_tools.py,sha256=TPeS7QWnc_PmmU_ndiDT03dXbQ5yDSP33E7U8cSj7Ls,28660
 vision_agent/tools/planner_tools.py,sha256=8pJZCGGOGIqGiV2or52BjyRP6eDlporuQ2hXCIHfLTQ,15382
 vision_agent/tools/prompts.py,sha256=V1z4YJLXZuUl_iZ5rY0M5hHc_2tmMEUKr0WocXKGt4E,1430
-vision_agent/tools/tool_utils.py,sha256=xJRWF96Ge9RvhhVHrOtifjUYoc4HIJ2y7c2VOQ2Lp8s,10152
-vision_agent/tools/tools.py,sha256=Eb2paiXjik0HyGeZzXctTpJCLG0V3NnNL9awtaB8HN4,107011
+vision_agent/tools/tool_utils.py,sha256=l4oWkgPd_s8QzXqqbrLwPgcfnhsJaPpdMKikOcwRaoQ,10396
+vision_agent/tools/tools.py,sha256=MBeFVYyCx-QQLCFb0Cn4m6SgmT6-6HxUOmCKAARrv6s,108547
 vision_agent/tools/tools_types.py,sha256=8hYf2OZhI58gvf65KGaeGkt4EQ56nwLFqIQDPHioOBc,2339
 vision_agent/utils/__init__.py,sha256=QKk4zVjMwGxQI0MQ-aZZA50N-qItxRY4EB9CwQkZ2HY,185
 vision_agent/utils/exceptions.py,sha256=booSPSuoULF7OXRr_YbC4dtKt6gM_HyiFQHBuaW86C4,2052
@@ -45,8 +45,8 @@ vision_agent/utils/image_utils.py,sha256=z_ONgcza125B10NkoGwPOzXnL470bpTWZbkB16N
 vision_agent/utils/sim.py,sha256=DYya76dYVtifFyXilMLxBzGgyfyeqhEwU4RJ4894lCI,9796
 vision_agent/utils/type_defs.py,sha256=BE12s3JNQy36QvauXHjwyeffVh5enfcvd4vTzSwvEZI,1384
 vision_agent/utils/video.py,sha256=e1VwKhXzzlC5LcFMyrcQYrPnpnX4wxDpnQ-76sB4jgM,6001
-vision_agent/utils/video_tracking.py,sha256=wK5dOutqV2t2aeaxedstCBa7xy-NNQE0-QZqKu1QUds,9498
-vision_agent-0.2.233.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vision_agent-0.2.233.dist-info/METADATA,sha256=EoNuerRth0lHRC7TK2Xh7w6V__YtUJraKk9yN8AMx2U,5760
-vision_agent-0.2.233.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-vision_agent-0.2.233.dist-info/RECORD,,
+vision_agent/utils/video_tracking.py,sha256=PXZYB0ZJM97WU52XbucyoXX2GW9-gNpSHrPF30_Lq1Q,10263
+vision_agent-0.2.235.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vision_agent-0.2.235.dist-info/METADATA,sha256=bAPsRs8veydvltpYRLYxAOB_bhASv9zKkE9TjkPVm2Q,5760
+vision_agent-0.2.235.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+vision_agent-0.2.235.dist-info/RECORD,,