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

rapidata/rapidata_client/rapidata_client.py

@@ -1,31 +1,8 @@
-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
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.rapidata_client.dataset.rapidata_dataset import RapidataDataset
 
-from rapidata.rapidata_client.order.order_builder import BaseOrderBuilder
+from rapidata.rapidata_client.order.rapidata_order_manager import RapidataOrderManager
 
-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_select_words_builders import SelectWordsInstructionBuilder
-
-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_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
-from rapidata.api_client.models.sort_criterion import SortCriterion
-
-from rapidata.api_client.models.query_validation_set_model import QueryValidationSetModel
-
-from deprecated import deprecated
+from rapidata.rapidata_client.validation.validation_set_manager import ValidationSetManager
 
 
 class RapidataClient:
@@ -39,14 +16,19 @@ class RapidataClient:
         oauth_scope: str = "openid",
         cert_path: str | None = None,
     ):
-        """Initialize the RapidataClient. Best practice is to store the client ID and client secret in environment variables. Ask your Rapidata representative for the client ID and client secret.
+        """Initialize the RapidataClient. If both the client_id and client_secret are None, it will try using your credentials under "~/.config/rapidata/credentials.json". 
+        If this is not successful, it will open a browser windown and ask you to log in, then save your new credentials in said json file.
 
         Args:
             client_id (str): The client ID for authentication.
             client_secret (str): The client secret for authentication.
