rapidata 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -1,139 +1,86 @@
+from pydantic import StrictBytes, StrictStr
 from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.metadata import Metadata
 from typing import Sequence
-from rapidata.rapidata_client.validation.rapids.box import Box
+from typing import Any
+from rapidata.api_client.models.add_validation_rapid_model import (
+    AddValidationRapidModel,
+)
+from rapidata.api_client.models.add_validation_text_rapid_model import (
+    AddValidationTextRapidModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model_payload import (
+    AddValidationRapidModelPayload,
+)
+from rapidata.api_client.models.add_validation_rapid_model_truth import (
+    AddValidationRapidModelTruth,
+)
 
-class Rapid:
-    pass
+from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
+    DatapointMetadataModelMetadataInner,
+)
 
-class ClassificationRapid(Rapid):
-    """
-    A classification rapid. Used as a multiple choice question for the labeler to answer.
-    
-    
-    Args: 
-        instruction (str): The instruction how to choose the options.
-        answer_options (list[str]): The options that the labeler can choose from.
-        truths (list[str]): The correct answers to the question.
-        asset (MediaAsset | TextAsset): The asset that the labeler will be labeling.
-        metadata (Sequence[Metadata]): The metadata that is attached to the rapid.
-    """
 
-    def __init__(self, instruction: str, answer_options: list[str], truths: list[str], asset: MediaAsset | TextAsset, metadata: Sequence[Metadata]):
-        self.instruction = instruction
-        self.answer_options = answer_options
-        self.truths = truths
+class Rapid():
+    def __init__(self, asset: MediaAsset | TextAsset | MultiAsset, metadata: Sequence[Metadata], payload: Any, truth: Any, randomCorrectProbability: float, explanation: str | None):
         self.asset = asset
         self.metadata = metadata
-
-class CompareRapid(Rapid):
-    """
-    Used as a comparison of two assets for the labeler to compare.
-    
-    Args:
-        instruction (str): The instruction that the labeler will be comparing the assets on.
-        truth (str): The correct answer to the comparison. (has to be one of the assets)
-        asset (MultiAsset): The assets that the labeler will be comparing.
-        metadata (Sequence[Metadata]): The metadata that is attached to the rapid.
-    """
-    def __init__(self, instruction: str, truth: str, asset: MultiAsset, metadata: Sequence[Metadata]):
-        self.instruction = instruction
-        self.asset = asset
+        self.payload = payload
         self.truth = truth
-        self.metadata = metadata
+        self.randomCorrectProbability = randomCorrectProbability
+        self.explanation = explanation 
 
-class SelectWordsRapid(Rapid):
-    """
-    Used to give the labeler a text and have them select words from it.
-    
-    Args:
-        instruction (str): The instruction for the labeler.
-        truths (list[int]): The indices of the words that are the correct answers.
-        asset (MediaAsset): The asset that the labeler will be selecting words from.
-        sentence (str): The sentence that the labeler will be selecting words from. (split up by spaces)
-        strict_grading (bool): Whether the grading should be strict or not. 
-            True means that all correct words and no wrong words have to be selected for the rapid to be marked as correct.
-            False means that at least one correct word and no wrong words have to be selected for the rapid to be marked as correct.
-    """
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, sentence: str, required_precision: float, required_completeness: float, metadata: Sequence[Metadata]):
-        if not isinstance(truths, list):
-            raise ValueError("The truths must be a list of integers.")
-        if not all(isinstance(x, int) for x in truths):
-            raise ValueError("The truths must be a list of integers.")
-        if required_completeness <= 0 or required_completeness > 1:
-            raise ValueError("The required completeness must be > 0 and <= 1.")
-        if required_precision <= 0 or required_precision > 1:
-            raise ValueError("The required precision must be > 0 and <= 1.")
-        
-        self.instruction = instruction
-        self.truths = truths
-        self.asset = asset
-        self.sentence = sentence
-        self.required_precision = required_precision
-        self.required_completeness = required_completeness
-        self.metadata = metadata
+    def to_media_model(self, validationSetId: str) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
+        assets: list[MediaAsset] = [] 
+        if isinstance(self.asset, MultiAsset):
+            for asset in self.asset.assets:
+                if isinstance(asset, MediaAsset):
+                    assets.append(asset)
+                else:
+                    raise TypeError("The asset is a multiasset, but not all assets are MediaAssets")
 
