rapidata 1.8.2__py3-none-any.whl → 1.9.0__py3-none-any.whl

rapidata/__init__.py

@@ -1,7 +1,7 @@
 from .rapidata_client import (
     RapidataClient,
     ClassifyWorkflow,
-    TranscriptionWorkflow,
+    SelectWordsWorkflow,
     CompareWorkflow,
     FreeTextWorkflow,
     DemographicSelection,
@@ -14,7 +14,7 @@ from .rapidata_client import (
     PrivateTextMetadata,
     PublicTextMetadata,
     PromptMetadata,
-    TranscriptionMetadata,
+    SelectWordsMetadata,
     Settings,
     FeatureFlags, # remove next major version
     CountryCodes,

rapidata/constants.py

@@ -0,0 +1 @@
+MAX_TIME_IN_SECONDS_FOR_ONE_SESSION=25

rapidata/rapidata_client/__init__.py

@@ -1,7 +1,7 @@
 from .rapidata_client import RapidataClient
 from .workflow import (
     ClassifyWorkflow,
-    TranscriptionWorkflow,
+    SelectWordsWorkflow,
     CompareWorkflow,
     FreeTextWorkflow,
 )
@@ -17,7 +17,7 @@ from .metadata import (
     PrivateTextMetadata,
     PublicTextMetadata,
     PromptMetadata,
-    TranscriptionMetadata,
+    SelectWordsMetadata,
 )
 from .settings import Settings, FeatureFlags # remove FeatureFlags next major version
 from .country_codes import CountryCodes

rapidata/rapidata_client/assets/media_asset.py

@@ -13,6 +13,7 @@ class MediaAsset(BaseAsset):
     """MediaAsset Class
 
     Represents a media asset by storing the file path.
+    Supports local files and URLs for images, MP3, and MP4.
 
     Args:
         path (str): The file system path to the media asset.
@@ -21,68 +22,76 @@ class MediaAsset(BaseAsset):
         FileNotFoundError: If the provided file path does not exist.
     """
 
+    ALLOWED_TYPES = [
+        'image/', 
+        'audio/mp3',      # MP3
+        'video/mp4',       # MP4
+    ]
+
     def __init__(self, path: str):
         """
         Initialize a MediaAsset instance.
 
         Args:
-            path (str): The file system path to the media asset or a link to an image.
+            path (str): The file system path to the media asset or a URL.
 
         Raises:
             FileNotFoundError: If the provided file path does not exist.
+            ValueError: If media type is unsupported or duration exceeds 25 seconds.
         """
         if not isinstance(path, str):
-            raise ValueError("Media must be a string, either a local file path or an image URL")
+            raise ValueError("Media must be a string, either a local file path or a URL")
 
         if re.match(r'^https?://', path):
-            self.path = MediaAsset.get_image_bytes(path)
+            self.path = self._get_media_bytes(path)
             self.name = path.split('/')[-1]
-            if not self.name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
-                self.name += '.jpg'
+            if not self.name.endswith(('.jpg', '.jpeg', '.png', '.gif', '.mp3', '.mp4', '.webp')):
+                raise ValueError("Supported file types for custom names: jpg, jpeg, png, gif, mp3, mp4")
             return
         
         if not os.path.exists(path):
-            raise FileNotFoundError(f"File not found: {path}, please provide a valid local file path.")
+            raise FileNotFoundError(f"File not found: {path}")
+        
         
         self.path: str | bytes = path
         self.name = path
     
     def set_custom_name(self, name: str) -> 'MediaAsset':
-        """
-        Set a custom name for the media asset, will only work with links.
-
-        Args:
-            name (str): The custom name to be set.
-        """
+        """Set a custom name for the media asset (only works with URLs)."""
         if isinstance(self.path, bytes):
-            if not name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
-                name += '.jpg'
+            if not name.endswith(('.jpg', '.jpeg', '.png', '.gif', '.mp3', '.mp4', '.webp')):
+                raise ValueError("Supported file types for custom names: jpg, jpeg, png, gif, mp3, mp4")
             self.name = name
         else:
-            raise ValueError("Custom name can only be set for links.")
+            raise ValueError("Custom name can only be set for URLs.")
         return self
 
-    @staticmethod
-    def get_image_bytes(image_url: str) -> bytes:
+    def _get_media_bytes(self, url: str) -> bytes:
         """
-        Downloads an image from a URL and converts it to bytes.
-        Validates that the URL points to an actual image.
+        Downloads media files from URL and validates type and duration.
         
         Args:
-            image_url (str): URL of the image
-            
+            url: URL of the media file
+                
         Returns:
-            bytes: Image data as bytes
+            bytes: Media data
             
         Raises:
-            ValueError: If URL doesn't point to an image
+            ValueError: If media type is unsupported or duration exceeds limit
             requests.exceptions.RequestException: If download fails
         """
-        response = requests.get(image_url)
+        response = requests.get(url, stream=False)  # Don't stream, we need full file
         response.raise_for_status()
+
+        content_type = response.headers.get('content-type', '').lower()
         
-        content_type = response.headers.get('content-type', '')
-        if not content_type.startswith('image/'):
-            raise ValueError(f'URL does not point to an image. Content-Type: {content_type}')
-        
-        return BytesIO(response.content).getvalue()
+        # Validate content type
+        if not any(content_type.startswith(t) for t in self.ALLOWED_TYPES):
+            raise ValueError(
+                f'URL does not point to an allowed media type.\n'
+                f'Content-Type: {content_type}\n'
+                f'Allowed types: {self.ALLOWED_TYPES}'
+            )
+
+        content = BytesIO(response.content)
+        return content.getvalue()

rapidata/rapidata_client/dataset/rapid_builders/__init__.py

@@ -1,4 +1,4 @@
 from .classify_rapid_builders import ClassifyRapidQuestionBuilder
 from .compare_rapid_builders import CompareRapidCriteriaBuilder
-from .transcription_rapid_builders import TranscriptionRapidInstructionBuilder
+from .select_words_rapid_builders import SelectWordsRapidInstructionBuilder
 from .base_rapid_builder import BaseRapidBuilder

rapidata/rapidata_client/dataset/rapid_builders/base_rapid_builder.py

@@ -1,5 +1,5 @@
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.dataset.rapid_builders import ClassifyRapidQuestionBuilder, CompareRapidCriteriaBuilder, TranscriptionRapidInstructionBuilder
+from rapidata.rapidata_client.dataset.rapid_builders import ClassifyRapidQuestionBuilder, CompareRapidCriteriaBuilder, SelectWordsRapidInstructionBuilder
 
 class BaseRapidBuilder:
     """Base class for creating different types of rapids.
@@ -23,11 +23,11 @@ class BaseRapidBuilder:
         """
         return CompareRapidCriteriaBuilder()
     
-    def transcription_rapid(self):
-        """Creates a transcription rapid.
+    def select_words_rapid(self):
+        """Creates a select words rapid.
         
         Returns:
-            TranscriptionRapidInstructionBuilder: A builder for creating the transcription instruction.
+            SelectWordsRapidInstructionBuilder: A builder for creating the select words instruction.
         """
-        return TranscriptionRapidInstructionBuilder()
+        return SelectWordsRapidInstructionBuilder()
         

rapidata/rapidata_client/dataset/rapid_builders/rapids.py

@@ -5,7 +5,7 @@ class Rapid:
     pass
 
 class ClassificationRapid(Rapid):
-    """A classification rapid. This represents the question, options, truths, asset and metadata that will be given to the user."""
+    """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
@@ -14,19 +14,20 @@ class ClassificationRapid(Rapid):
         self.metadata = metadata
 
 class CompareRapid(Rapid):
-    """A comparison rapid. This represents the criteria, asset, truth and metadata that will be given to the user."""
+    """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 TranscriptionRapid(Rapid):
-    """A transcription rapid. This represents the instruction, truths, asset, transcription and strict grading that will be given to the user."""
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, transcription: str, strict_grading: bool):
+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.transcription = transcription
+        self.text = text
         self.strict_grading = strict_grading
 

rapidata/rapidata_client/dataset/rapid_builders/{transcription_rapid_builders.py → select_words_rapid_builders.py}

@@ -1,64 +1,56 @@
 from rapidata.rapidata_client.assets import MediaAsset
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import TranscriptionRapid
+from rapidata.rapidata_client.dataset.rapid_builders.rapids import SelectWordsRapid
 
-class TranscriptionRapidBuilder:
-    """Final builder class for transcription rapid.
+class SelectWordsRapidBuilder:
+    """Final builder class for rapid.
     
-    This class handles the final construction of a transcription rapid with all required parameters.
+    This class handles the final construction of a rapid with all required parameters.
     """
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, transcription_text: str):
+    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, text: str):
         self._instruction = instruction
         self._truths = truths
         self._asset = asset
