rapidata 2.37.0__py3-none-any.whl → 2.39.0__py3-none-any.whl

rapidata/rapidata_client/validation/rapids/rapids_manager.py

@@ -1,5 +1,21 @@
 import os
-from rapidata.api_client import AttachCategoryTruth, BoundingBoxTruth, BoxShape, ClassifyPayload, ComparePayload, CompareTruth, LinePayload, LocateBoxTruth, LocatePayload, ScrubPayload, ScrubRange, ScrubTruth, TranscriptionPayload, TranscriptionTruth, TranscriptionWord
+from rapidata.api_client import (
+    AttachCategoryTruth,
+    BoundingBoxTruth,
+    BoxShape,
+    ClassifyPayload,
+    ComparePayload,
+    CompareTruth,
+    LinePayload,
+    LocateBoxTruth,
+    LocatePayload,
+    ScrubPayload,
+    ScrubRange,
+    ScrubTruth,
+    TranscriptionPayload,
+    TranscriptionTruth,
+    TranscriptionWord,
+)
 from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.datapoints.metadata import Metadata
 from rapidata.rapidata_client.validation.rapids.box import Box
@@ -8,24 +24,27 @@ from typing import Sequence, Literal
 
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
 
+
 class RapidsManager:
     """
     Can be used to build different types of rapids. That can then be added to Validation sets
     """
+
     def __init__(self):
         pass