-class LocateRapid(Rapid):
-    """
-    Used to have the labeler locate a specific object in an image.
-    
-    Args:
-        instruction (str): The instructions on what the labeler should do.
-        truths (list[Box]): The boxes that the object is located in.
-        asset (MediaAsset): The image that the labeler is locating the object in.
-        metadata (Sequence[Metadata]): The metadata that is attached to the rapid.    
-    """
-    def __init__(self, instruction: str, truths: list[Box], asset: MediaAsset, metadata: Sequence[Metadata]):
-        self.instruction = instruction
-        self.asset = asset
-        self.truths = truths
-        self.metadata = metadata
+        if isinstance(self.asset, TextAsset):
+            raise TypeError("The asset must contain Media")
 
-class DrawRapid(Rapid):
-    """
-    Used to have the labeler draw a specific object in an image.
-    
-    Args:
-        instruction (str): The instructions on what the labeler should do.
-        truths (list[Box]): The boxes that the object is located in.
-        asset (MediaAsset): The image that the labeler is drawing the object in.
-        metadata (Sequence[Metadata]): The metadata that is attached to the rapid.
-    """
-    def __init__(self, instruction: str, truths: list[Box], asset: MediaAsset, metadata: Sequence[Metadata]):
-        self.instruction = instruction
-        self.asset = asset
-        self.truths = truths
-        self.metadata = metadata
+        if isinstance(self.asset, MediaAsset):
+            assets = [self.asset]
 
-class TimestampRapid(Rapid):
-    """
-    Used to have the labeler timestamp a video or audio file.
-    
-    Args:
-        instruction (str): The instruction for the labeler.
-        truths (list[tuple[int, int]]): The possible accepted timestamps intervals for the labeler (in miliseconds).
-            The first element of the tuple is the start of the interval and the second element is the end of the interval.
-        asset (MediaAsset): The asset that the labeler is timestamping.
-        metadata (Sequence[Metadata]): The metadata that is attached to the rapid.
-    """
-    def __init__(self, instruction: str, truths: list[tuple[int, int]], asset: MediaAsset, metadata: Sequence[Metadata]):
-        if not asset.get_duration():
-            raise ValueError("The datapoints must have a duration. (e.g. video or audio)")
-        
-        if not isinstance(truths, list):
-            raise ValueError("The truths must be a list of tuples.")
+        return (AddValidationRapidModel(
+            validationSetId=validationSetId,
+            payload=AddValidationRapidModelPayload(self.payload),
+            truth=AddValidationRapidModelTruth(self.truth),
+            metadata=[
+              DatapointMetadataModelMetadataInner(meta._to_model())
+              for meta in self.metadata
+            ],
+            randomCorrectProbability=self.randomCorrectProbability,
+            explanation=self.explanation
+        ), [asset.to_file() for asset in assets])
 
-        for truth in truths:
-            if len(truth) != 2 or not all(isinstance(x, int) for x in truth):
-                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.")
-            if truth[0] < 0:
-                raise ValueError("The start of the interval must be greater than or equal to 0.")
-            if truth[1] > asset.get_duration():
-                raise ValueError("The end of the interval can not be greater than the duration of the datapoint.")
-            
-        self.instruction = instruction
-        self.truths = truths
-        self.asset = asset
-        self.metadata = metadata
+    def to_text_model(self, validationSetId: str) -> AddValidationTextRapidModel:
+        texts: list[str] = []
+        if isinstance(self.asset, MultiAsset):
+            for asset in self.asset.assets:
+                if isinstance(asset, TextAsset):
+                    texts.append(asset.text)
+                else:
+                    raise TypeError("The asset is a multiasset, but not all assets are TextAssets")
+
+        if isinstance(self.asset, MediaAsset):
+            raise TypeError("The asset must contain Text")
+
+        if isinstance(self.asset, TextAsset):
+            texts = [self.asset.text]
+
+        return AddValidationTextRapidModel(
+          validationSetId=validationSetId,
+          payload=AddValidationRapidModelPayload(self.payload),
+          truth=AddValidationRapidModelTruth(self.truth),
+          metadata=[
+              DatapointMetadataModelMetadataInner(meta._to_model())
+              for meta in self.metadata
+          ],
+          randomCorrectProbability=self.randomCorrectProbability,
+          texts=texts,
+          explanation=self.explanation
+      )

