rapidata 1.10.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

rapidata/rapidata_client/dataset/rapid_builders/classify_rapid_builders.py

@@ -1,166 +0,0 @@
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import ClassificationRapid
-
-class ClassifyRapidBuilder:
-    """Final builder class for classification rapid.
-    
-    This class handles the final construction of a classification rapid with all required parameters.
-    """
-    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset):
-        self._question = question
-        self._options = options
-        self._truths = truths
-        self._asset = asset
-        self._metadata = []
-
-    def prompt(self, prompt: str):
-        """Add a prompt to provide additional context for the classification task.
-        
-        Args:
-            prompt (str): Additional instructions or context
-            
-        Returns:
-            ClassifyRapidBuilder: The builder instance for method chaining
-        """
-        self._metadata.append(PromptMetadata(prompt))
-        return self
-    
-    def build(self):
-        """Constructs and returns the final classification rapid.
-        
-        Returns:
-            ClassificationRapid: The constructed classification rapid 
-        """
-        return ClassificationRapid(
-            question=self._question,
-            options=self._options,
-            truths=self._truths,
-            asset=self._asset,
-            metadata=self._metadata
-        )
-    
-class ClassifyRapidTruthBuilder:
-    """Builder class for the truths of the classification rapid.
-
-    This adds the truths to the classification rapid.
-    """
-    def __init__(self, question: str, options: list[str], asset: MediaAsset | TextAsset):
-        self._question = question
-        self._options = options
-        self._asset = asset
-        self._truths = None
-
-    def truths(self, truths: list[str]):
-        """Set the truths for the classification rapid.
-
-        Args:
-            truths (list[str]): The correct answers for the classification task"""
-        
-        if not isinstance(truths, list) or not all(isinstance(truth, str) for truth in truths):
-            raise ValueError("Truths must be a list of strings")
-        
-        if not all(truth in self._options for truth in truths):
-            raise ValueError("Truths must be one of the selectable options")
-        
-        self._truths = truths
-        return self._build()
-    
-    def _build(self):
-        if self._truths is None:
-            raise ValueError("Truths are required")
-        return ClassifyRapidBuilder(
-            question=self._question,
-            options=self._options,
-            asset=self._asset,
-            truths=self._truths,
-        )
-    
-class ClassifyRapidMediaBuilder:
-    """Builder class for the media asset of the classification rapid.
-
-    This class adds the media asset to the classification rapid.
-    """
-    def __init__(self, question: str, options: list[str]):
-        self._question = question
-        self._options = options
-        self._asset: MediaAsset | TextAsset | None = None
-
-    def media(self, media: str):
-        """Set the media asset for the classification rapid.
-
-        Args:
-            media (str): A local file path or an image URL. The image will be displayed with the classification task"""        
-        self._asset = MediaAsset(media)
-
-        return self._build()
-
-    def text(self, text: str):
-        """Set the text asset for the classification rapid.
-
-        Args:
-            text (str): The text to be displayed with the classification task"""
-        self._asset = TextAsset(text)
-
-        return self._build()
-
-    def _build(self):
-        if self._asset is None:
-            raise ValueError("Assets are required")
-        
-        return ClassifyRapidTruthBuilder(
-            question=self._question,
-            options=self._options,
-            asset=self._asset,
-        )
-
-class ClassifyRapidOptionsBuilder:
-    def __init__(self, question: str):
-        self._question = question
-        self._options = None
-
-    def options(self, options: list[str]):
-        """Set the options for the classification rapid.
-
-        Args:
-            options (list[str]): The selectable options for the classification task"""
-
-        if not isinstance(options, list) or not all(isinstance(option, str) for option in options):
-            raise ValueError("Options must be a list of strings")
-        
-        self._options = options
-        return self._build()
-    
-    def _build(self):
-        if self._options is None:
-            raise ValueError("Options are required")
-        
-        return ClassifyRapidMediaBuilder(
-            question=self._question,
-            options=self._options,
-        )
-
-
-class ClassifyRapidQuestionBuilder:
-    def __init__(self):
-        self._question = None
-
-    def question(self, question: str):
-        """Set the question for the classification rapid.
-
-        Args:
-            question (str): The question to be answered by the classification task"""
-        
-        if not isinstance(question, str):
-            raise ValueError("Question must be a string")
-        
-        self._question = question
-        return self._build()
-    
-    def _build(self):
-        if self._question is None:
-            raise ValueError("Question is required")
-        
-        return ClassifyRapidOptionsBuilder(
-            question=self._question,
-        )

rapidata/rapidata_client/dataset/rapid_builders/compare_rapid_builders.py