-        self._transcription_text = transcription_text
+        self._text = text
         self._strict_grading = True
 
     def strict_grading(self, strict_grading: bool = True):
-        """Set whether to use strict grading for the transcription.
+        """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.
-            
-        Returns:
-            TranscriptionRapidBuilder: The builder instance for method chaining
-        """
+            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 transcription rapid.
-        
-        Returns:
-            TranscriptionRapid: The constructed transcription rapid
-        """
-        return TranscriptionRapid(
+        """Constructs and returns the final rapid."""
+        return SelectWordsRapid(
             instruction=self._instruction,
             truths=self._truths,
             asset=self._asset,
-            transcription=self._transcription_text,
+            text=self._text,
             strict_grading=self._strict_grading
         )
 
-class TranscriptionRapidTruthsBuilder:
-    """Builder class for the truths of the transcription rapid.
+class SelectWordsRapidTruthsBuilder:
+    """Builder class for the truths of the rapid.
 
-    This adds the truths to the transcription rapid.
+    This adds the truths to the rapid.
     """
-    def __init__(self, instruction: str, media: MediaAsset, transcription_text: str):
+    def __init__(self, instruction: str, media: MediaAsset, text: str):
         self._instruction = instruction
         self._media = media
-        self._transcription_text = transcription_text
+        self._text = text
         self._truths = None
 
     def truths(self, truths: list[int]):
-        """Set the truths for the transcription rapid.
+        """Set the truths for the rapid.
 
         Args:
-            truths (list[int]): The correct answers for the transcription task. \
-                Each integer represents the index of the correct word in the transcription text."""
+            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")
@@ -70,30 +62,30 @@ class TranscriptionRapidTruthsBuilder:
         if self._truths is None:
             raise ValueError("Truths are required")
         
-        return TranscriptionRapidBuilder(
+        return SelectWordsRapidBuilder(
             instruction=self._instruction,
             truths=self._truths,
             asset=self._media,
-            transcription_text=self._transcription_text
+            text=self._text
         )
 
-class TranscriptionRapidAssetBuilder:
-    """Builder class for the asset of the transcription rapid.
+class SelectWordsRapidAssetBuilder:
+    """Builder class for the asset of the rapid.
 
-    This adds the asset to the transcription rapid.
+    This adds the asset to the rapid.
     """
     def __init__(self, instruction: str):
         self._instruction = instruction
 
-    def media(self, media: str, transcription_text: str):
-        """Set the media asset for the transcription rapid.
+    def media(self, media: str, text: str):
+        """Set the media asset for the rapid.
 
         Args:
-            media (str): The local file path of the audio or video file to be transcribed 
-            transcription_text (str): The text to be transcribed from the media asset""" # is video file okay?
+            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._transcription_text = transcription_text
+        self._text = text
 
         return self._build()
 
@@ -101,21 +93,21 @@ class TranscriptionRapidAssetBuilder:
         if not self._asset:
             raise ValueError("Media is required")
         
-        return TranscriptionRapidTruthsBuilder(
+        return SelectWordsRapidTruthsBuilder(
             instruction=self._instruction,
             media=self._asset,
-            transcription_text=self._transcription_text
+            text=self._text
         )
 
-class TranscriptionRapidInstructionBuilder:
+class SelectWordsRapidInstructionBuilder:
     def __init__(self):
         self._instruction = None
 
     def instruction(self, instruction: str):
-        """Set the instruction for the transcription rapid.
+        """Set the instruction for the rapid.
 
         Args:
-            instruction (str): The instruction for the transcription task"""
+            instruction (str): The instruction for the task"""
         
         if not isinstance(instruction, str):
             raise ValueError("Instruction must be a string")
@@ -127,6 +119,6 @@ class TranscriptionRapidInstructionBuilder:
         if self._instruction is None:
             raise ValueError("Instruction is required")
         
-        return TranscriptionRapidAssetBuilder(
+        return SelectWordsRapidAssetBuilder(
             instruction=self._instruction,
         )

rapidata/rapidata_client/dataset/rapidata_validation_set.py

@@ -298,3 +298,9 @@ class RapidataValidationSet:
             asset=asset,
             randomCorrectProbability=len(correct_words) / len(transcription),
         )
+
+    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/dataset/validation_set_builder.py

@@ -20,7 +20,7 @@ from rapidata.rapidata_client.dataset.rapid_builders.rapids import (
     Rapid, 
     ClassificationRapid,
     CompareRapid,
-    TranscriptionRapid
+    SelectWordsRapid
 )
 from deprecated import deprecated
 
@@ -96,8 +96,8 @@ class ValidationSetBuilder:
         if isinstance(rapid, CompareRapid):
             self._add_compare_rapid(rapid.asset, rapid.criteria, rapid.truth, rapid.metadata)
 
-        if isinstance(rapid, TranscriptionRapid):
-            self._add_transcription_rapid(rapid.asset, rapid.instruction, rapid.transcription, rapid.truths, rapid.strict_grading)
+        if isinstance(rapid, SelectWordsRapid):
+            self._add_select_words_rapid(rapid.asset, rapid.instruction, rapid.text, rapid.truths, rapid.strict_grading)
 
         return self
 
@@ -237,21 +237,21 @@ class ValidationSetBuilder:
         )
 
     @deprecated("Use add_rapid instead")
-    def add_transcription_rapid(
+    def add_select_words_rapid(
         self,
         asset: MediaAsset | TextAsset,
         question: str,
-        transcription: str,
+        select_words: str,
         truths: list[int],
         strict_grading: bool | None = None,
         metadata: list[Metadata] = [],
     ):
-        """Add a transcription rapid to the validation set.
+        """Add a select words rapid to the validation set.
 
         Args:
             asset (MediaAsset | TextAsset): The asset for the rapid.
             question (str): The question for the rapid.
-            transcription (list[str]): The transcription for the rapid.
+            select words (list[str]): The select words for the rapid.
             truths (list[int]): The list of indices of the true word selections.
             strict_grading (bool | None, optional): The strict grading for the rapid. Defaults to None.
             metadata (list[Metadata], optional): The metadata for the rapid.
@@ -260,27 +260,27 @@ class ValidationSetBuilder:
             ValidationSetBuilder: The ValidationSetBuilder instance.
 
         Raises:
-            ValueError: If a correct word is not found in the transcription.
+            ValueError: If a correct word is not found in the select words.
         """
-        self._add_transcription_rapid(asset, question, transcription, truths, strict_grading, metadata)
+        self._add_select_words_rapid(asset, question, select_words, truths, strict_grading, metadata)
 
         return self
     
-    def _add_transcription_rapid(
+    def _add_select_words_rapid(
         self,
         asset: MediaAsset | TextAsset,
         question: str,
-        transcription: str,
+        select_words: str,
         truths: list[int],
         strict_grading: bool | None = None,
         metadata: list[Metadata] = [],
     ):
-        """Add a transcription rapid to the validation set.
+        """Add a select words rapid to the validation set.
 
         Args:
             asset (MediaAsset | TextAsset): The asset for the rapid.
             question (str): The question for the rapid.
-            transcription (list[str]): The transcription for the rapid.
+            select words (list[str]): The select words for the rapid.
             truths (list[int]): The list of indices of the true word selections.
             strict_grading (bool | None, optional): The strict grading for the rapid. Defaults to None.
             metadata (list[Metadata], optional): The metadata for the rapid.
@@ -289,11 +289,11 @@ class ValidationSetBuilder:
             ValidationSetBuilder: The ValidationSetBuilder instance.
 
         Raises:
-            ValueError: If a correct word is not found in the transcription.
+            ValueError: If a correct word is not found in the select words.
         """
         transcription_words = [
             TranscriptionWord(word=word, wordIndex=i)
-            for i, word in enumerate(transcription.split())
+            for i, word in enumerate(select_words.split())
         ]
 
         true_words = []

rapidata/rapidata_client/metadata/__init__.py

@@ -2,4 +2,4 @@ from .base_metadata import Metadata
 from .private_text_metadata import PrivateTextMetadata
 from .public_text_metadata import PublicTextMetadata
 from .prompt_metadata import PromptMetadata
-from .transcription_metadata import TranscriptionMetadata
+from .select_words_metadata import SelectWordsMetadata

rapidata/rapidata_client/metadata/{transcription_metadata.py → select_words_metadata.py}

@@ -4,16 +4,16 @@ from rapidata.api_client.models.transcription_metadata_input import (
 from rapidata.rapidata_client.metadata.base_metadata import Metadata
 
 
-class TranscriptionMetadata(Metadata):
+class SelectWordsMetadata(Metadata):
 
-    def __init__(self, transcription: str, identifier: str = "transcription"):
+    def __init__(self, select_words: str, identifier: str = "transcription"):
         super().__init__(identifier=identifier)
         self.identifier = identifier
-        self.transcription = transcription
+        self.select_words = select_words
 
     def to_model(self):
         return TranscriptionMetadataInput(
             _t="TranscriptionMetadataInput",
             identifier=self.identifier,
-            transcription=self.transcription,
+            transcription=self.select_words,
         )

rapidata/rapidata_client/order/rapidata_order.py

@@ -106,7 +106,7 @@ class RapidataOrder:
         Returns: 
             The results of the order.
         """
-        while self.get_status() not in ["Completed", "Paused", "ManuelReview"]:
+        while self.get_status() not in ["Completed", "Paused", "ManuelReview", "Failed"]:
             sleep(5)
 
         try:

rapidata/rapidata_client/rapidata_client.py

@@ -8,7 +8,7 @@ from rapidata.rapidata_client.dataset.rapidata_dataset import RapidataDataset
 from rapidata.rapidata_client.simple_builders.simple_classification_builders import ClassificationQuestionBuilder
 from rapidata.rapidata_client.simple_builders.simple_compare_builders import CompareCriteriaBuilder
 from rapidata.rapidata_client.simple_builders.simple_free_text_builders import FreeTextQuestionBuilder
-from rapidata.rapidata_client.simple_builders.simple_transcription_builders import TranscriptionInstructionBuilder
+from rapidata.rapidata_client.simple_builders.simple_select_words_builders import SelectWordsInstructionBuilder
 
 from rapidata.rapidata_client.dataset.rapid_builders import BaseRapidBuilder
 
@@ -194,14 +194,14 @@ class RapidataClient:
         """
         return FreeTextQuestionBuilder(name=name, openapi_service=self.openapi_service)
     
-    def create_transcription_order(self, name: str) -> TranscriptionInstructionBuilder:
-        """Create a new transcription order where people are asked to transcribe an audio file.
+    def create_select_words_order(self, name: str) -> SelectWordsInstructionBuilder:
+        """Create a new select words order where people are asked to transcribe an audio file.
 
         Args:
             name (str): The name of the order.
 
         Returns:
-            TranscriptionInstructionBuilder: A TranscriptionInstructionBuilder instance.
+            SelectWordsInstructionBuilder: A SelectWordsInstructionBuilder instance.
         """
-        return TranscriptionInstructionBuilder(name=name, openapi_service=self.openapi_service)
+        return SelectWordsInstructionBuilder(name=name, openapi_service=self.openapi_service)
 

rapidata/rapidata_client/simple_builders/simple_classification_builders.py

@@ -1,4 +1,4 @@
-from constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
+from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.metadata import Metadata, PromptMetadata
@@ -219,6 +219,15 @@ class ClassificationOptionsBuilder:
 
     def options(self, options: list[str]) -> ClassificationMediaBuilder:
         """Set the answer options for the classification order."""
+        if not isinstance(options, list) or not all(isinstance(option, str) for option in options):
+            raise ValueError("Options must be a list of strings")
+        
+        if len(options) < 2:
+            raise ValueError("At least two options are required")
+        
+        if len(options) > 8:
+            raise ValueError("Maximum of 8 options allowed")
+
         self._options = options
         return self._build()
 

rapidata/rapidata_client/simple_builders/simple_compare_builders.py

@@ -1,4 +1,4 @@
-from constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
+from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.metadata import Metadata, PromptMetadata
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
@@ -29,7 +29,7 @@ class CompareOrderBuilder:
         self._time_effort = time_effort
 
     def responses(self, responses_required: int) -> 'CompareOrderBuilder':
-        """Set the number of resoonses required per matchup/pairing for the comparison order. Will default to 10."""
+        """Set the number of resoonses required per matchup/pairing for the comparison order. Will default to 10 if not set."""
         self._responses_required = responses_required
         return self
     

rapidata/rapidata_client/simple_builders/simple_free_text_builders.py

@@ -1,4 +1,4 @@
-from constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
+from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee

rapidata/rapidata_client/simple_builders/{simple_transcription_builders.py → simple_select_words_builders.py}

@@ -1,62 +1,62 @@
-from constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
+from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection.base_selection import Selection
-from rapidata.rapidata_client.workflow import TranscriptionWorkflow
+from rapidata.rapidata_client.workflow import SelectWordsWorkflow
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.assets import MediaAsset, BaseAsset
 from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
-from rapidata.rapidata_client.metadata import TranscriptionMetadata
+from rapidata.rapidata_client.metadata import SelectWordsMetadata
 from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
 
-class TranscriptionOrderBuilder:
+class SelectWordsOrderBuilder:
     def __init__(self, 
                  name: str, 
                  instruction: str, 
                  media_assets: list[BaseAsset], 
-                 transcription_texts: list[TranscriptionMetadata],
+                 texts: list[SelectWordsMetadata],
                  openapi_service: OpenAPIService, 
                  time_effort: int):
         self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
         self._instruction = instruction
         self._media_assets = media_assets
-        self._transcription_texts = transcription_texts
+        self._texts = texts
         self._validation_set_id = None
         self._referee = NaiveReferee()
         self._settings = Settings()
         self._filters: list[Filter] = []
         self._time_effort = time_effort
 
-    def responses(self, responses_required: int) -> 'TranscriptionOrderBuilder':
-        """Set the number of responses required per datapoint for the transcription order. Will default to 10."""
+    def responses(self, responses_required: int) -> 'SelectWordsOrderBuilder':
+        """Set the number of responses required per datapoint for the order. Will default to 10."""
         self._referee = NaiveReferee(responses=responses_required)
         return self
 
-    def validation_set(self, validation_set_id: str) -> 'TranscriptionOrderBuilder':
-        """Set the validation set for the transcription order."""
+    def validation_set(self, validation_set_id: str) -> 'SelectWordsOrderBuilder':
+        """Set the validation set for the order."""
         self._validation_set_id = validation_set_id
         return self
     
-    def countries(self, country_codes: list[str]) -> 'TranscriptionOrderBuilder':
+    def countries(self, country_codes: list[str]) -> 'SelectWordsOrderBuilder':
         """Set the countries where order will be shown as country codes."""
         self._filters.append(CountryFilter(country_codes))
         return self
     
-    def languages(self, language_codes: list[str]) -> 'TranscriptionOrderBuilder':
+    def languages(self, language_codes: list[str]) -> 'SelectWordsOrderBuilder':
         """Set the languages where order will be shown as language codes."""
         self._filters.append(LanguageFilter(language_codes))
         return self
     
-    def wait_for_video_to_finish(self, offset: int = 0) -> 'TranscriptionOrderBuilder':
+    def wait_for_video_to_finish(self, offset: int = 0) -> 'SelectWordsOrderBuilder':
         """Allows labeler to only answer once the video has finished playing.
         The offset gets added on top. Can be negative to allow answers before the video ends."""
         self._settings.play_video_until_the_end(offset)
         return self
     
-    def translation(self, disable: bool = False, show_both: bool = False) -> 'TranscriptionOrderBuilder':
+    def translation(self, disable: bool = False, show_both: bool = False) -> 'SelectWordsOrderBuilder':
         """Disable the translation of the order.
         Only the instruction will be translated.
         
@@ -84,15 +84,12 @@ class TranscriptionOrderBuilder:
         return self
 
     def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
-        """Run the transcription order.
+        """Run the order.
         
         Args:
             submit (bool): Whether to submit the order. Defaults to True. \
                 Set this to False if you first want to see the order on your dashboard before running it.
-            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
-            
-        Returns:
-            RapidataOrder: The created transcription order."""
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False."""
         
         if (self._validation_set_id and MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1 < 1) or (MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort < 1):
             raise ValueError(f"The Labelers only have {MAX_TIME_IN_SECONDS_FOR_ONE_SESSION} seconds to do the task. \
@@ -106,12 +103,12 @@ class TranscriptionOrderBuilder:
 
         order = (self._order_builder
             .workflow(
-                TranscriptionWorkflow(
+                SelectWordsWorkflow(
                     instruction=self._instruction
                 )
             )
             .referee(self._referee)
-            .media(self._media_assets, metadata=self._transcription_texts)
+            .media(self._media_assets, metadata=self._texts)
             .selections(selection)
             .settings(self._settings)
             .filters(self._filters)
@@ -120,36 +117,31 @@ class TranscriptionOrderBuilder:
         return order 
 
 
-class TranscriptionMediaBuilder:
+class SelectWordsMediaBuilder:
     def __init__(self, name: str, instruction: str, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         self._name = name
         self._instruction = instruction
         self._media_assets: list[BaseAsset] = []
-        self._transcription_texts: list[TranscriptionMetadata] = []
-        self._time_effort = 20
+        self._texts: list[SelectWordsMetadata] = []
+        self._time_effort = 10
 
-    def media(self, media_paths: list[str], transcription_texts: list[str], time_effort: int = 20) -> TranscriptionOrderBuilder:
-        """Set the media assets for the transcription order by providing the local paths to the audio / video files.
+    def media(self, media_paths: list[str], texts: list[str], time_effort: int = 10) -> SelectWordsOrderBuilder:
+        """Set the media assets for the order by providing the local paths to the audio / video files.
 
         Args:
             media_paths (list[str]): A local file path.
-            time_effort (int): Estimated time in seconds to solve one transcription task for the first time. Defaults to 20.
-            
-        Returns:
-            TranscriptionOrderBuilder: The transcription order builder instance.
-        
-        Raises:
-            ValueError: If the media paths are not a list of strings."""
+            texts (list[str]): The text will be split up by spaces and the labeler will be able to select the words.
+            time_effort (int): Estimated time in seconds to solve one task for the first time. Defaults to 10."""
         
         if not isinstance(media_paths, list) or not all(isinstance(path, str) for path in media_paths):
             raise ValueError("Media paths must be a list of strings, the strings being file paths.")
         
-        if not isinstance(transcription_texts, list) or not all(isinstance(text, str) for text in transcription_texts):
-            raise ValueError("Transcription texts must be a list of strings.")
+        if not isinstance(texts, list) or not all(isinstance(text, str) for text in texts):
+            raise ValueError("texts must be a list of strings.")
         
-        if not len(media_paths) == len(transcription_texts):
-            raise ValueError("The number of media paths and transcription texts must be the same.")
+        if not len(media_paths) == len(texts):
+            raise ValueError("The number of media paths and texts must be the same.")
 
         invalid_paths: list[str] = []
         for path in media_paths:
@@ -161,34 +153,34 @@ class TranscriptionMediaBuilder:
         if invalid_paths:
             raise FileNotFoundError(f"Could not find the following files: {invalid_paths}")
         
-        self._transcription_texts = [TranscriptionMetadata(text) for text in transcription_texts]
+        self._texts = [SelectWordsMetadata(text) for text in texts]
 
         self._time_effort = time_effort
         return self._build()
 
-    def _build(self) -> TranscriptionOrderBuilder:
+    def _build(self) -> SelectWordsOrderBuilder:
         if not self._media_assets:
             raise ValueError("Please provide either a text or an media to be shown with the question")
-        return TranscriptionOrderBuilder(self._name, 
+        return SelectWordsOrderBuilder(self._name, 
                                          self._instruction, 
                                          self._media_assets, 
-                                         self._transcription_texts, 
+                                         self._texts, 
                                          openapi_service=self._openapi_service, 
                                          time_effort=self._time_effort)
 
 
-class TranscriptionInstructionBuilder:
+class SelectWordsInstructionBuilder:
     def __init__(self, name: str, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         self._name = name
         self._instruction = None
 
-    def instruction(self, instruction: str) -> TranscriptionMediaBuilder:
-        """Set the instruction for the transcription order."""
+    def instruction(self, instruction: str) -> SelectWordsMediaBuilder:
+        """Set the instruction for the order."""
         self._instruction = instruction
         return self._build()
 
-    def _build(self) -> TranscriptionMediaBuilder:
+    def _build(self) -> SelectWordsMediaBuilder:
         if self._instruction is None:
             raise ValueError("Instruction is required")
-        return TranscriptionMediaBuilder(self._name, self._instruction, self._openapi_service)
+        return SelectWordsMediaBuilder(self._name, self._instruction, self._openapi_service)

rapidata/rapidata_client/workflow/__init__.py

@@ -2,5 +2,5 @@ from .base_workflow import Workflow
 from .classify_workflow import ClassifyWorkflow
 from .compare_workflow import CompareWorkflow
 from .free_text_workflow import FreeTextWorkflow
-from .transcription_workflow import TranscriptionWorkflow
+from .select_words_workflow import SelectWordsWorkflow
 from .evaluation_workflow import EvaluationWorkflow

rapidata/rapidata_client/workflow/{transcription_workflow.py → select_words_workflow.py}

@@ -4,26 +4,26 @@ from rapidata.api_client.models.transcription_rapid_blueprint import Transcripti
 from rapidata.rapidata_client.workflow.base_workflow import Workflow
 
 
-class TranscriptionWorkflow(Workflow):
+class SelectWordsWorkflow(Workflow):
     """
-    A workflow for transcription tasks.
+    A workflow for select words tasks.
 
-    This class represents a transcription workflow where audio or video content
+    This class represents a select words workflow where audio or video content
     is transcribed based on given instructions.
 
     Attributes:
-        _instruction (str): The instruction for the transcription task.
+        _instruction (str): The instruction for the select words task.
 
     Args:
-        instruction (str): The instruction to be provided for the transcription task.
+        instruction (str): The instruction to be provided for the select words task.
     """
 
     def __init__(self, instruction: str):
         """
-        Initialize a TranscriptionWorkflow instance.
+        Initialize a SelectWordsWorkflow instance.
 
         Args:
-            instruction (str): The instruction to be provided for the transcription task.
+            instruction (str): The instruction to be provided for the select words task.
         """
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction

{rapidata-1.8.2.dist-info → rapidata-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapidata
-Version: 1.8.2
+Version: 1.9.0
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG

{rapidata-1.8.2.dist-info → rapidata-1.9.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-rapidata/__init__.py,sha256=PwuTW_WL75klRHmgTPKVqIVQJg32Uq48TBxxYI6qUvI,621
+rapidata/__init__.py,sha256=5rYiKe2CUYawO0_VQlTPHO-9RIIfH1v2hXUno5n4Zic,617
 rapidata/api_client/__init__.py,sha256=SpzT3CTlZB6LfQKX2ITN0di_uFITeU8kRFyNFsjTbQM,23921
 rapidata/api_client/api/__init__.py,sha256=h0wnYolEBVduAU_7YBLFnwHcwXgZg_krSgarsWxz4zs,1061
 rapidata/api_client/api/campaign_api.py,sha256=DxPFqt9F6c9OpXu_Uxhsrib2NVwnbcZFa3Vkrj7cIuA,40474
@@ -321,25 +321,26 @@ rapidata/api_client/models/workflow_split_model_filter_configs_inner.py,sha256=1
 rapidata/api_client/models/workflow_state.py,sha256=5LAK1se76RCoozeVB6oxMPb8p_5bhLZJqn7q5fFQWis,850
 rapidata/api_client/rest.py,sha256=zmCIFQC2l1t-KZcq-TgEm3vco3y_LK6vRm3Q07K-xRI,9423
 rapidata/api_client_README.md,sha256=2Jqt9GXhr2ZA4S1PpYVkgsrdg2Cc29fnMt_I5V26JOQ,36246
-rapidata/rapidata_client/__init__.py,sha256=mmfjHy_GMA7xFU_haNwxjNRaCF505iPXhE4KC2dXObY,841
+rapidata/constants.py,sha256=tv-g6KDuc0v1GtCN5LZFf8VTP1PeV6J1P4OqyhEfUgI,39
+rapidata/rapidata_client/__init__.py,sha256=sPjhwFGNSCDgRJXqF8CvH8XTGQ0kTUbKrJ4y-IUXhQY,837
 rapidata/rapidata_client/assets/__init__.py,sha256=ctyFS6eSBcmTG69Tzq_f2q1TSEjslstCOVFRP5TBl4Y,273
 rapidata/rapidata_client/assets/base_asset.py,sha256=B2YWH1NgaeYUYHDW3OPpHM_bqawHbH4EjnRCE2BYwiM,298
-rapidata/rapidata_client/assets/media_asset.py,sha256=0XkO7DOff6iq2ybgeS2Ktjj9EKP-btKJnqpaPt0AT3g,2788
+rapidata/rapidata_client/assets/media_asset.py,sha256=vmsin8EdyZcHzxU-Je5mFHsJP0rzVgNDqZxDkp6rRqg,3285
 rapidata/rapidata_client/assets/multi_asset.py,sha256=l6BysrDYWY13FTAw93cmnHN7HLUMrpG27qwOT7KNeLQ,1666
 rapidata/rapidata_client/assets/text_asset.py,sha256=Jn9sXAVkniZVjB75L5oP2_xTYMJ79A7HC-ZgowGp_V0,617
 rapidata/rapidata_client/country_codes/__init__.py,sha256=FB9Dcks44J6C6YBSYmTmNZ71tE130x6NO_3aLJ8fKzQ,40
 rapidata/rapidata_client/country_codes/country_codes.py,sha256=ePHqeb7y9DWQZAnddBzPx1puYBcrgUjdR2sbFijuFD8,283
 rapidata/rapidata_client/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/dataset/rapid_builders/__init__.py,sha256=MAYlb0dHc8fdEtIe3N3VjVkgH9DHTE3KEFE0CfOyJ_k,258
-rapidata/rapidata_client/dataset/rapid_builders/base_rapid_builder.py,sha256=wRN2jFcF55DXwxN8-Gt6rWDWuL_VNuXC0MZrUTXGBqg,1161
+rapidata/rapidata_client/dataset/rapid_builders/__init__.py,sha256=I5xYZrA7WwH-TgB3eaMrTbL32Tumfk0fNj-MGBBuE8o,255
+rapidata/rapidata_client/dataset/rapid_builders/base_rapid_builder.py,sha256=idzHEG7HPwpBJ8wIQg1XPua5pUy2yZTnn1Hbksz7igY,1152
 rapidata/rapidata_client/dataset/rapid_builders/classify_rapid_builders.py,sha256=IljXUkLmf38DGt2uGp2ApFTEZCfNN24KMq1Blek9Ma8,5454
 rapidata/rapidata_client/dataset/rapid_builders/compare_rapid_builders.py,sha256=DAGBz2oGzZw_7-FeTeQXFAwbogBvGWicOmZ9fwL63Aw,4517
-rapidata/rapidata_client/dataset/rapid_builders/rapids.py,sha256=WRiHMtAB3-c4RVfuzVa0XHsatfDVDBf1k1-Ba596Y50,1459
-rapidata/rapidata_client/dataset/rapid_builders/transcription_rapid_builders.py,sha256=-zwIaR65lfQIVK_qVufJ7QwKbCJM1vBuYnN7mzXBz0Y,4767
+rapidata/rapidata_client/dataset/rapid_builders/rapids.py,sha256=pZthVTXmB7-FGqIiZpqsglIYPYvKY_6MfC6WbHfcs0k,1520
+rapidata/rapidata_client/dataset/rapid_builders/select_words_rapid_builders.py,sha256=r78LO6cY6XBn3-rxDqffKcBzG_Z6sYajmbVMdZOYofs,4146
 rapidata/rapidata_client/dataset/rapidata_dataset.py,sha256=R7mlummfPdIMcIE6qB1gBWWIuOpUTFtwVlBkOf8Fm60,5224
-rapidata/rapidata_client/dataset/rapidata_validation_set.py,sha256=tevW03U9LnzonCgt4fK7UFUYhGJQjtLOVCd8wyMgfI8,11505
+rapidata/rapidata_client/dataset/rapidata_validation_set.py,sha256=qSvsTSdpv4sM7uTRxA7f5RM4Lg0VvkrUEbBgG39KiEM,11662
 rapidata/rapidata_client/dataset/validation_rapid_parts.py,sha256=uzpOZFqQu8bG6vmjcWWUNJPZsRe28OmnyalRE6ry8tk,2317
-rapidata/rapidata_client/dataset/validation_set_builder.py,sha256=ZI2T7gisXnA28QL8I2tCkBIOR1Z5yRcoR7O5ZhMbMzY,12000
+rapidata/rapidata_client/dataset/validation_set_builder.py,sha256=TQUYsOQISKMSFKpddUTiP66mD4TSXGo95jB7QSAqa3I,11971
 rapidata/rapidata_client/filter/__init__.py,sha256=F3JsMCbAZWH7SNdgaj98ydTqgCCKXKBhLyt9gQ4x6tQ,301
 rapidata/rapidata_client/filter/age_filter.py,sha256=hncr1zNM_HrO0fCta8h0LgTCB8Ufv_vI5_cGhMb-xr8,478
 rapidata/rapidata_client/filter/base_filter.py,sha256=nXraj72cumyQjjYoo4MMpnlE0aWjAIOmGakKf0MNqps,135
@@ -348,16 +349,16 @@ rapidata/rapidata_client/filter/country_filter.py,sha256=e7kEVn6tzpX-HkHs_KUawJI
 rapidata/rapidata_client/filter/gender_filter.py,sha256=AG4JK8eIycp0iM9h21B_cmFBfgE6v9sU-rIFDCHFUeY,472
 rapidata/rapidata_client/filter/language_filter.py,sha256=_ulaZKO6quKvH7PW-eRv0geab8vFvll96aiY4DSM3sw,743
 rapidata/rapidata_client/filter/user_score_filter.py,sha256=YtZH0eFvo4SS96-R2PqT6at_qHFDlaztwOFOdpeZe5w,560
-rapidata/rapidata_client/metadata/__init__.py,sha256=qMmo4wqScUCAJ6YXRWxvJLmbFA5YRbK39p9_exV1d50,246
+rapidata/rapidata_client/metadata/__init__.py,sha256=H8wjSdk_puZmWhvSXwS2cL2wRWswWaLXiS_aJTC4HlI,243
 rapidata/rapidata_client/metadata/base_metadata.py,sha256=BJoZT4lRs94lu7PE3__LcsMINHNDVKRKRART-EKzSaw,217
 rapidata/rapidata_client/metadata/private_text_metadata.py,sha256=VJ_SJwp8OMFZLuUMRWvPeKOySXYJuGr-YgpwuLfTbmo,517
 rapidata/rapidata_client/metadata/prompt_metadata.py,sha256=W3kG4J53SuVCw9rU2bJYrCnvm7tzRNtLtZo6l48R3Ok,575
 rapidata/rapidata_client/metadata/public_text_metadata.py,sha256=LTiBQHs6izxQ6-C84d6Pf7lL4ENTDgg__HZnDKvzvMc,511
-rapidata/rapidata_client/metadata/transcription_metadata.py,sha256=THtDEVCON4UlcXHmXrjilaOLHys4TrktUOPGWnXaCcc,631
+rapidata/rapidata_client/metadata/select_words_metadata.py,sha256=Z7mxJ1i0EDRUlHpnzaUyBSdybu3waR15L-GFVfCjJos,625
 rapidata/rapidata_client/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/order/rapidata_order.py,sha256=3mIh0pnjReFWDU4mOMsmFXRJffaRZR-PZcoO0lcrztY,4824
+rapidata/rapidata_client/order/rapidata_order.py,sha256=91F4PnNvhlSNwIB328_2R6mt9gINweo9U41rVrk_YPo,4834
 rapidata/rapidata_client/order/rapidata_order_builder.py,sha256=Eu97BSjPuiyu0U-b-GTCIterU5h_cXBLd3cmC1vQI5E,16699
-rapidata/rapidata_client/rapidata_client.py,sha256=Sr8RhQfG_K7FZgouBduhF4TJemYa2TKQUcVl-BXLYig,9127
+rapidata/rapidata_client/rapidata_client.py,sha256=5UNgnlwEIptyoRNMgJMJB7h1x23aCkx6pMPyX_raUi4,9114
 rapidata/rapidata_client/referee/__init__.py,sha256=E1VODxTjoQRnxzdgMh3aRlDLouxe1nWuvozEHXD2gq4,150
 rapidata/rapidata_client/referee/base_referee.py,sha256=bMy7cw0a-pGNbFu6u_1_Jplu0A483Ubj4oDQzh8vu8k,493
 rapidata/rapidata_client/referee/early_stopping_referee.py,sha256=V9c2Iau40-aPM06FYW5qwpJGa-usTCiZixoCCQWkrxI,1929
@@ -373,23 +374,23 @@ rapidata/rapidata_client/settings/__init__.py,sha256=DTsffohaZICEmBRpokyWAd6GNcf
 rapidata/rapidata_client/settings/feature_flags.py,sha256=aKnxl1kv4cC3TaHV-xfqYlvL3ATIB2-H0VKl1rUt8jQ,4658
 rapidata/rapidata_client/settings/settings.py,sha256=ncLvEuIYWkUnAi8J3PQoG7WoAOZn-G3WZ0LWyrwt-QM,4556
 rapidata/rapidata_client/simple_builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/simple_builders/simple_classification_builders.py,sha256=jqHQY8cKQuZnVcx2oCPaVyd2p6jQ421Iw9AzbnL7vI8,11634
-rapidata/rapidata_client/simple_builders/simple_compare_builders.py,sha256=JpXoURsrGouBNJMqqmd35bgbmKcgCTVIXEYZNekfS5o,12237
-rapidata/rapidata_client/simple_builders/simple_free_text_builders.py,sha256=udJWDo_8h-lglxxEEl-FpufPtCZ9Fs9AMZX9Q24CmCA,8171
-rapidata/rapidata_client/simple_builders/simple_transcription_builders.py,sha256=J0d53f2zDOpRwXNtgVVAgQ_n6srUzC4BHjXxjTYQGHc,9580
-rapidata/rapidata_client/workflow/__init__.py,sha256=xWuzAhBnbcUFfWcgYrzj8ZYLSOXyFtgfepgMrf0hNhU,290
+rapidata/rapidata_client/simple_builders/simple_classification_builders.py,sha256=DTRSGwYk1keM1ijRhNtkoy3bv0fIJqd7ynhsh6iswuk,12013
+rapidata/rapidata_client/simple_builders/simple_compare_builders.py,sha256=IYtJMZConHjZElyHFg6AnvhZ6DL5O3DTLTxtnuCwGqQ,12257
+rapidata/rapidata_client/simple_builders/simple_free_text_builders.py,sha256=-FE3q0Ci98kbKpX5T3zxHjo4_QIRWiQI6iJBvbXW0wo,8180
+rapidata/rapidata_client/simple_builders/simple_select_words_builders.py,sha256=Jx8jMomS-7v_-yGVSQOnsEYBFEIq7aGTvf50aKBlR80,9088
+rapidata/rapidata_client/workflow/__init__.py,sha256=IAZInqi6bJcyl1k5-whfuMZcKnC-UR_whv7R5gQwhS0,287
 rapidata/rapidata_client/workflow/base_workflow.py,sha256=iDBeklFwOIbMuJHA7t-x_cwxfygJCG0SoXLBB7R53fQ,1395
 rapidata/rapidata_client/workflow/classify_workflow.py,sha256=NkyyBrlCDqYVQaCARR9EHYuREEtXond69kD6jbzcN3M,1713
 rapidata/rapidata_client/workflow/compare_workflow.py,sha256=nqrgtohlXBfgHh_cRPOFAlwdI8wVc7PUsH0FDM7wIjg,1431
 rapidata/rapidata_client/workflow/evaluation_workflow.py,sha256=IBQoVFxOaeCDIBfaaboytWk8hNX9QH_xikkXt3lu9GY,619
 rapidata/rapidata_client/workflow/free_text_workflow.py,sha256=VaypoG3yKgsbtVyqxta3W28eDwdnGebCy2xDWPCBMyo,1566
-rapidata/rapidata_client/workflow/transcription_workflow.py,sha256=_KDtGCdRhauJm3jQHpwhY-Hq79CLg5I8q2RgOz5lo1g,1404
+rapidata/rapidata_client/workflow/select_words_workflow.py,sha256=9PNsXM1LZ9LOV0RLPTgBBlceOfEn2olkOpEUeQR4hTY,1395
 rapidata/service/__init__.py,sha256=s9bS1AJZaWIhLtJX_ZA40_CK39rAAkwdAmymTMbeWl4,68
 rapidata/service/credential_manager.py,sha256=4jiJaX4hnRKoU91-WnpLytOTvSWApSa8ezN8fGAp0dg,7944
 rapidata/service/local_file_service.py,sha256=pgorvlWcx52Uh3cEG6VrdMK_t__7dacQ_5AnfY14BW8,877
 rapidata/service/openapi_service.py,sha256=Q1_anQhDFOfgucLJkNyTnqdX9qdJQUQlYIktbe-dOZM,2581
 rapidata/service/token_manager.py,sha256=JZ5YbR5Di8dO3H4kK11d0kzWlrXxjgCmeNkHA4AapCM,6425
-rapidata-1.8.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-rapidata-1.8.2.dist-info/METADATA,sha256=Dt4Yf9uPyf4CInvI6f_DQZM0_k7kkHjQH2eaHvNZ9B8,1033
-rapidata-1.8.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-rapidata-1.8.2.dist-info/RECORD,,
+rapidata-1.9.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-1.9.0.dist-info/METADATA,sha256=9VQ5AMstoDVAfzwhlTdXwIfoZAYuqUDanglxyIZcM3c,1033
+rapidata-1.9.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+rapidata-1.9.0.dist-info/RECORD,,