rapidata 1.7.1__py3-none-any.whl → 1.8.1__py3-none-any.whl

rapidata/rapidata_client/rapidata_client.py

@@ -1,6 +1,4 @@
-from rapidata.rapidata_client.dataset.rapidata_validation_set import (
-    RapidataValidationSet,
-)
+from rapidata.rapidata_client.dataset.rapidata_validation_set import RapidataValidationSet
 from rapidata.rapidata_client.dataset.validation_set_builder import ValidationSetBuilder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.service.openapi_service import OpenAPIService
@@ -9,11 +7,15 @@ 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.dataset.rapid_builders import BaseRapidBuilder
 
 from rapidata.api_client.exceptions import BadRequestException
 from urllib3._collections import HTTPHeaderDict
 
-from rapidata.api_client.models.query_orders_model import QueryOrdersModel
+from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.root_filter import RootFilter
 from rapidata.api_client.models.filter import Filter
@@ -21,16 +23,19 @@ from rapidata.api_client.models.sort_criterion import SortCriterion
 
 from rapidata.api_client.models.query_validation_set_model import QueryValidationSetModel
 
+from deprecated import deprecated
+
 
 class RapidataClient:
-    """The Rapidata client is the main entry point for interacting with the Rapidata API. It allows you to create orders and validation sets. For creating a new order, check out `new_order()`. For creating a new validation set, check out `new_validation_set()`."""
+    """The Rapidata client is the main entry point for interacting with the Rapidata API. It allows you to create orders and validation sets."""
 
+    rapid_builder = BaseRapidBuilder()
+    
     def __init__(
         self,
         client_id: str | None = None,
         client_secret: str | None = None,
-        endpoint: str = "https://api.rapidata.ai",
-        token_url: str = "https://auth.rapidata.ai",
+        enviroment: str = "rapidata.ai",
         oauth_scope: str = "openid",
         cert_path: str | None = None,
     ):
@@ -44,12 +49,12 @@ class RapidataClient:
         self.openapi_service = OpenAPIService(
             client_id=client_id,
             client_secret=client_secret,
-            endpoint=endpoint,
-            token_url=token_url,
+            enviroment=enviroment,
             oauth_scope=oauth_scope,
             cert_path=cert_path
         )
-
+    
+    @deprecated("Use the specific builder methods instead.")
     def new_order(self, name: str) -> RapidataOrderBuilder:
         """Create a new order using a RapidataOrderBuilder instance.
 
@@ -108,7 +113,7 @@ class RapidataClient:
             list[RapidataOrder]: A list of RapidataOrder instances.
         """
         try:
-            order_page_result = self.openapi_service.order_api.order_query_get(QueryOrdersModel(
+            order_page_result = self.openapi_service.order_api.order_query_get(QueryModel(
                 page=PageInfo(index=1, size=amount),
                 filter=RootFilter(filters=[Filter(field="OrderName", operator="Contains", value=name)]),
                 sortCriteria=[SortCriterion(direction="Desc", propertyName="OrderDate")]
@@ -177,3 +182,26 @@ class RapidataClient:
             CompareQuestionBuilder: A CompareQuestionBuilder instance.
         """
         return CompareCriteriaBuilder(name=name, openapi_service=self.openapi_service)
+    
+    def create_free_text_order(self, name: str) -> FreeTextQuestionBuilder:
+        """Create a new free text order where people are asked to provide a free text answer.
+
+        Args:
+            name (str): The name of the order.
+
+        Returns:
+            FreeTextQuestionBuilder: A FreeTextQuestionBuilder instance.
+        """
+        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.
+
+        Args:
+            name (str): The name of the order.
+
+        Returns:
+            TranscriptionInstructionBuilder: A TranscriptionInstructionBuilder instance.
+        """
+        return TranscriptionInstructionBuilder(name=name, openapi_service=self.openapi_service)
+

rapidata/rapidata_client/settings/__init__.py

@@ -1,2 +1,2 @@
 from .feature_flags import FeatureFlags
-from .settings import Settings
+from .settings import Settings, TranslationBehaviour

rapidata/rapidata_client/settings/settings.py

@@ -96,17 +96,18 @@ class Settings:
         """
         self._settings["no_shuffle"] = str(value)
         return self
-
-    def compare_with_prompt_design(self, value: bool = True):
-        """A special design to compare two texts/images based on a criteria and a given prompt.
-
+    
+    def play_video_until_the_end(self, additional_time=0):
+        """Allows users to only answer once the video has finished playing.
+        The additional time gets added on top. Can be negative to allow answers before the video ends.
+        
         Args:
-            value (bool, optional): Whether to enable compare with prompt design. Defaults to True.
-
+            additional_time (int, optional): Additional time in milliseconds. Defaults to 0.
+            
         Returns:
-            Settings: The current Settings instance for method chaining.
-        """
-        self._settings["claire"] = str(value)
+            Settings: The current Settings instance for method chaining."""
+            
+        self._settings["alert_on_fast_response_add_media_duration"] = str(additional_time)
         return self
 
     def key_value(self, key: str, value: str):

rapidata/rapidata_client/simple_builders/simple_classification_builders.py

@@ -1,5 +1,7 @@
+from 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.base_metadata import Metadata
+from rapidata.rapidata_client.metadata import Metadata, PromptMetadata
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.referee.early_stopping_referee import EarlyStoppingReferee
 from rapidata.rapidata_client.selection.base_selection import Selection
@@ -7,11 +9,20 @@ from rapidata.rapidata_client.workflow.classify_workflow import ClassifyWorkflow
 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
+from rapidata.rapidata_client.assets import MediaAsset, TextAsset, BaseAsset
+from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
+from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
+from deprecated import deprecated
 from typing import Sequence
 
 class ClassificationOrderBuilder:
-    def __init__(self, name: str, question: str, options: list[str], media_assets: list[MediaAsset], openapi_service: OpenAPIService):
+    def __init__(self, 
+                 name: str, 
+                 question: str, 
+                 options: list[str], 
+                 media_assets: list[BaseAsset], 
+                 openapi_service: OpenAPIService, 
+                 time_effort: int):
         self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
         self._question = question
         self._options = options
@@ -20,28 +31,95 @@ class ClassificationOrderBuilder:
         self._probability_threshold = None
         self._metadata = None
         self._validation_set_id = None
+        self._filters: list[Filter] = []
+        self._settings = Settings()
+        self._time_effort = time_effort
+
+    def prompts(self, prompts: list[str]) -> 'ClassificationOrderBuilder':
+        """Set the prompts for the classification order. Has to be the same lenght as the media paths."""
+        if len(prompts) != len(self._media_assets):
+            raise ValueError("The number of prompts must be the same as the number of media paths")
+        
+        if self._metadata is not None:
+            print("Warning: Metadata will be overwritten by prompts")
+
+        self._metadata = [PromptMetadata(prompt) for prompt in prompts]
+        return self
 
-    def metadata(self, metadata: Sequence[Metadata]):
+    @deprecated("Use prompts instead")
+    def metadata(self, metadata: Sequence[Metadata]) -> 'ClassificationOrderBuilder':
         """Set the metadata for the classification order. Has to be the same lenght as the media paths."""
         self._metadata = metadata
         return self
 
-    def responses(self, responses_required: int):
-        """Set the number of responses required for the classification order."""
+    def responses(self, responses_required: int) -> 'ClassificationOrderBuilder':
+        """Set the number of responses required per datapoint for the classification order. Will default to 10."""
         self._responses_required = responses_required
         return self
 
-    def probability_threshold(self, probability_threshold: float):
+    def probability_threshold(self, probability_threshold: float) -> 'ClassificationOrderBuilder':
         """Set the probability threshold for early stopping."""
         self._probability_threshold = probability_threshold
         return self
 
-    def validation_set_id(self, validation_set_id: str):
-        """Set the validation set ID for the classification order."""
+    def validation_set(self, validation_set_id: str) -> 'ClassificationOrderBuilder':
+        """Set the validation set for the classification order."""
         self._validation_set_id = validation_set_id
         return self
+    
+    def countries(self, country_codes: list[str]) -> 'ClassificationOrderBuilder':
+        """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]) -> 'ClassificationOrderBuilder':
+        """Set the languages where order will be shown as language codes."""
+        self._filters.append(LanguageFilter(language_codes))
+        return self
+    
+    def translation(self, disable: bool = False, show_both: bool = False) -> 'ClassificationOrderBuilder':
+        """Disable the translation of the order.
+        Only the question and the options will be translated.
+        
+        Args:
+            disable (bool): Whether to disable the translation. Defaults to False.
+            show_both (bool): Whether to show the original text alongside the translation. Defaults to False.
+                ATTENTION: this can lead to cluttering of the UI if the texts are long, leading to bad results."""
 
-    def create(self, submit: bool = True, max_upload_workers: int = 10):
+        if not isinstance(disable, bool) or not isinstance(show_both, bool):
+            raise ValueError("disable and show_both must be booleans.")
+        
+        if disable and show_both:
+            raise ValueError("You can't disable the translation and show both at the same time.")
+        
+        if show_both:
+            self._settings.translation_behaviour(TranslationBehaviour.BOTH)
+            return self
+        
+        if disable:
+            self._settings.translation_behaviour(TranslationBehaviour.ONLY_ORIGINAL)
+
+        else:
+            self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
+
+        return self
+
+    @deprecated("Use .run instead.")
+    def create(self, submit: bool = True, max_upload_workers: int = 10) -> 'RapidataOrder':
+        """Create the classification order."""
+        return self.run(submit=submit, disable_link=False)
+
+    def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
+        """Run the classification 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 classification order."""
+                
         if self._probability_threshold and self._responses_required:
             referee = EarlyStoppingReferee(
                 max_vote_count=self._responses_required,
@@ -50,10 +128,16 @@ class ClassificationOrderBuilder:
 
         else:
             referee = NaiveReferee(responses=self._responses_required)
+        
+        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. \
+                             Your taks is too complex. Try to break it down into simpler tasks.\
+                             {'Alternatively remove the validation task' if self._validation_set_id else ''}")
 
-        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), LabelingSelection(amount=2)] 
+        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), 
+                                       LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1)] 
                      if self._validation_set_id 