rapidata/rapidata_client/validation/rapids/rapids_manager.py

@@ -1,17 +1,14 @@
+import os
+from rapidata.api_client import AttachCategoryTruth, BoundingBoxTruth, BoxShape, ClassifyPayload, ComparePayload, CompareTruth, LinePayload, LocateBoxTruth, LocatePayload, ScrubPayload, ScrubRange, ScrubTruth, TranscriptionPayload, TranscriptionTruth, TranscriptionWord
 from rapidata.rapidata_client.assets.data_type_enum import RapidataDataTypes
-from rapidata.rapidata_client.validation.rapids.rapids import (
-    ClassificationRapid, 
-    CompareRapid, 
-    SelectWordsRapid, 
-    LocateRapid, 
-    DrawRapid,
-    TimestampRapid)
 from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
 from rapidata.rapidata_client.metadata import Metadata
 from rapidata.rapidata_client.validation.rapids.box import Box
 
 from typing import Sequence
 
+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
@@ -26,7 +23,8 @@ class RapidsManager:
             truths: list[str],
             data_type: str = RapidataDataTypes.MEDIA,
             metadata: Sequence[Metadata] = [],
-    ) -> ClassificationRapid:
+            explanation: str | None = None,
+    ) -> Rapid:
         """Build a classification rapid
         
         Args:
@@ -45,13 +43,24 @@ class RapidsManager:
         else:
             raise ValueError(f"Unsupported data type: {data_type}")
 
-        return ClassificationRapid(
-                instruction=instruction,
-                answer_options=answer_options,
+        if not all(truth in answer_options for truth in truths):
+            raise ValueError("Truths must be part of the answer options")
+
+        payload = ClassifyPayload(
+            _t="ClassifyPayload", possibleCategories=answer_options, title=instruction
+        )
+        model_truth = AttachCategoryTruth(
+            correctCategories=truths, _t="AttachCategoryTruth"
+        )
+
+        return Rapid(
                 asset=asset,
-                truths=truths,
                 metadata=metadata,
-                )
+                explanation=explanation,
+                payload=payload,
+                truth=model_truth,
+                randomCorrectProbability=len(truths) / len(answer_options)
+             )
     
     def compare_rapid(self,
             instruction: str,
@@ -59,7 +68,8 @@ class RapidsManager:
             datapoint: list[str],
             data_type: str = RapidataDataTypes.MEDIA,
             metadata: Sequence[Metadata] = [],
-    ) -> CompareRapid:
+            explanation: str | None = None,
+    ) -> Rapid:
         """Build a compare rapid
 
         Args:
@@ -78,12 +88,23 @@ class RapidsManager:
             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)
+        model_truth = CompareTruth(_t="CompareTruth", winnerId=truth)
 
-        return CompareRapid(
-                instruction=instruction,
+        if len(asset) != 2:
+            raise ValueError("Compare rapid requires exactly two media paths")
+
+
+        return Rapid(
                 asset=asset,
-                truth=truth,
+                truth=model_truth,
                 metadata=metadata,
+                payload=payload,
+                explanation=explanation,
+                randomCorrectProbability= 1 / len(asset.assets)
                 )
     
     def select_words_rapid(self,
@@ -94,7 +115,8 @@ class RapidsManager:
             required_precision: float = 1,
             required_completeness: float = 1,
             metadata: Sequence[Metadata] = [],
-    ) -> SelectWordsRapid:
+            explanation: str | None = None,
+    ) -> Rapid:
         """Build a select words rapid
 
         Args:
@@ -108,23 +130,44 @@ class RapidsManager:
         """
         
         asset = MediaAsset(datapoint)