-    
-    def classification_rapid(self,
-            instruction: str,
-            answer_options: list[str],
-            datapoint: str,
-            truths: list[str],
-            data_type: Literal["media", "text"] = "media",
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None,
+
+    def classification_rapid(
+        self,
+        instruction: str,
+        answer_options: list[str],
+        datapoint: str,
+        truths: list[str],
+        data_type: Literal["media", "text"] = "media",
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a classification rapid
-        
+
         Args:
             instruction (str): The instruction/question to be shown to the labeler.
             answer_options (list[str]): The options that the labeler can choose from to answer the question.
@@ -34,17 +53,19 @@ class RapidsManager:
             data_type (str, optional): The type of the datapoint. Defaults to "media" (any form of image, video or audio).
             metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
-        
+
         if data_type == "media":
             asset = MediaAsset(datapoint)
         elif data_type == "text":
             asset = TextAsset(datapoint)
         else:
-            raise ValueError(f"Unsupported data type: {data_type}, must be one of 'media' or 'text'")
+            raise ValueError(
+                f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+            )
 
         if not isinstance(truths, list):
             raise ValueError("Truths must be a list of strings")
-        
+
         if not all(truth in answer_options for truth in truths):
             raise ValueError("Truths must be part of the answer options")
 
@@ -56,21 +77,22 @@ class RapidsManager:
         )
 
         return Rapid(
-                asset=asset,
-                metadata=metadata,
-                explanation=explanation,
-                payload=payload,
-                truth=model_truth,
-                randomCorrectProbability=len(truths) / len(answer_options)
-             )
-    
-    def compare_rapid(self,
-            instruction: str,
-            truth: str,
-            datapoint: list[str],
-            data_type: Literal["media", "text"] = "media",
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None,
+            asset=asset,
+            metadata=metadata,
+            explanation=explanation,
+            payload=payload,
+            truth=model_truth,
+            randomCorrectProbability=len(truths) / len(answer_options),
+        )
+
+    def compare_rapid(
+        self,
+        instruction: str,
+        truth: str,
+        datapoint: list[str],
+        data_type: Literal["media", "text"] = "media",
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a compare rapid
 
@@ -88,9 +110,9 @@ class RapidsManager:
             assets = [TextAsset(text) for text in datapoint]
         else:
             raise ValueError(f"Unsupported data type: {data_type}")
-        
+
         asset = MultiAsset(assets)
-        
+
         payload = ComparePayload(_t="ComparePayload", criteria=instruction)
         # take only last part of truth path
         truth = os.path.basename(truth)
@@ -99,25 +121,25 @@ class RapidsManager:
         if len(asset) != 2:
             raise ValueError("Compare rapid requires exactly two media paths")
 
-
         return Rapid(
-                asset=asset,
-                truth=model_truth,
-                metadata=metadata,
-                payload=payload,
-                explanation=explanation,
-                randomCorrectProbability= 1 / len(asset.assets)
-                )
-    
-    def select_words_rapid(self,
-            instruction: str,
-            truths: list[int],
-            datapoint: str,
-            sentence: str,
-            required_precision: float = 1,
-            required_completeness: float = 1,
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None,
+            asset=asset,
+            truth=model_truth,
+            metadata=metadata,
+            payload=payload,
+            explanation=explanation,
+            randomCorrectProbability=1 / len(asset.assets),
+        )
+
+    def select_words_rapid(
+        self,
+        instruction: str,
+        truths: list[int],
+        datapoint: str,
+        sentence: str,
+        required_precision: float = 1,
+        required_completeness: float = 1,
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a select words rapid
 
@@ -130,7 +152,7 @@ class RapidsManager:
             required_completeness (float): The required completeness for the labeler to get the rapid correct (miminum ratio of total correct words selected). defaults to 1. (all correct words need to be selected)
             metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
-        
+
         asset = MediaAsset(datapoint)
         transcription_words = [
             TranscriptionWord(word=word, wordIndex=i)
@@ -144,7 +166,9 @@ class RapidsManager:
             )
 
         payload = TranscriptionPayload(
-            _t="TranscriptionPayload", title=instruction, transcription=transcription_words
+            _t="TranscriptionPayload",
+            title=instruction,
+            transcription=transcription_words,
         )
 
         model_truth = TranscriptionTruth(
@@ -155,20 +179,22 @@ class RapidsManager:
         )
 
         return Rapid(
-                payload=payload,
-                truth=model_truth,
-                asset=asset,
-                metadata=metadata,
-                explanation=explanation,
-                randomCorrectProbability= len(correct_transcription_words) / len(transcription_words)
-            )
-    
-    def locate_rapid(self,
-            instruction: str,
-            truths: list[Box],
-            datapoint: str,
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None,
+            payload=payload,
+            truth=model_truth,
+            asset=asset,
+            metadata=metadata,
+            explanation=explanation,
+            randomCorrectProbability=len(correct_transcription_words)
+            / len(transcription_words),
+        )
+
+    def locate_rapid(
+        self,
+        instruction: str,
+        truths: list[Box],
+        datapoint: str,
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a locate rapid
 
@@ -178,11 +204,9 @@ class RapidsManager:
             datapoint (str): The asset that the labeler will be locating the object in.
             metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
-        
+
         asset = MediaAsset(datapoint)
-        payload = LocatePayload(
-            _t="LocatePayload", target=instruction
-        )
+        payload = LocatePayload(_t="LocatePayload", target=instruction)
 
         img_dimensions = asset.get_image_dimension()
 
@@ -190,33 +214,39 @@ class RapidsManager:
             raise ValueError("Failed to get image dimensions")
 
         model_truth = LocateBoxTruth(
-            _t="LocateBoxTruth", 
-            boundingBoxes=[BoxShape(
-                _t="BoxShape",
-                xMin=truth.x_min / img_dimensions[0] * 100,
-                xMax=truth.x_max / img_dimensions[0] * 100,
-                yMax=truth.y_max / img_dimensions[1] * 100,
-                yMin=truth.y_min / img_dimensions[1] * 100,
-            ) for truth in truths]
+            _t="LocateBoxTruth",
+            boundingBoxes=[
+                BoxShape(
+                    _t="BoxShape",
+                    xMin=truth.x_min / img_dimensions[0] * 100,
+                    xMax=truth.x_max / img_dimensions[0] * 100,
+                    yMax=truth.y_max / img_dimensions[1] * 100,
+                    yMin=truth.y_min / img_dimensions[1] * 100,
+                )
+                for truth in truths
+            ],
         )
 
-        coverage = self._calculate_boxes_coverage(truths, img_dimensions[0], img_dimensions[1])
+        coverage = self._calculate_boxes_coverage(
+            truths, img_dimensions[0], img_dimensions[1]
+        )
 
         return Rapid(
-                payload=payload,
-                truth=model_truth,
-                asset=asset,
-                metadata=metadata,
-                explanation=explanation,
-                randomCorrectProbability=coverage                
-                )
-    
-    def draw_rapid(self,
-            instruction: str,
-            truths: list[Box],
-            datapoint: str,
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None
+            payload=payload,
+            truth=model_truth,
+            asset=asset,
+            metadata=metadata,
+            explanation=explanation,
+            randomCorrectProbability=coverage,
+        )
+
+    def draw_rapid(
+        self,
+        instruction: str,
+        truths: list[Box],
+        datapoint: str,
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a draw rapid
 
@@ -226,12 +256,10 @@ class RapidsManager:
             datapoint (str): The asset that the labeler will be drawing the object in.
             metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
-        
+
         asset = MediaAsset(datapoint)
 
-        payload = LinePayload(
-            _t="LinePayload", target=instruction
-        )
+        payload = LinePayload(_t="LinePayload", target=instruction)
 
         img_dimensions = asset.get_image_dimension()
 
@@ -239,14 +267,16 @@ class RapidsManager:
             raise ValueError("Failed to get image dimensions")
 
         model_truth = BoundingBoxTruth(
-            _t="BoundingBoxTruth", 
+            _t="BoundingBoxTruth",
             xMax=truths[0].x_max / img_dimensions[0] * 100,
             xMin=truths[0].x_min / img_dimensions[0] * 100,
             yMax=truths[0].y_max / img_dimensions[1] * 100,
             yMin=truths[0].y_min / img_dimensions[1] * 100,
         )
 
-        coverage = self._calculate_boxes_coverage(truths, img_dimensions[0], img_dimensions[1])
+        coverage = self._calculate_boxes_coverage(
+            truths, img_dimensions[0], img_dimensions[1]
+        )
 
         return Rapid(
             payload=payload,
@@ -254,16 +284,16 @@ class RapidsManager:
             asset=asset,
             metadata=metadata,
             explanation=explanation,
-            randomCorrectProbability=coverage
+            randomCorrectProbability=coverage,
         )
 
-
-    def timestamp_rapid(self,
-            instruction: str,
-            truths: list[tuple[int, int]],
-            datapoint: str,
-            metadata: Sequence[Metadata] = [],
-            explanation: str | None = None
+    def timestamp_rapid(
+        self,
+        instruction: str,
+        truths: list[tuple[int, int]],
+        datapoint: str,
+        metadata: Sequence[Metadata] = [],
+        explanation: str | None = None,
     ) -> Rapid:
         """Build a timestamp rapid
 
@@ -274,38 +304,40 @@ class RapidsManager:
             datapoint (str): The asset that the labeler will be timestamping.
             metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
-        
+
         asset = MediaAsset(datapoint)
-        
+
         for truth in truths:
             if len(truth) != 2:
-                raise ValueError("The truths per datapoint must be a tuple of exactly two integers.")
+                raise ValueError(
+                    "The truths per datapoint must be a tuple of exactly two integers."
+                )
             if truth[0] > truth[1]:
-                raise ValueError("The start of the interval must be smaller than the end of the interval.")
-        
-        payload = ScrubPayload(
-            _t="ScrubPayload", 
-            target=instruction
-        )
+                raise ValueError(
+                    "The start of the interval must be smaller than the end of the interval."
+                )
+
+        payload = ScrubPayload(_t="ScrubPayload", target=instruction)
 
         model_truth = ScrubTruth(
             _t="ScrubTruth",
-            validRanges=[ScrubRange(
-                start=truth[0],
-                end=truth[1]
-            ) for truth in truths]
+            validRanges=[ScrubRange(start=truth[0], end=truth[1]) for truth in truths],
         )
 
         return Rapid(
-                payload=payload,
-                truth=model_truth,
-                asset=asset,
-                metadata=metadata,
-                explanation=explanation,
-                randomCorrectProbability=self._calculate_coverage_ratio(asset.get_duration(), truths),
-                )
+            payload=payload,
+            truth=model_truth,
+            asset=asset,
+            metadata=metadata,
+            explanation=explanation,
+            randomCorrectProbability=self._calculate_coverage_ratio(
+                asset.get_duration(), truths
+            ),
+        )
 
-    def _calculate_boxes_coverage(self, boxes: list[Box], image_width: int, image_height: int) -> float:
+    def _calculate_boxes_coverage(
+        self, boxes: list[Box], image_width: int, image_height: int
+    ) -> float:
         if not boxes:
             return 0.0
         # Convert all coordinates to integers for pixel-wise coverage
@@ -314,48 +346,49 @@ class RapidsManager:
             for x in range(int(box.x_min), int(box.x_max + 1)):
                 for y in range(int(box.y_min), int(box.y_max + 1)):
                     if 0 <= x < image_width and 0 <= y < image_height:
-                        pixels.add((x,y))
-                        
+                        pixels.add((x, y))
+
         total_covered = len(pixels)
         return total_covered / (image_width * image_height)
 
-    def _calculate_coverage_ratio(self, total_duration: int, subsections: list[tuple[int, int]]) -> float:
+    def _calculate_coverage_ratio(
+        self, total_duration: int, subsections: list[tuple[int, int]]
+    ) -> float:
         """
         Calculate the ratio of total_duration that is covered by subsections, handling overlaps.
-        
+
         Args:
             total_duration: The total duration to consider
             subsections: List of tuples containing (start, end) times
-            
+
         Returns:
             float: Ratio of coverage (0 to 1)
         """
         if not subsections:
             return 0.0
-        
+
         # Sort subsections by start time and clamp to valid range
         sorted_ranges = sorted(
-            (max(0, start), min(end, total_duration)) 
-            for start, end in subsections
+            (max(0, start), min(end, total_duration)) for start, end in subsections
         )
-        
+
         # Merge overlapping ranges
         merged_ranges = []
         current_range = list(sorted_ranges[0])
-        
+
         for next_start, next_end in sorted_ranges[1:]:
             current_start, current_end = current_range
-            
+
             # If ranges overlap or are adjacent
             if next_start <= current_end:
                 current_range[1] = max(current_end, next_end)
             else:
                 merged_ranges.append(current_range)
                 current_range = [next_start, next_end]
-        
+
         merged_ranges.append(current_range)
-        
+
         # Calculate total coverage
         total_coverage = sum(end - start for start, end in merged_ranges)
-        
+
         return total_coverage / total_duration