-                     else [LabelingSelection(amount=3)])
+                     else [LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort)])
 
         order = (self._order_builder
             .workflow(
@@ -65,7 +149,7 @@ class ClassificationOrderBuilder:
             .referee(referee)
             .media(self._media_assets, metadata=self._metadata)
             .selections(selection)
-            .create(submit=submit, max_workers=max_upload_workers))
+            .create(submit=submit, disable_link=disable_link))
 
         return order 
 
@@ -76,14 +160,26 @@ class ClassificationMediaBuilder:
         self._name = name
         self._question = question
         self._options = options
-        self._media_assets = []
-
-    def media(self, media_paths: list[str]) -> ClassificationOrderBuilder:
-        """Set the media assets for the classification order by providing the local paths to the files."""
+        self._media_assets: list[BaseAsset] = []
+        self._time_effort = 8
+
+    def media(self, media_paths: list[str], time_effort: int = 8) -> ClassificationOrderBuilder:
+        """Set the media assets for the classification order by providing the local paths to the files or a link.
+
+        Args:
+            media_paths (list[str]): Either a local file path or a link.
+            time_effort (int): Estimated time in seconds to solve one classification task for the first time. Defaults to 8.
+            
+        Returns:
+            ClassificationOrderBuilder: The classification order builder instance.
+        
+        Raises:
+            ValueError: If the media paths are not a list of strings."""
+        
         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")
+            raise ValueError("Media paths must be a list of strings, the strings being file paths or image links.")
         
-        invalid_paths = []
+        invalid_paths: list[str] = []
         for path in media_paths:
             try:
                 self._media_assets.append(MediaAsset(path))
@@ -91,12 +187,27 @@ class ClassificationMediaBuilder:
                 invalid_paths.append(path)
         if invalid_paths:
             raise FileNotFoundError(f"Could not find the following files: {invalid_paths}")
+        self._time_effort = time_effort
+        return self._build()
+    
+    def text(self, texts: list[str], time_effort: int = 10) -> ClassificationOrderBuilder:
+        """Set the text assets for the classification order by providing the text to be classified.
+
+        Args:
+            texts (list[str]): The texts to be classified.
+            time_effort (int): Estimated time in seconds to solve one classification task for the first time. Defaults to 10.
+            
+        Returns:
+            ClassificationOrderBuilder: The classification order builder instance."""
+        for text in texts:
+            self._media_assets.append(TextAsset(text))
+        self._time_effort = time_effort
         return self._build()
 
     def _build(self) -> ClassificationOrderBuilder:
         if not self._media_assets:
-            raise ValueError("Media paths are required")
-        return ClassificationOrderBuilder(self._name, self._question, self._options, self._media_assets, openapi_service=self._openapi_service)
+            raise ValueError("Please provide either a text or an media to classify")
+        return ClassificationOrderBuilder(self._name, self._question, self._options, self._media_assets, openapi_service=self._openapi_service, time_effort=self._time_effort)
 
 
 class ClassificationOptionsBuilder:

rapidata/rapidata_client/simple_builders/simple_compare_builders.py

