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

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -1,50 +1,3 @@
-import os
-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,
-)
-from rapidata.api_client.models.attach_category_truth import AttachCategoryTruth
-from rapidata.api_client.models.bounding_box_payload import BoundingBoxPayload
-from rapidata.api_client.models.bounding_box_truth import BoundingBoxTruth
-from rapidata.api_client.models.classify_payload import ClassifyPayload
-from rapidata.api_client.models.compare_payload import ComparePayload
-from rapidata.api_client.models.compare_truth import CompareTruth
-from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
-    DatapointMetadataModelMetadataInner,
-)
-from rapidata.api_client.models.empty_validation_truth import EmptyValidationTruth
-from rapidata.api_client.models.free_text_payload import FreeTextPayload
-from rapidata.api_client.models.line_payload import LinePayload
-from rapidata.api_client.models.line_truth import LineTruth
-from rapidata.api_client.models.locate_box_truth import LocateBoxTruth
-from rapidata.api_client.models.locate_payload import LocatePayload
-from rapidata.api_client.models.named_entity_payload import NamedEntityPayload
-from rapidata.api_client.models.named_entity_truth import NamedEntityTruth
-from rapidata.api_client.models.polygon_payload import PolygonPayload
-from rapidata.api_client.models.polygon_truth import PolygonTruth
-from rapidata.api_client.models.transcription_payload import TranscriptionPayload
-from rapidata.api_client.models.transcription_truth import TranscriptionTruth
-from rapidata.api_client.models.transcription_word import TranscriptionWord
-from rapidata.api_client.models.scrub_payload import ScrubPayload
-from rapidata.api_client.models.scrub_truth import ScrubTruth
-from rapidata.rapidata_client.assets._media_asset import MediaAsset
-from rapidata.rapidata_client.assets._multi_asset import MultiAsset
-from rapidata.rapidata_client.assets._text_asset import TextAsset
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-from rapidata.service.openapi_service import OpenAPIService
-
-from typing import Sequence
-
-
 class RapidataValidationSet:
     """A class for interacting with a Rapidata validation set.
 
@@ -57,257 +10,12 @@ class RapidataValidationSet:
         name (str): The name of the validation set.
     """
 
-    def __init__(self, validation_set_id, openapi_service: OpenAPIService, name: str):
+    def __init__(self, validation_set_id, name: str):
         self.id = validation_set_id
         self.name = name