@@ -1,145 +0,0 @@
-from rapidata.rapidata_client.assets import MultiAsset, TextAsset, MediaAsset
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import CompareRapid
-import re
-
-class CompareRapidBuilder:
-    """Final builder class for comparison rapid.
-    
-    This class handles the final construction of a comparison rapid with all required parameters.
-    """
-    def __init__(self, criteria: str, truth: str, asset: MultiAsset):
-        """Initialize the comparison rapid builder.
-        
-        Args:
-            criteria (str): The criteria for comparison
-            truth (str): The correct answer
-            asset (MultiAsset): Collection of assets to be compared
-        """
-        self._criteria = criteria
-        self._truth = truth
-        self._asset = asset
-        self._metadata = []
-
-    def prompt(self, prompt: str):
-        """Add a prompt to provide additional context for the comparison.
-        
-        Args:
-            prompt (str): Additional instructions or context
-            
-        Returns:
-            CompareRapidBuilder: The builder instance for method chaining
-        """
-        self._metadata.append(PromptMetadata(prompt))
-        return self
-
-    def build(self):
-        """Constructs and returns the final comparison rapid.
-        
-        Returns:
-            CompareRapid: The constructed comparison rapid
-        """
-        return CompareRapid(
-            criteria=self._criteria,
-            asset=self._asset,
-            truth=self._truth,
-            metadata=self._metadata
-        )
-
-class CompareRapidTruthBuilder:
-    """Builder class for the truth of the comparison rapid.
-
-    This adds the truth to the comparison rapid.    
-    """
-    def __init__(self, criteria: str, asset: MultiAsset):
-        self._criteria = criteria
-        self._asset = asset
-        self._truth = None
-    
-    def truth(self, truth: str):
-        """Set the truth for the comparison rapid.
-
-        Args:
-            truth (str): The correct answer for the comparison task. Is the string of the correct media/text asset"""
-        
-        if not isinstance(truth, str):
-            raise ValueError("Truth must be a string.")
-        
-        self._truth = MediaAsset(truth).name
-        
-        return self._build()
-    
-    def _build(self):
-        if self._truth is None:
-            raise ValueError("Truth is required")
-        
-        return CompareRapidBuilder(
-            criteria=self._criteria,
-            asset=self._asset,
-            truth=self._truth,
-        )
-
-class CompareRapidAssetBuilder:
-    """Builder class for the asset of the comparison rapid.
-
-    This adds the asset to the comparison rapid.
-    """
-    def __init__(self, criteria: str):
-        self._criteria = criteria
-        self._asset: MultiAsset | None = None
-
-    def media(self, medias: list[str]):
-        """Set the media assets for the comparison rapid.
-
-        Args:
-            medias (list[str]): The local file paths or links of the media assets to be compared"""
-        
-        media_assets = [MediaAsset(media) for media in medias]
-        self._asset = MultiAsset(media_assets)
-        return self._build()
-    
-    def text(self, texts: list[str]):
-        """Set the text assets for the comparison rapid.
-
-        Args:
-            texts (list[str]): The texts to be compared"""
-        
-        text_assets = [TextAsset(text) for text in texts]
-        self._asset = MultiAsset(text_assets)
-        return self._build()
-    
-    def _build(self):
-        if self._asset is None:
-            raise ValueError("Asset is required")
-
-        return CompareRapidTruthBuilder(
-            criteria=self._criteria,
-            asset=self._asset,
-        )
-
-class CompareRapidCriteriaBuilder:
-    """Builder class for the criteria of the comparison rapid.
-
-    This adds the criteria to the comparison rapid."""
-    def __init__(self):
-        self._criteria = None
-
-    def criteria(self, criteria: str):
-        """Set the criteria for the comparison rapid.
-
-        Args:
-            criteria (str): The criteria for comparison"""
-        
-        if not isinstance(criteria, str):
-            raise ValueError("Criteria must be a string")
-        
-        self._criteria = criteria
-        return self._build()
-
-    def _build(self):
-        if self._criteria is None:
-            raise ValueError("Criteria is required")
-
-        return CompareRapidAssetBuilder(
-            criteria=self._criteria,
-        )

rapidata/rapidata_client/dataset/rapid_builders/rapids.py