@@ -1,17 +1,21 @@
+from constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.metadata import Metadata
+from rapidata.rapidata_client.metadata import Metadata, PromptMetadata
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.workflow.compare_workflow import CompareWorkflow
 from rapidata.rapidata_client.referee import NaiveReferee, EarlyStoppingReferee
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.rapidata_client.selection.base_selection import Selection
-from rapidata.rapidata_client.assets import MultiAsset, MediaAsset
+from rapidata.rapidata_client.assets import MultiAsset, MediaAsset, TextAsset
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+from rapidata.rapidata_client.filter import CountryFilter, Filter, LanguageFilter
+from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
+from deprecated import deprecated
 from typing import Sequence
 
 class CompareOrderBuilder:
-    def __init__(self, name:str, criteria: str, media_assets: list[MultiAsset], openapi_service: OpenAPIService):
+    def __init__(self, name:str, criteria: str, media_assets: list[MultiAsset], openapi_service: OpenAPIService, time_effort: int):
         self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
         self._name = name
         self._criteria = criteria
@@ -20,19 +24,40 @@ class CompareOrderBuilder:
         self._metadata = None
         self._validation_set_id = None
         self._probability_threshold = None
+        self._filters: list[Filter] = []
+        self._settings = Settings()
+        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."""
+        """Set the number of resoonses required per matchup/pairing for the comparison order. Will default to 10."""
         self._responses_required = responses_required
         return self
     
+    def prompts(self, prompts: list[str]) -> 'CompareOrderBuilder':
+        """Set the prompts for the comparison order. Has to be the same shape as the media paths."""
+        if len(prompts) != len(self._media_assets):
+            raise ValueError("The number of prompts must match the number of media paths.")
+        
+        if self._metadata is not None:
+            print("Warning: Metadata will be overwritten by prompts.")
+
+        self._metadata = [PromptMetadata(prompt=prompt) for prompt in prompts]
+        return self
+    
+    deprecated("Use prompts instead.")
     def metadata(self, metadata: Sequence[Metadata]) -> 'CompareOrderBuilder':
         """Set the metadata for the comparison order. Has to be the same shape as the media paths."""
+        if len(metadata) != len(self._media_assets):
+            raise ValueError("The number of metadata must match the number of media paths or image links.")
+        
+        if self._metadata is not None:
+            print("Warning: Metadata will be overwritten by prompts.")
+
         self._metadata = metadata
         return self
     
-    def validation_set_id(self, validation_set_id: str) -> 'CompareOrderBuilder':
-        """Set the validation set ID for the comparison order."""
+    def validation_set(self, validation_set_id: str) -> 'CompareOrderBuilder':
+        """Set the validation set for the comparison order."""
         self._validation_set_id = validation_set_id
         return self
     
@@ -41,7 +66,59 @@ class CompareOrderBuilder:
         self._probability_threshold = probability_threshold
         return self
     
-    def create(self, submit: bool = True, max_upload_workers: int = 10) -> RapidataOrder:
+    def countries(self, country_codes: list[str]) -> 'CompareOrderBuilder':
+        """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]) -> 'CompareOrderBuilder':
+        """Set the languages where order will be shown as language codes."""
+        self._filters.append(LanguageFilter(language_codes))
+        return self
+    
+    def translation(self, disable: bool = False, show_both: bool = False) -> 'CompareOrderBuilder':
+        """Disable the translation of the order.
+        Only the criteria will be translated.
+        
+        Args:
+            disable (bool): Whether to disable the translation. Defaults to False.
+            show_both (bool): Whether to show the original text alongside the translation. Defaults to False.
+                ATTENTION: this can lead to cluttering of the UI if the texts are long, leading to bad results."""
+
+        if not isinstance(disable, bool) or not isinstance(show_both, bool):
+            raise ValueError("disable and show_both must be booleans.")
+        
+        if disable and show_both:
+            raise ValueError("You can't disable the translation and show both at the same time.")
+        
+        if show_both:
+            self._settings.translation_behaviour(TranslationBehaviour.BOTH)
+            return self
+        
+        if disable:
+            self._settings.translation_behaviour(TranslationBehaviour.ONLY_ORIGINAL)
+
+        else:
+            self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
+
+        return self
+    
+    @deprecated("Use .run instead.")
+    def create(self, submit: bool = True, max_upload_workers: int = 10) -> 'RapidataOrder':
+        """Create the classification order."""
+        return self.run(submit=submit, disable_link=False)
+    
+    def run(self, submit: bool = True, disable_link: bool = False) -> RapidataOrder:
+        """Run the compare 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 compare order."""
+        
         if self._probability_threshold and self._responses_required:
             referee = EarlyStoppingReferee(
                 max_vote_count=self._responses_required,
@@ -50,9 +127,16 @@ class CompareOrderBuilder:
 
         else:
             referee = NaiveReferee(responses=self._responses_required)
-        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), LabelingSelection(amount=2)] 
+        
+        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. \
+                             Your taks is too complex. Try to break it down into simpler tasks.\
+                             {'Alternatively remove the validation task' if self._validation_set_id else ''}")
+
+        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), 
+                                       LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1)] 
                      if self._validation_set_id 
