rapidata 2.21.4__py3-none-any.whl → 2.22.0__py3-none-any.whl

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -29,6 +29,8 @@ from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset, B
 
 from typing import Optional, cast, Sequence
 
+from rapidata.rapidata_client.logging import logger, managed_print
+
 
 class RapidataOrderBuilder:
     """Builder object for creating Rapidata orders.
@@ -73,7 +75,7 @@ class RapidataOrderBuilder:
             raise ValueError("You must provide a workflow to create an order.")
 
         if self.__referee is None:
-            print("No referee provided, using default NaiveReferee.")
+            managed_print("No referee provided, using default NaiveReferee.")
             self.__referee = NaiveReferee()
 
         return CreateOrderModel(
@@ -113,6 +115,7 @@ class RapidataOrderBuilder:
             RapidataOrder: The created RapidataOrder instance.
         """
         order_model = self._to_model()
+        logger.debug(f"Creating order with model: {order_model}")
         if isinstance(
             self.__workflow, CompareWorkflow
         ):  # Temporary fix; will be handled by backend in the future
@@ -125,12 +128,17 @@ class RapidataOrderBuilder:
         )
 
         self.order_id = str(result.order_id)
+        logger.debug(f"Order created with ID: {self.order_id}")
 
         self.__dataset = (
             RapidataDataset(result.dataset_id, self.__openapi_service)
             if result.dataset_id
             else None
         )
+        if self.__dataset:
+            logger.debug(f"Dataset created with ID: {self.__dataset.dataset_id}")
+        else:
+            logger.warning("No dataset created for this order.")
 
         order = RapidataOrder(
             order_id=self.order_id,
@@ -138,6 +146,9 @@ class RapidataOrderBuilder:
             name=self._name,
         )
 
+        logger.debug(f"Order created: {order}")
+        logger.debug("Adding media to the order.")
+
         if all(isinstance(item, MediaAsset) for item in self.__assets) and self.__dataset:
             assets = cast(list[MediaAsset], self.__assets)
             self.__dataset._add_media_from_paths(assets, self.__metadata, max_upload_workers)
@@ -183,6 +194,8 @@ class RapidataOrderBuilder:
                 "Media paths must all be of the same type: MediaAsset, TextAsset, or MultiAsset."
             )
         
+        logger.debug("Media added to the order.")
+        logger.debug("Setting order to preview")
         self.__openapi_service.order_api.order_order_id_preview_post(self.order_id)
 
         return order
@@ -291,7 +304,7 @@ class RapidataOrderBuilder:
                 raise TypeError("Filters must be of type Filter.")
 
         if len(self.__user_filters) > 0:
-            print("Overwriting existing user filters.")
+            managed_print("Overwriting existing user filters.")
 
         self.__user_filters = filters
         return self

rapidata/rapidata_client/order/rapidata_order.py

@@ -17,6 +17,7 @@ from rapidata.api_client.models.preliminary_download_model import PreliminaryDow
 from rapidata.api_client.models.workflow_artifact_model import WorkflowArtifactModel
 from rapidata.rapidata_client.order.rapidata_results import RapidataResults
 from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.logging import logger, managed_print
 
 
 class RapidataOrder:
@@ -47,23 +48,29 @@ class RapidataOrder:
         self._max_retries = 10  
         self._retry_delay = 2
         self.order_details_page = f"https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}"
+        logger.debug("RapidataOrder initialized")
 
-    def run(self, print_link: bool = True) -> "RapidataOrder":
+    def run(self) -> "RapidataOrder":
         """Runs the order to start collecting responses."""
-        self.__openapi_service.order_api.order_submit_post(self.order_id)
-        if print_link:
-            print(f"Order '{self.name}' is now viewable under: {self.order_details_page}")
+        logger.info(f"Starting order '{self}'")
+        self.__openapi_service.order_api.order_order_id_submit_post(self.order_id)
+        logger.debug(f"Order '{self}' has been started.")
+        managed_print(f"Order '{self.name}' is now viewable under: {self.order_details_page}")
         return self
 
     def pause(self) -> None:
         """Pauses the order."""
+        logger.info(f"Pausing order '{self}'")
         self.__openapi_service.order_api.order_pause_post(self.order_id)
-        print(f"Order '{self}' has been paused.")
+        logger.debug(f"Order '{self}' has been paused.")
+        managed_print(f"Order '{self}' has been paused.")
 
     def unpause(self) -> None:
         """Unpauses/resumes the order."""
+        logger.info(f"Unpausing order '{self}'")
         self.__openapi_service.order_api.order_resume_post(self.order_id)