-            endpoint (str, optional): The API endpoint URL.
+            enviroment (str, optional): The API endpoint.
+
+        Attributes:
+            order (RapidataOrderManager): The RapidataOrderManager instance.
+            validation (ValidationSetManager): The ValidationSetManager instance.
         """
-        self.openapi_service = OpenAPIService(
+        self._openapi_service = OpenAPIService(
             client_id=client_id,
             client_secret=client_secret,
             enviroment=enviroment,
@@ -54,177 +36,6 @@ class RapidataClient:
             cert_path=cert_path
         )
         
-        self.rapid_builder = BaseRapidBuilder()
-
-        self.order_builder = BaseOrderBuilder(openapi_service=self.openapi_service)
-    
-    @deprecated("Use the order_builder instead.")
-    def new_order(self, name: str) -> RapidataOrderBuilder:
-        """Create a new order using a RapidataOrderBuilder instance.
-
-        Args:
-            name (str): The name of the order.
-
-        Returns:
-            RapidataOrderBuilder: A RapidataOrderBuilder instance.
-        """
-        return self.new_advanced_order(name)
-    
-    @deprecated("Use the order_builder instead.")
-    def new_advanced_order(self, name: str) -> RapidataOrderBuilder:
-        """Create a new order using a RapidataOrderBuilder instance.
-        This method is intended for creating orders with complex requirements that can not be fulfilled with the specific builders.
-        For any other order, it is recommended to use the specific builder methods.
-        example: create_classify_order, create_compare_order, create_free_text_order, create_select_words_order
-
-        Args:
-            name (str): The name of the order.
-
-        Returns:
-            RapidataOrderBuilder: A RapidataOrderBuilder instance.
-        """
-        return RapidataOrderBuilder(name=name, openapi_service=self.openapi_service)
-
-    def new_validation_set(self, name: str) -> ValidationSetBuilder:
-        """Create a new validation set using a ValidationDatasetBuilder instance.
-
-        Args:
-            name (str): The name of the validation set.
-
-        Returns:
-            ValidationSetBuilder: A ValidationDatasetBuilder instance.
-        """
-        return ValidationSetBuilder(name=name, openapi_service=self.openapi_service)
-
-    def get_order(self, order_id: str) -> RapidataOrder:
-        """Get an order by ID.
-
-        Args:
-            order_id (str): The ID of the order.
-
-        Returns:
-            RapidataOrder: The Order instance.
-        """
-
-        # TODO: check the pipeline for the dataset id - not really necessary atm
-        # order = self.openapi_service.order_api.order_get_by_id_get(order_id)
-        # pipeline = self.openapi_service..pipeline_get_by_id_get(order.pipeline_id)
-        try:
-            order = self.openapi_service.order_api.order_get_by_id_get(order_id)
-        except Exception:
-            raise ValueError(f"Order with ID {order_id} not found.")
-
-        temp_dataset = RapidataDataset("temp", self.openapi_service)
-        return RapidataOrder(
-            dataset=temp_dataset, 
-            order_id=order_id, 
-            name=order.order_name,
-            openapi_service=self.openapi_service)
-
-    def find_orders(self, name: str = "", amount: int = 1) -> list[RapidataOrder]:
-        """Find your recent orders given criteria. If nothing is provided, it will return the most recent order.
-
-        Args:
-            name (str, optional): The name of the order - matching order will contain the name. Defaults to "" for any order.
-            amount (int, optional): The amount of orders to return. Defaults to 1.
-
-        Returns:
-            list[RapidataOrder]: A list of RapidataOrder instances.
-        """
-        try:
-            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")]
-                ))
-
-        except BadRequestException as e:
-            raise ValueError(f"Error occured during request. \nError: {e.body} \nTraceid: {e.headers.get('X-Trace-Id') if isinstance(e.headers, HTTPHeaderDict) else 'Unknown'}")
-
-        except Exception as e:
-            raise ValueError(f"Unknown error occured: {e}")
-
-        orders = [self.get_order(order.id) for order in order_page_result.items]
-        return orders
-    
-    def get_validation_set(self, validation_set_id: str) -> RapidataValidationSet:
-        """Get a validation set by ID.
-
-        Args:
-            validation_set_id (str): The ID of the validation set.
-
-        Returns:
-            RapidataValidationSet: The ValidationSet instance.
-        """
-        try:
-            validation_set = self.openapi_service.validation_api.validation_get_by_id_get(id=validation_set_id)
-        except Exception:
-            raise ValueError(f"ValidationSet with ID {validation_set_id} not found.")
+        self.order = RapidataOrderManager(openapi_service=self._openapi_service)
         
-        return RapidataValidationSet(validation_set_id, self.openapi_service, validation_set.name)
-    
-    def find_validation_sets(self, name: str = "", amount: int = 1) -> list[RapidataValidationSet]:
-        try:
-            validation_page_result = self.openapi_service.validation_api.validation_query_validation_sets_get(QueryValidationSetModel(
-                pageInfo=PageInfo(index=1, size=amount),
-                filter=RootFilter(filters=[Filter(field="Name", operator="Contains", value=name)]),
-                sortCriteria=[SortCriterion(direction="Desc", propertyName="CreatedAt")]
-                ))
-
-        except BadRequestException as e:
-            raise ValueError(f"Error occured during request. \nError: {e.body} \nTraceid: {e.headers.get('X-Trace-Id') if isinstance(e.headers, HTTPHeaderDict) else 'Unknown'}")
-
-        except Exception as e:
-            raise ValueError(f"Unknown error occured: {e}")
-
-        orders = [self.get_validation_set(validation_set.id) for validation_set in validation_page_result.items] # type: ignore # will be fixed with the next backend deployment
-        return orders
-
-    @deprecated("Use the order_builder instead.")
-    def create_classify_order(self, name: str) -> ClassificationQuestionBuilder:
-        """Create a new classification order where people are asked to classify an image.
-
-        Args:
-            name (str): The name of the order.
-
-        Returns:
-            ClassificationQuestionBuilder: A ClassificationQuestionBuilder instance.
-        """
-        return ClassificationQuestionBuilder(name=name, openapi_service=self.openapi_service)
-
-    @deprecated("Use the order_builder instead.")
-    def create_compare_order(self, name: str) -> CompareCriteriaBuilder:
-        """Create a new comparison order where people are asked to compare two images.
-
-        Args:
-            name (str): The name of the order.
-
-        Returns:
-            CompareQuestionBuilder: A CompareQuestionBuilder instance.
-        """
-        return CompareCriteriaBuilder(name=name, openapi_service=self.openapi_service)
-    
-    @deprecated("Use the order_builder instead.")
-    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)
-    
-    @deprecated("Use the order_builder instead.")
-    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:
-            SelectWordsInstructionBuilder: A SelectWordsInstructionBuilder instance.
-        """
-        return SelectWordsInstructionBuilder(name=name, openapi_service=self.openapi_service)
-
+        self.validation = ValidationSetManager(openapi_service=self._openapi_service)