-                     else [LabelingSelection(amount=3)])
+                     else [LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort)])
         
         order = (self._order_builder
             .workflow(
@@ -63,7 +147,8 @@ class CompareOrderBuilder:
             .referee(referee)
             .media(self._media_assets, metadata=self._metadata)
             .selections(selection)
-            .create(submit=submit, max_workers=max_upload_workers))
+            .filters(self._filters)
+            .create(submit=submit, disable_link=disable_link))
         
         return order
 
@@ -73,13 +158,26 @@ class CompareMediaBuilder:
         self._name = name
         self._criteria = criteria
         self._media_assets = []
+        self._time_effort = 8
 
-    def media(self, media_paths: list[list[str]]) -> CompareOrderBuilder:
-        """Set the media assets for the comparison order by providing the local paths to the files."""
+    def media(self, media_paths: list[list[str]], time_effort = 8) -> CompareOrderBuilder:
+        """Set the media assets for the comparison order by providing the local paths to the files or a link.
+        
+        Args:
+            media_paths (list[list[str]]): A list of lists of file paths. Each inner list is a pair of file paths that will be shown together in a matchup.
+            time_effort (int): Estimated time in seconds to solve one comparison task for the first time. Defaults to 8.
+            
+        Returns:
+            CompareOrderBuilder: The compare order builder instance.
+            
+        Raises:
+            ValueError: If the media paths are not a list of lists of strings."""
+        
         if not isinstance(media_paths, list) \
                 or not all([isinstance(matchup_paths, list) for matchup_paths in media_paths]) \
                 or not all([isinstance(path, str) for matchup_paths in media_paths for path in matchup_paths]):
-            raise ValueError("Media paths must be a list of lists. The inner list is a pair of file paths that will be shown together in a matchup.")
+            raise ValueError("Media paths must be a list of lists. \
+                             \nThe inner list is a pair of file paths that will be shown together in a matchup.")
         
         invalid_paths = []
         for matchup_idx, matchup_paths in enumerate(media_paths):
@@ -98,13 +196,41 @@ class CompareMediaBuilder:
             for matchup_idx, path in invalid_paths:
                 error_msg += f"  Matchup {matchup_idx + 1}: {path}\n"
             raise FileNotFoundError(error_msg.rstrip())
+        
+        self._time_effort = time_effort
+        return self._build()
+    
+    def text(self, text_matchups: list[list[str]], time_effort = 10) -> CompareOrderBuilder:
+        """Set the text assets for the comparison order by providing the texts.
+        
+        Args:
+            text_matchups (list[list[str]]): A list of lists of texts. Each inner list is a pair of texts that will be shown together in a matchup.
+            time_effort (int): Estimated time in seconds to solve one comparison task for the first time. Defaults to 10.
+            
+        Returns:
+            CompareOrderBuilder: The compare order builder instance.
+                
+        Raises:
+            ValueError: If the media paths are not a list of lists of strings."""
+        if not isinstance(text_matchups, list) \
+                or not all([isinstance(matchup_paths, list) for matchup_paths in text_matchups]) \
+                or not all([isinstance(path, str) for matchup_paths in text_matchups for path in matchup_paths]):
+            raise ValueError("Media paths must be a list of lists. \
+                             \nThe inner list is a pair of file paths that will be shown together in a matchup.")
+        
+        for matchup_texts in text_matchups:
+            matchup_assets = []
+            for text in matchup_texts:
+                matchup_assets.append(TextAsset(text=text))
+            self._media_assets.append(MultiAsset(matchup_assets))
+
+        self._time_effort = time_effort
         return self._build()
     
     def _build(self) -> CompareOrderBuilder:
         if not self._media_assets:
             raise ValueError("Media paths are required")
-        assert all([len(path) == 2 for path in self._media_assets]), "The media paths must come in pairs for comparison tasks."
-        return CompareOrderBuilder(self._name, self._criteria, self._media_assets, self._openapi_service)
+        return CompareOrderBuilder(self._name, self._criteria, self._media_assets, self._openapi_service, time_effort=self._time_effort)
 
 class CompareCriteriaBuilder:
     def __init__(self, name: str, openapi_service: OpenAPIService):