-        print(f"Order '{self}' has been unpaused.")
+        logger.debug(f"Order '{self}' has been unpaused.")
+        managed_print(f"Order '{self}' has been unpaused.")
 
     def get_status(self) -> str:
         """
@@ -95,12 +102,12 @@ class RapidataOrder:
             raise Exception("Order has not been started yet. Please start it first.")
         
         while self.get_status() == OrderState.SUBMITTED:
-            print(f"Order '{self.name}' is submitted and being reviewed. Standby...", end="\r")
+            managed_print(f"Order '{self}' is submitted and being reviewed. Standby...", end="\r")
             sleep(1)
 
         if self.get_status() == OrderState.MANUALREVIEW:
             raise Exception(
-                f"Order '{self.name}' is in manual review. It might take some time to start. "
+                f"Order '{self}' is in manual review. It might take some time to start. "
                 "To speed up the process, contact support (info@rapidata.ai).\n"
                 "Once started, run this method again to display the progress bar."
             )
@@ -145,12 +152,12 @@ class RapidataOrder:
                 Note that preliminary results are not final and may not contain all the datapoints & responses. Only the onese that are already available.
                 This will throw an exception if there are no responses available yet.
         """
-
+        logger.info(f"Getting results for order '{self}'...")
         if preliminary_results and self.get_status() not in [OrderState.COMPLETED]:
             return self.__get_preliminary_results()
         
         elif preliminary_results and self.get_status() in [OrderState.COMPLETED]:
-            print("Order is already completed. Returning final results.")
+            managed_print("Order is already completed. Returning final results.")
 
         while self.get_status() not in [OrderState.COMPLETED, OrderState.PAUSED, OrderState.MANUALREVIEW, OrderState.FAILED]:
             sleep(5)
@@ -167,10 +174,11 @@ class RapidataOrder:
         Raises:
             Exception: If the order is not in processing state.
         """
+        logger.info("Opening order details page in browser...")
         could_open_browser = webbrowser.open(self.order_details_page)
         if not could_open_browser:
             encoded_url = urllib.parse.quote(self.order_details_page, safe="%/:=&?~#+!$,;'@()*[]")
-            print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
+            managed_print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
         
     def preview(self) -> None:
         """
@@ -178,13 +186,14 @@ class RapidataOrder:
         
         Raises:
             Exception: If the order is not in processing state.
-        """        
+        """
+        logger.info("Opening order preview in browser...")
         campaign_id = self.__get_campaign_id()
         auth_url = f"https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}/preview?campaignId={campaign_id}"
         could_open_browser = webbrowser.open(auth_url)
         if not could_open_browser:
             encoded_url = urllib.parse.quote(auth_url, safe="%/:=&?~#+!$,;'@()*[]")
-            print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
+            managed_print(Fore.RED + f'Please open this URL in your browser: "{encoded_url}"' + Fore.RESET)
 
     def __get_pipeline_id(self) -> str:
         """Internal method to fetch and cache the pipeline ID."""
@@ -249,7 +258,7 @@ class RapidataOrder:
             raise Exception(f"Failed to get preliminary results: {str(e)}") from e
 
     def __str__(self) -> str:
-        return f"name: '{self.name}' order id: {self.order_id}"
+        return f"RapidataOrder(name='{self.name}', order_id='{self.order_id}')"
 
     def __repr__(self) -> str:
         return f"RapidataOrder(name='{self.name}', order_id='{self.order_id}')"

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -34,6 +34,7 @@ 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.rapidata_client.logging import logger
 
 from tqdm import tqdm
 
@@ -53,6 +54,7 @@ class RapidataOrderManager:
         self.settings = RapidataSettings
         self.selections = RapidataSelections
         self.__priority = 50
+        logger.debug("RapidataOrderManager initialized")
 
     def __get_selections(self, validation_set_id: str | None, labeling_amount=3) -> Sequence[RapidataSelection]:
         if validation_set_id:
@@ -85,7 +87,7 @@ class RapidataOrderManager:
             raise ValueError("You can only use contexts or sentences, not both")
         
         if contexts and data_type == RapidataDataTypes.TEXT:
-            print("Warning: Contexts are not supported for text data type. Ignoring contexts.")
+            logger.warning("Warning: Contexts are not supported for text data type. Ignoring contexts.")
 
         if not confidence_threshold:
             referee = NaiveReferee(responses=responses_per_datapoint)
@@ -98,7 +100,7 @@ class RapidataOrderManager:
         order_builder = RapidataOrderBuilder(name=name, openapi_service=self._openapi_service)
 
         if selections and validation_set_id:
-            print("Warning: You provided both selections and validation_set_id. Ignoring validation_set_id.")
+            logger.warning("Warning: Both selections and validation_set_id provided. Ignoring validation_set_id.")
         
         if selections is None:
             selections = self.__get_selections(validation_set_id, labeling_amount=default_labeling_amount)