rapidata/rapidata_client/referee/__init__.py

@@ -1,3 +1,3 @@
-from .base_referee import Referee
-from .naive_referee import NaiveReferee #as MaxVoteReferee
-from .early_stopping_referee import EarlyStoppingReferee
+from ._base_referee import Referee
+from ._naive_referee import NaiveReferee #as MaxVoteReferee
+from ._early_stopping_referee import EarlyStoppingReferee

rapidata/rapidata_client/referee/{base_referee.py → _base_referee.py}

@@ -6,15 +6,15 @@ class Referee(ABC):
     The referee defines when a rapid is considered complete. 
     """
     @abstractmethod
-    def to_dict(self) -> Mapping[str, str | int | float]:
+    def _to_dict(self) -> Mapping[str, str | int | float]:
         """
         Convert the referee to a referee configuration dict.
         """
         pass
 
     @abstractmethod
-    def to_model(self) -> Any:
+    def _to_model(self) -> Any:
         """
         Convert the referee to a referee configuration model.
         """
-        pass
+        pass

rapidata/rapidata_client/referee/{early_stopping_referee.py → _early_stopping_referee.py}

@@ -1,5 +1,5 @@
 from typing import Any
-from rapidata.rapidata_client.referee.base_referee import Referee
+from rapidata.rapidata_client.referee._base_referee import Referee
 from rapidata.api_client.models.early_stopping_referee_model import (
     EarlyStoppingRefereeModel,
 )
@@ -18,31 +18,34 @@ class EarlyStoppingReferee(Referee):
     This referee is supported for the classification and compare tasks (in compare, 
     the two options are treated as the categories).
 
+    Args:
+        threshold (float, optional): The confidence threshold for early stopping.
+            Defaults to 0.999.
+        max_vote_count (int, optional): The maximum number of votes allowed
+            before stopping. Defaults to 100.
+
     Attributes:
         threshold (float): The confidence threshold for early stopping.
         max_vote_count (int): The maximum number of votes allowed before stopping.
     """
 
     def __init__(self, threshold: float = 0.999, max_vote_count: int = 100):
-        """Initialize the EarlyStoppingReferee.
-
-        Args:
-            threshold (float, optional): The confidence threshold for early stopping.
-                Defaults to 0.999.
-            max_vote_count (int, optional): The maximum number of votes allowed
-                before stopping. Defaults to 100.
-        """
+        if threshold <= 0 or threshold >= 1:
+            raise ValueError("The threshold must be between 0 and 1.")
+        if max_vote_count < 1:
+            raise ValueError("The number of responses must be greater than 0.")
+        
         self.threshold = threshold
         self.max_vote_count = max_vote_count
 
-    def to_dict(self):
+    def _to_dict(self):
         return {
             "_t": "ProbabilisticAttachCategoryRefereeConfig",
             "threshold": self.threshold,
             "maxVotes": self.max_vote_count,
         }
 