@@ -1,33 +0,0 @@
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
-from rapidata.rapidata_client.metadata import Metadata
-
-class Rapid:
-    pass
-
-class ClassificationRapid(Rapid):
-    """A classification rapid. This represents the question, options, truths, asset and metadata that will be given to the labeler."""
-    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset, metadata: list[Metadata]):
-        self.question = question
-        self.options = options
-        self.truths = truths
-        self.asset = asset
-        self.metadata = metadata
-
-class CompareRapid(Rapid):
-    """A comparison rapid. This represents the criteria, asset, truth and metadata that will be given to the labeler."""
-    def __init__(self, criteria: str, truth: str, asset: MultiAsset, metadata: list[Metadata]):
-        self.criteria = criteria
-        self.asset = asset
-        self.truth = truth
-        self.metadata = metadata
-
-class SelectWordsRapid(Rapid):
-    """A transcription rapid. This represents the instruction, truths, asset, transcription and strict grading that will be given to the labeler."""
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, text: str, strict_grading: bool):
-        """The text will be split up by spaces to be selected by the labeler."""
-        self.instruction = instruction
-        self.truths = truths
-        self.asset = asset
-        self.text = text
-        self.strict_grading = strict_grading
-

rapidata/rapidata_client/dataset/rapid_builders/select_words_rapid_builders.py

@@ -1,124 +0,0 @@
-from rapidata.rapidata_client.assets import MediaAsset
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import SelectWordsRapid
-
-class SelectWordsRapidBuilder:
-    """Final builder class for rapid.
-    
-    This class handles the final construction of a rapid with all required parameters.
-    """
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, text: str):
-        self._instruction = instruction
-        self._truths = truths
-        self._asset = asset
-        self._text = text
-        self._strict_grading = True
-
-    def strict_grading(self, strict_grading: bool = True):
-        """Set whether to use strict grading for the select words.
-        Strict grading true: In order to be correct, you must select all of the right words
-        Strict grading false: In order to be correct, you must select at least one right word
-        In both cases it will be incorrect if you select any wrong words
-        
-        Args:
-            strict_grading (bool): Whether to use strict grading. Defaults to True."""
-        self._strict_grading = strict_grading
-        return self
-
-    def build(self):
-        """Constructs and returns the final rapid."""
-        return SelectWordsRapid(
-            instruction=self._instruction,
-            truths=self._truths,
-            asset=self._asset,
-            text=self._text,
-            strict_grading=self._strict_grading
-        )
-
-class SelectWordsRapidTruthsBuilder:
-    """Builder class for the truths of the rapid.
-
-    This adds the truths to the rapid.
-    """
-    def __init__(self, instruction: str, media: MediaAsset, text: str):
-        self._instruction = instruction
-        self._media = media
-        self._text = text
-        self._truths = None
-
-    def truths(self, truths: list[int]):
-        """Set the truths for the rapid.
-
-        Args:
-            truths (list[int]): The correct answers for the task. \
-                Each integer represents the index of the correct word in the text."""
-        
-        if not isinstance(truths, list) or not all(isinstance(truth, int) for truth in truths):
-            raise ValueError("Truths must be a list of integers")
-        
-        self._truths = truths
-        return self._build()
-    
-    def _build(self):
-        if self._truths is None:
-            raise ValueError("Truths are required")
-        
-        return SelectWordsRapidBuilder(
-            instruction=self._instruction,
-            truths=self._truths,
-            asset=self._media,
-            text=self._text
-        )
-
-class SelectWordsRapidAssetBuilder:
-    """Builder class for the asset of the rapid.
-
-    This adds the asset to the rapid.
-    """
-    def __init__(self, instruction: str):
-        self._instruction = instruction
-
-    def media(self, media: str, text: str):
-        """Set the media asset for the rapid.
-
-        Args:
-            media (str): The local path (image, video, audio) or URL (image) of the media asset.
-            text (str): The text will be split up by spaces and the labeler will be able to select the words"""
-        
-        self._asset = MediaAsset(media)
-        self._text = text
-
-        return self._build()
-
-    def _build(self):
-        if not self._asset:
-            raise ValueError("Media is required")
-        
-        return SelectWordsRapidTruthsBuilder(
-            instruction=self._instruction,
-            media=self._asset,
-            text=self._text
-        )
-
-class SelectWordsRapidInstructionBuilder:
-    def __init__(self):
-        self._instruction = None
-
-    def instruction(self, instruction: str):
-        """Set the instruction for the rapid.
-
-        Args:
-            instruction (str): The instruction for the task"""
-        
-        if not isinstance(instruction, str):
-            raise ValueError("Instruction must be a string")
-        
-        self._instruction = instruction
-        return self._build()
-    
-    def _build(self):
-        if self._instruction is None:
-            raise ValueError("Instruction is required")
-        
-        return SelectWordsRapidAssetBuilder(
-            instruction=self._instruction,
-        )