rapidata/rapidata_client/order/rapidata_results.py

@@ -2,6 +2,7 @@ import pandas as pd
 from typing import Any
 from pandas.core.indexes.base import Index
 import json
+from rapidata.rapidata_client.logging import managed_print
 
 class RapidataResults(dict):
     """
@@ -32,7 +33,7 @@ class RapidataResults(dict):
             return pd.DataFrame()
         
         if self["info"].get("orderType") is None:
-            print("Warning: Results are old and Order type is not specified. Dataframe might be wrong.")
+            managed_print("Warning: Results are old and Order type is not specified. Dataframe might be wrong.")
         
         # Check for detailed results if split_details is True
         if split_details:

rapidata/rapidata_client/rapidata_client.py

@@ -8,6 +8,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
 
 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."""
@@ -38,6 +39,7 @@ class RapidataClient:
             order (RapidataOrderManager): The RapidataOrderManager instance.
             validation (ValidationSetManager): The ValidationSetManager instance.
         """
+        logger.debug("Initializing OpenAPIService")
         self._openapi_service = OpenAPIService(
             client_id=client_id,
             client_secret=client_secret,
@@ -48,12 +50,15 @@ class RapidataClient:
             leeway=leeway,
         )
 
+        logger.debug("Initializing RapidataOrderManager")
         self.order = RapidataOrderManager(openapi_service=self._openapi_service)
 
+        logger.debug("Initializing ValidationSetManager")
         self.validation = ValidationSetManager(openapi_service=self._openapi_service)
 
+        logger.debug("Initializing DemographicManager")
         self._demographic = DemographicManager(openapi_service=self._openapi_service)
-
+        
     def reset_credentials(self):
         """Reset the credentials saved in the configuration file for the current environment."""
         self._openapi_service.reset_credentials()

rapidata/rapidata_client/selection/__init__.py

@@ -7,3 +7,4 @@ 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

rapidata/rapidata_client/selection/labeling_selection.py

@@ -1,5 +1,6 @@
 from typing import Any
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+from rapidata.rapidata_client.selection.retrieval_modes import RetrievalMode
 from rapidata.api_client.models.labeling_selection import (
     LabelingSelection as LabelingSelectionModel,
 )
@@ -12,10 +13,15 @@ class LabelingSelection(RapidataSelection):
     
     Args:
         amount (int): The amount of labeling rapids that will be shown per session.
+        retrieval_mode (RetrievalMode): The retrieval mode to use. Defaults to "Random".
+        max_iterations (int | None): The maximum number an annotator can see the same task. Defaults to None.
+            This parameter is only taken into account when using "Shuffled" or "Sequential" retrieval modes.
     """
 
-    def __init__(self, amount: int):
+    def __init__(self, amount: int, retrieval_mode: RetrievalMode = RetrievalMode.Random, 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)
+        return LabelingSelectionModel(_t="LabelingSelection", amount=self.amount, retrievalMode=self.retrieval_mode.value, maxIterations=self.max_iterations)

rapidata/rapidata_client/selection/retrieval_modes.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class RetrievalMode(Enum):
+    # Will just randomly shuffle the datapoints. This is the default and will NOT take into account the "max_iterations" parameter.
+    Random = "Random"
+    # 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.
+    Shuffled = "Shuffled"
+    # Will show the datapoints in the order they are in the dataset. This will take into account the "max_iterations" parameter.
+    Sequential = "Sequential"

rapidata/rapidata_client/settings/alert_on_fast_response.py

@@ -1,4 +1,5 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+from rapidata.rapidata_client.logging import managed_print
 
 class AlertOnFastResponse(RapidataSetting):
     """
@@ -12,7 +13,7 @@ class AlertOnFastResponse(RapidataSetting):
         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)?")
+            managed_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:

rapidata/rapidata_client/settings/free_text_minimum_characters.py

@@ -1,4 +1,5 @@
 from rapidata.rapidata_client.settings._rapidata_setting import RapidataSetting
+from rapidata.rapidata_client.logging import managed_print, logger
 
 class FreeTextMinimumCharacters(RapidataSetting):
     """
@@ -12,5 +13,5 @@ class FreeTextMinimumCharacters(RapidataSetting):
         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}?")
+            managed_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/validation/rapidata_validation_set.py

@@ -1,8 +1,8 @@
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
 from rapidata.service.openapi_service import OpenAPIService