-        self.__openapi_service = openapi_service
-
-    def __upload_files(self, model: AddValidationRapidModel, assets: list[MediaAsset]):
-        """Upload a file to the validation set.
-
-        Args:
-            assets: list[(MediaAsset)]: The asset to upload.
-        """
-        files = []
-        for asset in assets:
-            files.append(asset.to_file())
-            
-        self.__openapi_service.validation_api.validation_add_validation_rapid_post(
-            model=model, files=files
-        )        
-
-    def _add_general_validation_rapid(
-        self,
-        payload: (
-            BoundingBoxPayload
-            | ClassifyPayload
-            | ComparePayload
-            | FreeTextPayload
-            | LinePayload
-            | LocatePayload
-            | NamedEntityPayload
-            | PolygonPayload
-            | TranscriptionPayload
-            | ScrubPayload
-        ),
-        truths: (
-            AttachCategoryTruth
-            | BoundingBoxTruth
-            | CompareTruth
-            | EmptyValidationTruth
-            | LineTruth
-            | LocateBoxTruth
-            | NamedEntityTruth
-            | PolygonTruth
-            | TranscriptionTruth
-            | ScrubTruth
-        ),
-        metadata: Sequence[Metadata],
-        asset: MediaAsset | TextAsset | MultiAsset,
-        randomCorrectProbability: float,
-    ) -> None:
-        """Add a validation rapid to the validation set.
-
-        Args:
-            payload: The payload for the rapid.
-            truths: The truths for the rapid.
-            metadata (list[Metadata]): The metadata for the rapid.
-            asset: The asset(s) for the rapid.
-            randomCorrectProbability (float): The random correct probability for the rapid.
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: If an invalid asset type is provided.
-        """
-
-        model = AddValidationRapidModel(
-            validationSetId=self.id,
-            payload=AddValidationRapidModelPayload(payload),
-            truth=AddValidationRapidModelTruth(truths),
-            metadata=[
-                DatapointMetadataModelMetadataInner(meta._to_model())
-                for meta in metadata
-            ],
-            randomCorrectProbability=randomCorrectProbability,
-        )
-        if isinstance(asset, MediaAsset):
-            self.__upload_files(model=model, assets=[asset])
-
-        elif isinstance(asset, TextAsset):
-            model = AddValidationTextRapidModel(
-                validationSetId=self.id,
-                payload=AddValidationRapidModelPayload(payload),
-                truth=AddValidationRapidModelTruth(truths),
-                metadata=[
-                    DatapointMetadataModelMetadataInner(meta._to_model())
-                    for meta in metadata
-                ],
-                randomCorrectProbability=randomCorrectProbability,
-                texts=[asset.text],
-            )
-            self.__openapi_service.validation_api.validation_add_validation_text_rapid_post(
-                add_validation_text_rapid_model=model
-            )
-
-        elif isinstance(asset, MultiAsset):
-            files = [a for a in asset if isinstance(a, MediaAsset)]
-            texts = [a.text for a in asset if isinstance(a, TextAsset)]
-            if files:
-                self.__upload_files(model=model, assets=files)
-            if texts:
-                model = AddValidationTextRapidModel(
-                    validationSetId=self.id,
-                    payload=AddValidationRapidModelPayload(payload),
-                    truth=AddValidationRapidModelTruth(truths),
-                    metadata=[
-                        DatapointMetadataModelMetadataInner(meta._to_model())
-                        for meta in metadata
-                    ],
-                    randomCorrectProbability=randomCorrectProbability,
-                    texts=texts,
-                )
-                self.__openapi_service.validation_api.validation_add_validation_text_rapid_post(
-                    add_validation_text_rapid_model=model
-                )
-                
-        else:
-            raise ValueError("Invalid asset type")
-
-    def _add_classify_rapid(
-        self,
-        asset: MediaAsset | TextAsset,
-        instruction: str,
-        categories: list[str],
-        truths: list[str],
-        metadata: Sequence[Metadata] = [],
-    ) -> None:
-        """Add a classify rapid to the validation set.
-
-        Args:
-            asset (MediaAsset | TextAsset): The asset for the rapid.
-            instruction (str): The instruction for the rapid.
-            categories (list[str]): The list of categories for the rapid.
-            truths (list[str]): The list of truths for the rapid.
-            metadata (Sequence[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
-
-        Returns:
-            None
-        """
-        payload = ClassifyPayload(
-            _t="ClassifyPayload", possibleCategories=categories, title=instruction
-        )
-        model_truth = AttachCategoryTruth(
-            correctCategories=truths, _t="AttachCategoryTruth"
-        )
-
-        self._add_general_validation_rapid(
-            payload=payload,
-            truths=model_truth,
-            metadata=metadata,
-            asset=asset,
-            randomCorrectProbability=len(truths) / len(categories),
-        )
-
-    def _add_compare_rapid(
-        self,
-        asset: MultiAsset,
-        instruction: str,
-        truth: str,
-        metadata: Sequence[Metadata] = [],
-    ) -> None:
-        """Add a compare rapid to the validation set.
-
-        Args:
-            asset (MultiAsset): The assets for the rapid.
-            instruction (str): The instruction for the rapid.
-            truth (str): The path to the truth file.
-            metadata (Sequence[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: If the number of assets is not exactly two.
-        """
-        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)
-
-        if len(asset) != 2:
-            raise ValueError("Compare rapid requires exactly two media paths")
-
-        self._add_general_validation_rapid(
-            payload=payload,
-            truths=model_truth,
-            metadata=metadata,
-            asset=asset,
-            randomCorrectProbability=1 / len(asset),
-        )
-
-    def _add_transcription_rapid(
-        self,
-        asset: MediaAsset | TextAsset,
-        instruction: str,
-        text: list[str],
-        correct_words: list[str],
-        required_precision: float = 1,
-        required_completeness: float = 1,
-        metadata: Sequence[Metadata] = [],
-    ) -> None:
-        """Add a transcription rapid to the validation set.
-
-        Args:
-            asset (MediaAsset | TextAsset): The asset for the rapid.
-            instruction (str): The instruction for the rapid.
-            text (list[str]): The text for the rapid.
-            correct_words (list[str]): The list of correct words for the rapid.
-            required_precision (float, optional): The required precision for the rapid. Defaults to 1.
-            required_completeness (float, optional): The required completeness for the rapid. Defaults to 1.
-            metadata (Sequence[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: If a correct word is not found in the transcription.
-        """
-        transcription_words = [
-            TranscriptionWord(word=word, wordIndex=i)
-            for i, word in enumerate(text)
-        ]
-
-        correct_transcription_words = []
-        for word in correct_words:
-            if word not in text:
-                raise ValueError(f"Correct word '{word}' not found in transcription")
-            correct_transcription_words.append(
-                TranscriptionWord(word=word, wordIndex=text.index(word))
-            )
-
-        payload = TranscriptionPayload(
-            _t="TranscriptionPayload", title=instruction, transcription=transcription_words
-        )
-
-        model_truth = TranscriptionTruth(
-            _t="TranscriptionTruth",
-            correctWords=correct_transcription_words,
-            requiredPrecision=required_precision,
-            requiredCompleteness=required_completeness,
-        )
-
-        self._add_general_validation_rapid(
-            payload=payload,
-            truths=model_truth,
-            metadata=metadata,
-            asset=asset,
-            randomCorrectProbability=len(correct_words) / len(text),
-        )
 
     def __str__(self):
         return f"name: '{self.name}' id: {self.id}"
-    
+
     def __repr__(self):
         return f"name: '{self.name}' id: {self.id}"

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
+      )