+        transcription_words = [
+            TranscriptionWord(word=word, wordIndex=i)
+            for i, word in enumerate(sentence)
+        ]
+
+        correct_transcription_words: list[TranscriptionWord] = []
+        for index in truths:
+            correct_transcription_words.append(
+                TranscriptionWord(word=transcription_words[index].word, wordIndex=index)
+            )
+
+        payload = TranscriptionPayload(
+            _t="TranscriptionPayload", title=instruction, transcription=transcription_words
+        )
+
+        model_truth = TranscriptionTruth(
+            _t="TranscriptionTruth",
+            correctWords=correct_transcription_words,
+            requiredPrecision=required_precision,
+            requiredCompleteness=required_completeness,
+        )
 
-        return SelectWordsRapid(
-                instruction=instruction,
-                truths=truths,
+        return Rapid(
+                payload=payload,
+                truth=model_truth,
                 asset=asset,
-                sentence=sentence,
-                required_precision=required_precision,
-                required_completeness=required_completeness,
                 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] = [],
-    ) -> LocateRapid:
+            explanation: str | None = None,
+    ) -> Rapid:
         """Build a locate rapid
 
         Args:
@@ -135,12 +178,35 @@ class RapidsManager:
         """
         
         asset = MediaAsset(datapoint)
+        payload = LocatePayload(
+            _t="LocatePayload", target=instruction
+        )
+
+        img_dimensions = asset.get_image_dimension()
+
+        if not img_dimensions:
+            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]
+        )
+
+        coverage = self._calculate_boxes_coverage(truths, img_dimensions[0], img_dimensions[1])
 
-        return LocateRapid(
-                instruction=instruction,
-                truths=truths,
+        return Rapid(
+                payload=payload,
+                truth=model_truth,
                 asset=asset,
                 metadata=metadata,
+                explanation=explanation,
+                randomCorrectProbability=coverage                
                 )
     
     def draw_rapid(self,
@@ -148,7 +214,8 @@ class RapidsManager:
             truths: list[Box],
             datapoint: str,
             metadata: Sequence[Metadata] = [],
-    ) -> DrawRapid:
+            explanation: str | None = None
+    ) -> Rapid:
         """Build a draw rapid
 
         Args:
@@ -160,19 +227,42 @@ class RapidsManager:
         
         asset = MediaAsset(datapoint)
 
-        return DrawRapid(
-                instruction=instruction,
-                truths=truths,
-                asset=asset,
-                metadata=metadata,
-                )
-    
+        payload = LinePayload(
+            _t="LinePayload", target=instruction
+        )
+
+        img_dimensions = asset.get_image_dimension()
+
+        if not img_dimensions:
+            raise ValueError("Failed to get image dimensions")
+
+        model_truth = BoundingBoxTruth(
+            _t="BoundingBoxTruth", 
+            xMax=truths[0].x_max / img_dimensions[0],
+            xMin=truths[0].x_min / img_dimensions[0],
+            yMax=truths[0].y_max / img_dimensions[1],
+            yMin=truths[0].y_min / 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 timestamp_rapid(self,
             instruction: str,
             truths: list[tuple[int, int]],
             datapoint: str,
-            metadata: Sequence[Metadata] = []
-    ) -> TimestampRapid:
+            metadata: Sequence[Metadata] = [],
+            explanation: str | None = None
+    ) -> Rapid:
         """Build a timestamp rapid
 
         Args:
@@ -184,12 +274,86 @@ class RapidsManager:
         """
         
         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.")
+            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
+        )
+
+        model_truth = ScrubTruth(
+            _t="ScrubTruth",
+            validRanges=[ScrubRange(
+                start=truth[0],
+                end=truth[1]
+            ) for truth in truths]
+        )
 
-        return TimestampRapid(
-                instruction=instruction,
-                truths=truths,
+        return Rapid(
+                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:
+        if not boxes:
+            return 0.0
+        # Convert all coordinates to integers for pixel-wise coverage
+        pixels = set()
+        for box in boxes:
+            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))
+                        
+        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:
+        """
+        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
+        )
+        
+        # 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