-from requests.adapters import HTTPAdapter, Retry
-import requests
+from rapidata.rapidata_client.logging import logger
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
+from rapidata.rapidata_client.assets._sessions import SessionManager
 
 class RapidataValidationSet:
     """A class for interacting with a Rapidata validation set.
@@ -20,7 +20,6 @@ class RapidataValidationSet:
         self.id = validation_set_id
         self.name = name
         self.__openapi_service = openapi_service
-        self.__session = self._get_session()
     
     def add_rapid(self, rapid: Rapid):
         """Add a Rapid to the validation set.
@@ -28,7 +27,7 @@ class RapidataValidationSet:
         Args:
             rapid (Rapid): The Rapid to add to the validation set.
         """
-        rapid._add_to_validation_set(self.id, self.__openapi_service, self.__session)
+        rapid._add_to_validation_set(self.id, self.__openapi_service)
         return self
 
     def update_dimensions(self, dimensions: list[str]):
@@ -37,39 +36,10 @@ class RapidataValidationSet:
         Args:
             dimensions (list[str]): The new dimensions of the validation set.
         """
+        logger.debug(f"Updating dimensions for validation set {self.id} to {dimensions}")
         self.__openapi_service.validation_api.validation_validation_set_id_dimensions_patch(self.id, UpdateDimensionsModel(dimensions=dimensions))
         return self
 
-    def _get_session(self, max_retries: int = 5, max_workers: int = 10) -> requests.Session:   
-        """Get a requests session with retry logic.
-
-
-        Args:
-            max_retries (int): The maximum number of retries.
-            max_workers (int): The maximum number of workers.
-
-        Returns:
-            requests.Session: A requests session with retry logic.
-        """
-        session = requests.Session()
-        retries = Retry(
-            total=max_retries,
-            backoff_factor=1,
-            status_forcelist=[500, 502, 503, 504],
-            allowed_methods=["GET"],
-            respect_retry_after_header=True
-        )
-
-        adapter = HTTPAdapter(
-            pool_connections=max_workers * 2,
-            pool_maxsize=max_workers * 4,
-            max_retries=retries
-        )
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
-
-        return session
-
     def __str__(self):
         return f"name: '{self.name}' id: {self.id}"
 

rapidata/rapidata_client/validation/rapids/rapids.py

@@ -19,7 +19,8 @@ from rapidata.api_client.models.create_datapoint_from_files_model_metadata_inner
 
 from rapidata.service.openapi_service import OpenAPIService
 
-import requests
+from rapidata.rapidata_client.logging import logger
+
 
 class Rapid():
     def __init__(self, asset: MediaAsset | TextAsset | MultiAsset, metadata: Sequence[Metadata], payload: Any, truth: Any, randomCorrectProbability: float, explanation: str | None):
@@ -29,15 +30,16 @@ class Rapid():
         self.truth = truth
         self.randomCorrectProbability = randomCorrectProbability
         self.explanation = explanation 
+        logger.debug(f"Created Rapid with asset: {self.asset}, metadata: {self.metadata}, payload: {self.payload}, truth: {self.truth}, randomCorrectProbability: {self.randomCorrectProbability}, explanation: {self.explanation}")
 
-    def _add_to_validation_set(self, validationSetId: str, openapi_service: OpenAPIService, session: requests.Session) -> None:
+    def _add_to_validation_set(self, validationSetId: str, openapi_service: OpenAPIService) -> None:
         if isinstance(self.asset, TextAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], TextAsset)):
             openapi_service.validation_api.validation_add_validation_text_rapid_post(
                 add_validation_text_rapid_model=self.__to_text_model(validationSetId)
             )
 
         elif isinstance(self.asset, MediaAsset) or (isinstance(self.asset, MultiAsset) and isinstance(self.asset.assets[0], MediaAsset)):
-            model = self.__to_media_model(validationSetId, session=session)
+            model = self.__to_media_model(validationSetId)
             openapi_service.validation_api.validation_add_validation_rapid_post(
                 model=model[0], files=model[1]
             )
@@ -45,7 +47,7 @@ class Rapid():
         else:
             raise TypeError("The asset must be a MediaAsset, TextAsset, or MultiAsset")
 
-    def __to_media_model(self, validationSetId: str, session: requests.Session) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
+    def __to_media_model(self, validationSetId: str) -> tuple[AddValidationRapidModel, list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]]:
         assets: list[MediaAsset] = [] 
         if isinstance(self.asset, MultiAsset):
             for asset in self.asset.assets:
@@ -60,9 +62,6 @@ class Rapid():
         if isinstance(self.asset, MediaAsset):
             assets = [self.asset]
 
-        for asset in assets:
-            asset.session = session
-
         return (AddValidationRapidModel(
             validationSetId=validationSetId,
             payload=AddValidationRapidModelPayload(self.payload),