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

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

rapidata/rapidata_client/simple_builders/simple_free_text_builders.py

@@ -0,0 +1,180 @@
+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.referee.naive_referee import NaiveReferee
+from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.workflow import FreeTextWorkflow
+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, TextAsset, BaseAsset
+from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
+from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
+
+class FreeTextOrderBuilder:
+    def __init__(self, 
+                 name: str, 
+                 question: 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._media_assets = media_assets
+        self._referee = NaiveReferee()
+        self._settings = Settings()
+        self._filters: list[Filter] = []
+        self._time_effort = time_effort
+
+    def responses(self, responses_required: int) -> 'FreeTextOrderBuilder':
+        """Set the number of responses required per datapoint for the free text order. Will default to 10."""
+        self._referee = NaiveReferee(responses=responses_required)
+        return self
+    
+    def minimum_characters(self, minimum_characters: int) -> 'FreeTextOrderBuilder':
+        """Set the minimum number of characters for the free text."""
+        self._settings.free_text_minimum_characters(minimum_characters)
+        return self
+    
+    def countries(self, country_codes: list[str]) -> 'FreeTextOrderBuilder':
+        """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]) -> 'FreeTextOrderBuilder':
+        """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) -> 'FreeTextOrderBuilder':
+        """Disable the translation of the order.
+        Only the question 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
+
+    def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
+        """Run the free text 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 free text order."""
+        
+        if 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.")
+
+        selection: list[Selection] = [LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort)]
+
+        order = (self._order_builder
+            .workflow(
+                FreeTextWorkflow(
+                    question=self._question
+                )
+            )
+            .referee(self._referee)
+            .media(self._media_assets)
+            .selections(selection)
+            .settings(self._settings)
+            .filters(self._filters)
+            .create(submit=submit, disable_link=disable_link))
+
+        return order 
+
+
+class FreeTextMediaBuilder:
+    def __init__(self, name: str, question: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._question = question
+        self._media_assets: list[BaseAsset] = []
+        self._time_effort = 20
+
+    def media(self, media_paths: list[str], time_effort: int = 20) -> FreeTextOrderBuilder:
+        """Set the media assets for the free text 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 free text task for the first time. Defaults to 20.
+            
+        Returns:
+            FreeTextOrderBuilder: The free text 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 or image links.")
+        
+        invalid_paths: list[str] = []
+        for path in media_paths:
+            try:
+                self._media_assets.append(MediaAsset(path))
+            except FileNotFoundError:
+                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 = 20) -> FreeTextOrderBuilder:
+        """Set the text assets for the free text order by.
+
+        Args:
+            texts (list[str]): The texts to be shown.
+            time_effort (int): Estimated time in seconds to solve one free text task for the first time. Defaults to 20.
+            
+        Returns:
+            FreeTextOrderBuilder: The free text order builder instance."""
+        for text in texts:
+            self._media_assets.append(TextAsset(text))
+        self._time_effort = time_effort
+        return self._build()
+
+    def _build(self) -> FreeTextOrderBuilder:
+        if not self._media_assets:
+            raise ValueError("Please provide either a text or an media to be shown with the question")
+        return FreeTextOrderBuilder(self._name, self._question, self._media_assets, openapi_service=self._openapi_service, time_effort=self._time_effort)
+
+
+class FreeTextQuestionBuilder:
+    def __init__(self, name: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._question = None
+
+    def question(self, question: str) -> FreeTextMediaBuilder:
+        """Set the question for the free text order."""
+        self._question = question
+        return self._build()
+
+    def _build(self) -> FreeTextMediaBuilder:
+        if self._question is None:
+            raise ValueError("Question is required")
+        return FreeTextMediaBuilder(self._name, self._question, self._openapi_service)