-    def to_model(self) -> Any:
+    def _to_model(self) -> Any:
         return EarlyStoppingRefereeModel(
             _t="EarlyStoppingReferee",
             threshold=self.threshold,

rapidata/rapidata_client/referee/{naive_referee.py → _naive_referee.py}

@@ -1,5 +1,5 @@
 from rapidata.api_client.models.naive_referee_model import NaiveRefereeModel
-from rapidata.rapidata_client.referee.base_referee import Referee
+from rapidata.rapidata_client.referee._base_referee import Referee
 
 
 class NaiveReferee(Referee):
@@ -9,25 +9,25 @@ class NaiveReferee(Referee):
     where the task is considered finished after a predetermined number of
     responses have been made, regardless of the content or quality of those responses.
 
+    Args:
+        responses (int, optional): The number of responses required
+            to complete the task. Defaults to 10. This is per media item.
+
     Attributes:
         responses (int): The number of responses required to complete the task.
     """
 
     def __init__(self, responses: int = 10):
-        """Initialize the NaiveReferee.
-
-        Args:
-            responses (int, optional): The number of responses required
-                to complete the task. Defaults to 10. This is per media item.
-        """
+        if responses < 1:
+            raise ValueError("The number of responses must be greater than 0.")
         super().__init__()
         self.responses = responses
 
-    def to_dict(self):
+    def _to_dict(self):
         return {
             "_t": "NaiveRefereeConfig",
             "guessesRequired": self.responses,
         }
 
-    def to_model(self):
+    def _to_model(self):
         return NaiveRefereeModel(_t="NaiveReferee", totalVotes=self.responses)

rapidata/rapidata_client/selection/__init__.py

@@ -1,4 +1,4 @@
-from .base_selection import Selection
+from ._base_selection import RapidataSelection
 from .demographic_selection import DemographicSelection
 from .labeling_selection import LabelingSelection
 from .validation_selection import ValidationSelection

rapidata/rapidata_client/{filter/base_filter.py → selection/_base_selection.py}

@@ -2,8 +2,8 @@ from abc import abstractmethod
 from typing import Any
 
 
-class Filter:
+class RapidataSelection:
 
     @abstractmethod
-    def to_model(self) -> Any:
+    def _to_model(self) -> Any:
         pass

rapidata/rapidata_client/selection/capped_selection.py

@@ -4,21 +4,31 @@ from rapidata.api_client.models.capped_selection import (
 from rapidata.api_client.models.capped_selection_selections_inner import (
     CappedSelectionSelectionsInner,
 )
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from typing import Sequence
 
 
-class CappedSelection(Selection):
+class CappedSelection(RapidataSelection):
+    """CappedSelection Class
 
-    def __init__(self, selections: Sequence[Selection], max_rapids: int):
+    Takes in different selections and caps the amount of rapids that can be shown.
+    
+    Useful for demographic and conditional validation selections.
+    
+    Args:
+        selections (Sequence[RapidataSelection]): List of selections to cap.
+        max_rapids (int): The maximum amount of rapids that can be shown for this selection.
+    """
+
+    def __init__(self, selections: Sequence[RapidataSelection], max_rapids: int):
         self.selections = selections
         self.max_rapids = max_rapids
 
-    def to_model(self):
+    def _to_model(self):
         return CappedSelectionModel(
             _t="CappedSelection",
             selections=[
-                CappedSelectionSelectionsInner(selection.to_model())
+                CappedSelectionSelectionsInner(selection._to_model())
                 for selection in self.selections
             ],
             maxRapids=self.max_rapids,

rapidata/rapidata_client/selection/conditional_validation_selection.py

@@ -1,4 +1,4 @@
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.api_client.models.conditional_validation_rapid_selection_config import (
     ValidationChance,
 )
@@ -7,8 +7,17 @@ from rapidata.api_client.models.conditional_validation_selection import (
 )
 
 
-class ConditionalValidationSelection(Selection):
-    """Demographic selection class."""
+class ConditionalValidationSelection(RapidataSelection):
+    """Conditional validation selection class.
+
+    Probabilistically decides how many validation rapids you want to show per session based on the user score.
+    
+    Args:
+        validation_set_id (str): The id of the validation set to be used.
+        thresholds (list[float]): The thresholds to use for the user score.
+        chances (list[float]): The chances of showing a validation rapid for each threshold.
+        rapid_counts (list[int]): The amount of validation rapids that will be shown per session of this validation set for each threshold if selected by probability. (all or nothing)
+    """
 
     def __init__(
         self,
@@ -17,12 +26,16 @@ class ConditionalValidationSelection(Selection):
         chances: list[float],
         rapid_counts: list[int],
     ):
+        if len(thresholds) != len(chances) or len(thresholds) != len(rapid_counts):
+            raise ValueError(
+                "The lengths of thresholds, chances and rapid_counts must be equal."
+            )
         self.validation_set_id = validation_set_id
         self.thresholds = thresholds
         self.chances = chances
         self.rapid_counts = rapid_counts
 
-    def to_model(self):
+    def _to_model(self):
         return ConditionalValidationSelectionModel(
             _t="ConditionalValidationSelection",
             validationSetId=self.validation_set_id,

rapidata/rapidata_client/selection/demographic_selection.py

@@ -1,13 +1,24 @@
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.api_client.models.demographic_selection import DemographicSelection as DemographicSelectionModel
 
 
-class DemographicSelection(Selection):
-    """Demographic selection class."""
+class DemographicSelection(RapidataSelection):
+    """Demographic selection class.
+    
+    This is used to ask demographic questions in an order.    
 
-    def __init__(self, keys: list[str], maxRapids: int):
+    The keys will select the rapids based on the confidence we already saved for each user.
+
+    If the confidence is high, the users will be selected to solve the rapids with lower probability.
+
+    Args:
+        keys (list[str]): List of keys for the demographic rapids to be shown. As an example: "age"
+        max_rapids (int): The maximum number of rapids to run.\n
+            Allows to provide more keys, in case some of the earlier ones are not selected because of high confidence."""
+
+    def __init__(self, keys: list[str], max_rapids: int):
         self.keys = keys
-        self.maxRapids = maxRapids
+        self.max_rapids = max_rapids
 
-    def to_model(self):
-        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys, maxRapids=self.maxRapids)
+    def _to_model(self):
+        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys, maxRapids=self.max_rapids)

rapidata/rapidata_client/selection/labeling_selection.py

@@ -1,14 +1,21 @@
 from typing import Any
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.api_client.models.labeling_selection import (
     LabelingSelection as LabelingSelectionModel,
 )
 
 
-class LabelingSelection(Selection):
+class LabelingSelection(RapidataSelection):
+    """Labeling selection class.
+    
+    Decides how many actual datapoints you want to show per session.
+    
+    Args:
+        amount (int): The amount of labeling rapids that will be shown per session.
+    """
 
     def __init__(self, amount: int):
         self.amount = amount
 
-    def to_model(self) -> Any:
+    def _to_model(self) -> Any:
         return LabelingSelectionModel(_t="LabelingSelection", amount=self.amount)

rapidata/rapidata_client/selection/rapidata_selections.py

@@ -0,0 +1,21 @@
+from rapidata.rapidata_client.selection import (
+    DemographicSelection, 
+    LabelingSelection, 
+    ValidationSelection, 
+    ConditionalValidationSelection, 
+    CappedSelection)
+
+class RapidataSelections:
+    """RapidataSelections Classes
+
+    Attributes:
+        demographic (DemographicSelection): The DemographicSelection instance.
+        labeling (LabelingSelection): The LabelingSelection instance.
+        validation (ValidationSelection): The ValidationSelection instance.
+        conditional_validation (ConditionalValidationSelection): The ConditionalValidationSelection instance.
+        capped (CappedSelection): The CappedSelection instance."""
+    demographic = DemographicSelection
+    labeling = LabelingSelection
+    validation = ValidationSelection
+    conditional_validation = ConditionalValidationSelection
+    capped = CappedSelection

rapidata/rapidata_client/selection/validation_selection.py

@@ -1,15 +1,22 @@
 
 from rapidata.api_client.models.validation_selection import ValidationSelection as ValidationSelectionModel
-from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 
 
-class ValidationSelection(Selection):
+class ValidationSelection(RapidataSelection):
+    """Validation selection class.
+
+    Decides how many validation rapids you want to show per session.
+    
+    Args:
+        validation_set_id (str): The id of the validation set to be used.
+        amount (int): The amount of validation rapids that will be shown per session of this validation set.
+    """
 
     def __init__(self, validation_set_id: str, amount: int = 1):
         self.validation_set_id = validation_set_id
         self.amount = amount
 
-
-    def to_model(self):
+    def _to_model(self):
         return ValidationSelectionModel(_t="ValidationSelection", validationSetId=self.validation_set_id, amount=self.amount)
     

rapidata/rapidata_client/settings/__init__.py

@@ -1,2 +1,9 @@
-from .feature_flags import FeatureFlags
-from .settings import Settings, TranslationBehaviour
+from .models import TranslationBehaviourOptions
+from .alert_on_fast_response import AlertOnFastResponse
+from .translation_behaviour import TranslationBehaviour
+from .free_text_minimum_characters import FreeTextMinimumCharacters
+from .no_shuffle import NoShuffle
+from .play_video_until_the_end import PlayVideoUntilTheEnd
+from .custom_setting import CustomSetting
+from .rapidata_settings import RapidataSettings
+from ._rapidata_setting import RapidataSetting

rapidata/rapidata_client/settings/_rapidata_setting.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import Any
+from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
+
+class RapidataSetting(BaseModel):
+    """Base class for all settings"""
+    key: str
+    value: Any
+
+    def _to_feature_flag(self) -> FeatureFlagModel:
+        return FeatureFlagModel(key=self.key, value=str(self.value))

rapidata/rapidata_client/settings/alert_on_fast_response.py

@@ -0,0 +1,21 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+class AlertOnFastResponse(RapidataSetting):
+    """
+    Gives an alert as a pop up on the UI when the response time is less than the milliseconds.
+    
+    Args:
+        threshold (int): if the user responds in less than this time, an alert will be shown.
+    """
+    
+    def __init__(self, threshold: int):
+        if not isinstance(threshold, int):
+            raise ValueError("The alert must be an integer.")
+        if threshold < 10:
+            print(f"Warning: Are you sure you want to set the threshold so low ({threshold} milliseconds)?")
+        if threshold > 25000:
+            raise ValueError("The alert must be less than 25000 milliseconds.")
+        if threshold < 0:
+            raise ValueError("The alert must be greater than or equal to 0.")
+    
+        super().__init__(key="alert_on_fast_response", value=threshold)

rapidata/rapidata_client/settings/custom_setting.py

@@ -0,0 +1,16 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+class CustomSetting(RapidataSetting):
+    """
+    Set a custom setting with the given key and value. Use this to enable features that do not have a dedicated method (yet)
+    
+    Args:
+        key (str): The key for the custom setting.
+        value (str): The value for the custom setting.
+    """
+
+    def __init__(self, key: str, value: str):
+        if not isinstance(key, str):
+            raise ValueError("The key must be a string.")
+        
+        super().__init__(key=key, value=value)

rapidata/rapidata_client/settings/free_text_minimum_characters.py

@@ -0,0 +1,16 @@
+from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+
+class FreeTextMinimumCharacters(RapidataSetting):
+    """
+    Set the minimum number of characters a user has to type.
+    
+    Args:
+        value (int): The minimum number of characters for free text.
+    """
+
+    def __init__(self, value: int):
+        if value < 1:
+            raise ValueError("The minimum number of characters must be greater than or equal to 1.")
+        if value > 40:
+            print(f"Warning: Are you sure you want to set the minimum number of characters at {value}?")
+        super().__init__(key="free_text_minimum_characters", value=value)

rapidata/rapidata_client/settings/models/__init__.py

@@ -0,0 +1 @@
+from .translation_behaviour_options import TranslationBehaviourOptions