rapidata 2.36.1__py3-none-any.whl → 2.37.0__py3-none-any.whl

rapidata/rapidata_client/filter/response_count_filter.py

@@ -3,6 +3,8 @@ from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.response_count_user_filter_model import (
     ResponseCountUserFilterModel,
 )
+from rapidata.api_client.models.comparison_operator import ComparisonOperator
+
 
 class ResponseCountFilter(RapidataFilter):
     """ResponseCountFilter Class
@@ -11,12 +13,12 @@ class ResponseCountFilter(RapidataFilter):
         response_count (int): The number of user responses to filter by.
         dimension (str): The dimension to apply the filter on (e.g. "default", "electrical", etc.).
         operator (str): The comparison operator to use. Must be one of:
-            - "Equal"
-            - "NotEqual"
-            - "LessThan"
-            - "LessThanOrEqual"
-            - "GreaterThan"
-            - "GreaterThanOrEqual"
+            - ComparisonOperator.EQUAL
+            - ComparisonOperator.NOTEQUAL
+            - ComparisonOperator.LESSTHAN
+            - ComparisonOperator.LESSTHANOREQUAL
+            - ComparisonOperator.GREATERTHAN
+            - ComparisonOperator.GREATERTHANOREQUAL
 
     Raises:
         ValueError: If `response_count` is not an integer.
@@ -27,14 +29,14 @@ class ResponseCountFilter(RapidataFilter):
         ```python
         from rapidata import ResponseCountFilter
 
-        filter = ResponseCountFilter(response_count=10, dimension="electrical", operator="GreaterThan")
+        filter = ResponseCountFilter(response_count=10, dimension="electrical", operator=ComparisonOperator.GREATERTHAN)
         ```
         This will filter users who have a response count greater than 10 for the "electrical" dimension.
     """
 
-    def __init__(self, response_count: int, dimension: str, operator: str):
-        if operator not in ["Equal", "NotEqual", "LessThan", "LessThanOrEqual", "GreaterThan", "GreaterThanOrEqual"]:
-            raise ValueError("Operator must be one of Equal, NotEqual, LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual")
+    def __init__(
+        self, response_count: int, dimension: str, operator: ComparisonOperator
+    ):
 
         self.response_count = response_count
         self.dimension = dimension
@@ -42,5 +44,8 @@ class ResponseCountFilter(RapidataFilter):
 
     def _to_model(self):
         return ResponseCountUserFilterModel(
-            _t="ResponseCountFilter", responseCount=self.response_count, dimension=self.dimension, operator=self.operator
+            _t="ResponseCountFilter",
+            responseCount=self.response_count,
+            dimension=self.dimension,
+            operator=self.operator,
         )

rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -1,4 +1,4 @@
-from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
 from rapidata.rapidata_client.datapoints.assets import TextAsset, MediaAsset
 from rapidata.service import LocalFileService
 from rapidata.service.openapi_service import OpenAPIService
@@ -16,7 +16,7 @@ import threading
 from rapidata.rapidata_client.api.rapidata_exception import (
     suppress_rapidata_error_logging,
 )
-from rapidata.rapidata_client.config.config import rapidata_config
+from rapidata.rapidata_client.config.rapidata_config import rapidata_config
 
 
 def chunk_list(lst: list, chunk_size: int) -> Generator:
@@ -67,7 +67,7 @@ class RapidataDataset:
 
         total_uploads = len(datapoints)
         with ThreadPoolExecutor(
-            max_workers=rapidata_config.max_upload_workers
+            max_workers=rapidata_config.maxUploadWorkers
         ) as executor:
             future_to_datapoint = {
                 executor.submit(upload_text_datapoint, datapoint, index=i): datapoint
@@ -119,7 +119,7 @@ class RapidataDataset:
         urls = datapoint.get_urls()
 
         last_exception = None
-        for attempt in range(rapidata_config.upload_max_retries):
+        for attempt in range(rapidata_config.uploadMaxRetries):
             try:
                 with suppress_rapidata_error_logging():
                     self.openapi_service.dataset_api.dataset_dataset_id_datapoints_post(
@@ -136,7 +136,7 @@ class RapidataDataset:
 
             except Exception as e:
                 last_exception = e
-                if attempt < rapidata_config.upload_max_retries - 1:
+                if attempt < rapidata_config.uploadMaxRetries - 1:
                     # Exponential backoff: wait 1s, then 2s, then 4s
                     retry_delay = 2**attempt
                     time.sleep(retry_delay)
@@ -144,13 +144,13 @@ class RapidataDataset:
                     logger.debug(
                         "Retrying %s of %s...",
                         attempt + 1,
-                        rapidata_config.upload_max_retries,
+                        rapidata_config.uploadMaxRetries,
                     )
 
         # If we get here, all retries failed
         local_failed.append(datapoint)
         tqdm.write(
-            f"Upload failed for {datapoint} after {rapidata_config.upload_max_retries} attempts. \nFinal error: \n{str(last_exception)}"
+            f"Upload failed for {datapoint} after {rapidata_config.uploadMaxRetries} attempts. \nFinal error: \n{str(last_exception)}"
         )
 
         return local_successful, local_failed
@@ -293,7 +293,7 @@ class RapidataDataset:
 
         try:
             with ThreadPoolExecutor(
-                max_workers=rapidata_config.max_upload_workers
+                max_workers=rapidata_config.maxUploadWorkers
             ) as executor:
                 # Process uploads in chunks to avoid overwhelming the system
                 for chunk_idx, chunk in enumerate(chunk_list(datapoints, chunk_size)):

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -1,5 +1,5 @@
-from typing import Literal, Optional, cast, Sequence
-
+from typing import Literal, Optional, Sequence
+import random
 from rapidata.api_client.models.ab_test_selection_a_inner import AbTestSelectionAInner
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
@@ -11,14 +11,22 @@ from rapidata.api_client.models.create_order_model_referee import (
 from rapidata.api_client.models.create_order_model_workflow import (
     CreateOrderModelWorkflow,
 )
+from rapidata.api_client.models.sticky_state import StickyState
 
-from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
 from rapidata.rapidata_client.exceptions.failed_upload_exception import (
     FailedUploadException,
     _parse_failed_uploads,
 )
 from rapidata.rapidata_client.filter import RapidataFilter
-from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.rapidata_client.logging import (
+    logger,
+    managed_print,
+    RapidataOutputManager,
+)
+from rapidata.rapidata_client.validation.validation_set_manager import (
+    ValidationSetManager,
+)
 from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.referee import Referee
@@ -27,6 +35,10 @@ from rapidata.rapidata_client.selection._base_selection import RapidataSelection
 from rapidata.rapidata_client.settings import RapidataSetting
 from rapidata.rapidata_client.workflow import Workflow
 from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.config.rapidata_config import rapidata_config
+from rapidata.rapidata_client.api.rapidata_exception import (
+    suppress_rapidata_error_logging,
+)
 
 
 class RapidataOrderBuilder:
@@ -47,7 +59,7 @@ class RapidataOrderBuilder:
         self._name = name
         self.order_id: str | None = None
         self.__openapi_service = openapi_service
-        self.__dataset: Optional[RapidataDataset]
+        self.__dataset: Optional[RapidataDataset] = None
         self.__workflow: Workflow | None = None
         self.__referee: Referee | None = None
         self.__validation_set_id: str | None = None
@@ -56,7 +68,12 @@ class RapidataOrderBuilder:
         self.__selections: list[RapidataSelection] = []
         self.__priority: int | None = None
         self.__datapoints: list[Datapoint] = []
-        self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
+        self.__sticky_state_value: Literal["None", "Temporary", "Permanent"] | None = (
+            None
+        )
+        self.__validation_set_manager: ValidationSetManager = ValidationSetManager(
+            self.__openapi_service
+        )
 
     def _to_model(self) -> CreateOrderModel:
         """
@@ -99,9 +116,68 @@ class RapidataOrderBuilder:
                 else None
             ),
             priority=self.__priority,
-            stickyState=self.__sticky_state,
+            stickyState=(
+                StickyState(self.__sticky_state_value)
+                if self.__sticky_state_value
+                else None
+            ),
+        )
+
+    def _set_validation_set_id(self) -> None:
+        """
+        Get the validation set ID for the order.
+        """
+        assert self.__workflow is not None
+        if self.__validation_set_id:
+            logger.debug(
+                "Using specified validation set with ID: %s", self.__validation_set_id
+            )
+            return
+
+        try:
+            with suppress_rapidata_error_logging():
+                self.__validation_set_id = (
+                    (
+                        self.__openapi_service.validation_api.validation_set_recommended_get(
+                            asset_type=[self.__datapoints[0].get_asset_type()],
+                            modality=[self.__workflow.modality],
+                            prompt_type=[
+                                t.value for t in self.__datapoints[0].get_prompt_type()
+                            ],
+                        )
+                    )
+                    .validation_sets[0]
+                    .id
+                )
+            logger.debug(
+                "Using recommended validation set with ID: %s", self.__validation_set_id
+            )
+        except Exception as e:
+            logger.info("No recommended validation set found, creating new one.")
+
+        if len(self.__datapoints) < rapidata_config.minOrderDatapointsForValidation:
+            logger.debug(
+                "No recommended validation set found, dataset too small to create one."
+            )
+            return
+
+        managed_print()
+        managed_print(
+            f"No recommended validation set found, new one will be created.\nWe recommend adding some truths to ensure the order is accurate."
+        )
+        validation_set = self.__validation_set_manager._create_order_validation_set(
+            workflow=self.__workflow,
+            order_name=self._name,
+            datapoints=random.sample(
+                self.__datapoints,
+                min(rapidata_config.autoValidationSetSize, len(self.__datapoints)),
+            ),
+            settings=self.__settings,
         )
 
+        logger.debug("New validation set created for order: %s", validation_set)
+        self.__validation_set_id = validation_set.id
+
     def _create(self) -> RapidataOrder:
         """
         Create the Rapidata order by making the necessary API calls based on the builder's configuration.
@@ -116,6 +192,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrder: The created RapidataOrder instance.
         """
+        if rapidata_config.enableBetaFeatures:
+            self._set_validation_set_id()
+
         order_model = self._to_model()
         logger.debug("Creating order with model: %s", order_model)
 
@@ -358,5 +437,5 @@ class RapidataOrderBuilder:
                 "Sticky state must be of type Literal['None', 'Temporary', 'Permanent']."
             )
 
-        self.__sticky_state = sticky_state
+        self.__sticky_state_value = sticky_state
         return self

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -28,7 +28,7 @@ from rapidata.rapidata_client.workflow import (
     RankingWorkflow,
 )
 from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
-from rapidata.rapidata_client.datapoints.datapoint import Datapoint
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.filter.rapidata_filters import RapidataFilters
 from rapidata.rapidata_client.settings import RapidataSettings, RapidataSetting
@@ -39,7 +39,10 @@ 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.filter_operator import FilterOperator
 from rapidata.api_client.models.sort_criterion import SortCriterion
+from rapidata.api_client.models.sort_direction import SortDirection
+
 
 from tqdm import tqdm
 
@@ -164,6 +167,7 @@ class RapidataOrderManager:
             ._sticky_state(self.__sticky_state)
             ._create()
         )
+        logger.debug("Order created: %s", order)
         return order
 
     def _set_priority(self, priority: int):
@@ -424,6 +428,8 @@ class RapidataOrderManager:
         datapoints: list[str],
         data_type: Literal["media", "text"] = "media",
         responses_per_datapoint: int = 10,
+        contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         filters: Sequence[RapidataFilter] = [],
         settings: Sequence[RapidataSetting] = [],
         selections: Sequence[RapidataSelection] = [],
@@ -441,6 +447,12 @@ class RapidataOrderManager:
             data_type (str, optional): The data type of the datapoints. Defaults to "media" (any form of image, video or audio). \n
                 Other option: "text".
             responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
+            contexts (list[str], optional): The list of contexts for the free text. Defaults to None.\n
+                If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
+                Will be matched up with the datapoints using the list index.
+            media_contexts (list[str], optional): The list of media contexts for the free text i.e links to the images / videos. Defaults to None.\n
+                If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
+                Will be matched up with the datapoints using the list index.
             filters (Sequence[RapidataFilter], optional): The list of filters for the free text. Defaults to []. Decides who the tasks should be shown to.
             settings (Sequence[RapidataSetting], optional): The list of settings for the free text. Defaults to []. Decides how the tasks should be shown.
             selections (Sequence[RapidataSelection], optional): The list of selections for the free text. Defaults to []. Decides in what order the tasks should be shown.
@@ -463,6 +475,8 @@ class RapidataOrderManager:
             workflow=FreeTextWorkflow(instruction=instruction),
             assets=assets,
             responses_per_datapoint=responses_per_datapoint,
+            contexts=contexts,
+            media_contexts=media_contexts,
             filters=filters,
             selections=selections,
             settings=settings,
@@ -509,7 +523,9 @@ class RapidataOrderManager:
 
         return self._create_general_order(
             name=name,
-            workflow=SelectWordsWorkflow(instruction=instruction),
+            workflow=SelectWordsWorkflow(
+                instruction=instruction,
+            ),
             assets=assets,
             responses_per_datapoint=responses_per_datapoint,
             validation_set_id=validation_set_id,
@@ -730,10 +746,18 @@ class RapidataOrderManager:
             QueryModel(
                 page=PageInfo(index=1, size=amount),
                 filter=RootFilter(
-                    filters=[Filter(field="OrderName", operator="Contains", value=name)]
+                    filters=[
+                        Filter(
+                            field="OrderName",
+                            operator=FilterOperator.CONTAINS,
+                            value=name,
+                        )
+                    ]
                 ),
                 sortCriteria=[
-                    SortCriterion(direction="Desc", propertyName="OrderDate")
+                    SortCriterion(
+                        direction=SortDirection.DESC, propertyName="OrderDate"
+                    )
                 ],
             )
         )

rapidata/rapidata_client/rapidata_client.py

@@ -16,6 +16,7 @@ from rapidata.rapidata_client.validation.validation_set_manager import (
 from rapidata.rapidata_client.demographic.demographic_manager import DemographicManager
 
 from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.rapidata_client.config.rapidata_config import rapidata_config
 
 
 class RapidataClient:
@@ -77,6 +78,11 @@ class RapidataClient:
         """Reset the credentials saved in the configuration file for the current environment."""
         self._openapi_service.reset_credentials()
 
+    def _enable_beta_features(self):
+        """Enable beta features for the client."""
+        logger.debug("Enabling beta features")
+        rapidata_config.enableBetaFeatures = True
+
     def _check_version(self):
         try:
             response = requests.get(

rapidata/rapidata_client/selection/__init__.py

@@ -7,5 +7,5 @@ from .capped_selection import CappedSelection
 from .shuffling_selection import ShufflingSelection
 from .ab_test_selection import AbTestSelection
 from .static_selection import StaticSelection
-from .retrieval_modes import RetrievalMode
+from .rapidata_retrieval_modes import RapidataRetrievalMode
 from .effort_selection import EffortSelection

rapidata/rapidata_client/selection/effort_selection.py

@@ -1,6 +1,10 @@
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.api_client.models.effort_capped_selection import EffortCappedSelection as EffortCappedSelectionModel
-from rapidata.rapidata_client.selection.retrieval_modes import RetrievalMode
+from rapidata.api_client.models.effort_capped_selection import (
+    EffortCappedSelection as EffortCappedSelectionModel,
+)
+from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
+    RapidataRetrievalMode,
+)
 
 
 class EffortSelection(RapidataSelection):
@@ -13,14 +17,21 @@ class EffortSelection(RapidataSelection):
         retrieval_mode (RetrievalMode): The retrieval mode for the task.
         max_iterations (int | None): The maximum number of iterations for the task.
     """
-    def __init__(self, effort_budget: int, retrieval_mode: RetrievalMode = RetrievalMode.Shuffled, max_iterations: int | None = None):
+
+    def __init__(
+        self,
+        effort_budget: int,
+        retrieval_mode: RapidataRetrievalMode = RapidataRetrievalMode.Shuffled,
+        max_iterations: int | None = None,
+    ):
         self.effort_budget = effort_budget
         self.retrieval_mode = retrieval_mode
         self.max_iterations = max_iterations
 
     def _to_model(self):
         return EffortCappedSelectionModel(
-            _t="EffortCappedSelection", 
-            effortBudget=self.effort_budget, 
-            retrievalMode=self.retrieval_mode.value, 
-            maxIterations=self.max_iterations)
+            _t="EffortCappedSelection",
+            effortBudget=self.effort_budget,
+            retrievalMode=self.retrieval_mode.value,
+            maxIterations=self.max_iterations,
+        )

rapidata/rapidata_client/selection/labeling_selection.py

@@ -1,6 +1,8 @@
 from typing import Any
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.rapidata_client.selection.retrieval_modes import RetrievalMode
+from rapidata.rapidata_client.selection.rapidata_retrieval_modes import (
+    RapidataRetrievalMode,
+)
 from rapidata.api_client.models.labeling_selection import (
     LabelingSelection as LabelingSelectionModel,
 )
@@ -8,21 +10,31 @@ from rapidata.api_client.models.labeling_selection import (
 
 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.
         retrieval_mode (RetrievalMode): The retrieval mode to use. Defaults to "Shuffled".
-        max_iterations (int | None): An annotator can answer the same task only once if the retrieval_mode is "Shuffled" 
-            or "Sequential". max_iterations can increase the amount of responses an annotator can do 
+        max_iterations (int | None): An annotator can answer the same task only once if the retrieval_mode is "Shuffled"
+            or "Sequential". max_iterations can increase the amount of responses an annotator can do
             to the same task (datapoint).
     """
 
-    def __init__(self, amount: int, retrieval_mode: RetrievalMode = RetrievalMode.Shuffled, max_iterations: int | None = None):
+    def __init__(
+        self,
+        amount: int,
+        retrieval_mode: RapidataRetrievalMode = RapidataRetrievalMode.Shuffled,
+        max_iterations: int | None = None,
+    ):
         self.amount = amount
         self.retrieval_mode = retrieval_mode
         self.max_iterations = max_iterations
 
     def _to_model(self) -> Any:
-        return LabelingSelectionModel(_t="LabelingSelection", amount=self.amount, retrievalMode=self.retrieval_mode.value, maxIterations=self.max_iterations)
+        return LabelingSelectionModel(
+            _t="LabelingSelection",
+            amount=self.amount,
+            retrievalMode=self.retrieval_mode.value,
+            maxIterations=self.max_iterations,
+        )

rapidata/rapidata_client/selection/{retrieval_modes.py → rapidata_retrieval_modes.py}

@@ -1,18 +1,21 @@
 from enum import Enum
+from rapidata.api_client.models.retrieval_mode import RetrievalMode
 
-class RetrievalMode(Enum):
+
+class RapidataRetrievalMode(Enum):
     """
     Enum for defining retrieval modes for datapoints.
     """
-    Shuffled = "Shuffled"
+
+    Shuffled = RetrievalMode.SHUFFLED
     """
     Will shuffle the datapoints randomly for each user. The user will then see the datapoints in that order. This will take into account the "max_iterations" parameter.
     """
-    Sequential = "Sequential"
+    Sequential = RetrievalMode.SEQUENTIAL
     """
     Will show the datapoints in the order they are in the dataset. This will take into account the "max_iterations" parameter.
     """
-    Random = "Random"
+    Random = RetrievalMode.RANDOM
     """
     Will just randomly feed the datapoints to the annotators. This will NOT take into account the "max_iterations" parameter.
     """

rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -1,6 +1,9 @@
+import webbrowser
+import urllib.parse
+from colorama import Fore
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.logging import logger, managed_print
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
 from rapidata.api_client.models.update_should_alert_model import UpdateShouldAlertModel
 
@@ -20,6 +23,9 @@ class RapidataValidationSet:
     def __init__(self, validation_set_id, name: str, openapi_service: OpenAPIService):
         self.id = validation_set_id
         self.name = name
+        self.validation_set_details_page = (
+            f"https://app.{openapi_service.environment}/validation-set/detail/{self.id}"
+        )
         self.__openapi_service = openapi_service
 
     def add_rapid(self, rapid: Rapid):
@@ -62,6 +68,25 @@ class RapidataValidationSet:
         )
         return self
 
+    def view(self) -> None:
+        """
+        Opens the validation set details page in the browser.
+
+        Raises:
+            Exception: If the order is not in processing state.
+        """
+        logger.info("Opening validation set details page in browser...")
+        could_open_browser = webbrowser.open(self.validation_set_details_page)
+        if not could_open_browser:
+            encoded_url = urllib.parse.quote(
+                self.validation_set_details_page, safe="%/:=&?~#+!$,;'@()*[]"
+            )
+            managed_print(
+                Fore.RED
+                + f"Please open this URL in your browser: '{encoded_url}'"
+                + Fore.RESET
+            )
+
     def __str__(self):
         return f"name: '{self.name}' id: {self.id}"