rapidata 2.27.0__tar.gz → 2.27.2__tar.gz

{rapidata-2.27.0 → rapidata-2.27.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.27.0
+Version: 2.27.2
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG

{rapidata-2.27.0 → rapidata-2.27.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.27.0"
+version = "2.27.2"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.27.0"
+__version__ = "2.27.2"
 
 from .rapidata_client import (
     RapidataClient,

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/rapidata_client/filter/rapidata_filters.py

@@ -18,13 +18,13 @@ class RapidataFilters:
         This might significantly slow down the number of responses you receive.
     
     Attributes:
-        user_score (UserScoreFilter): The UserScoreFilter instance.
-        age (AgeFilter): The AgeFilter instance.
-        country (CountryFilter): The CountryFilter instance.
-        gender (GenderFilter): The GenderFilter instance.
-        language (LanguageFilter): The LanguageFilter instance.
-        not_filter (NotFilter): The NotFilter instance.
-        or_filter (OrFilter): The OrFilter instance.
+        user_score (UserScoreFilter): Filters for users with a specific user score.
+        age (AgeFilter): Filters for users with a specific age.
+        country (CountryFilter): Filters for users with a specific country.
+        gender (GenderFilter): Filters for users with a specific gender.
+        language (LanguageFilter): Filters for users with a specific language.
+        not_filter (NotFilter): Inverts the filter.
+        or_filter (OrFilter): Combines multiple filters with a logical OR operation.
 
     Example:
         ```python

rapidata-2.27.2/src/rapidata/rapidata_client/logging/logger.py

@@ -0,0 +1,122 @@
+"""
+Provides centralized logging configuration for the Rapidata Python SDK.
+It sets up a logger instance that is used throughout the SDK to provide
+consistent logging behavior and formatting.
+
+The logger is configured with sensible defaults but can be customized using the
+`configure_logger` function to adjust log levels, output destinations, and formatting.
+
+Example:
+    Basic usage with default configuration:
+    ```python
+    from rapidata import logger
+    
+    logger.info("This is an info message")
+    logger.error("This is an error message")
+    ```
+    
+    Custom configuration:
+    ```python
+    from rapidata import configure_logger
+    
+    # Configure with DEBUG level and file output
+    configure_logger(
+        level="DEBUG",
+        log_file="/path/to/logs/rapidata.log"
+    )
+    ```
+"""
+import logging
+import os
+from typing import Optional
+
+# Create module-level logger
+logger = logging.getLogger("rapidata")
+
+def configure_logger(
+    level: str = "WARNING",
+    log_file: Optional[str] = None,
+    format_string: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+) -> None:
+    """
+    Configure the logger with custom settings.
+    
+    This function allows you to customize the logging behavior for the entire SDK.
+    You can set the log level, specify a file for log output, and customize the log message format.
+    
+    Note:
+        This function removes any existing handlers before adding new ones,
+        so it's safe to call multiple times to reconfigure logging.
+    
+    Args:
+        level: The logging level to set. Must be one of:\n
+            - "DEBUG": Detailed information for diagnosing problems
+            - "INFO": General information about program execution
+            - "WARNING": Something unexpected happened (default)
+            - "ERROR": A serious problem occurred
+            - "CRITICAL": A very serious error occurred
+            
+        log_file: Optional path to a file where logs should be written.
+            If provided, logs will be written to both console and file.
+            The directory will be created if it doesn't exist.
+            
+        format_string: Custom format string for log messages.
+            Uses Python logging format specifications.
+            Default includes timestamp, logger name, level, and message.
+    
+    Example:
+        Configure for development with debug logging:
+        ```python
+        configure_logger(level="DEBUG")
+        ```
+        
+        Configure for production with file logging:
+        ```python
+        configure_logger(
+            level="INFO",
+            log_file="/var/log/rapidata/app.log"
+        )
+        ```
+        
+        Configure with custom format:
+        ```python
+        configure_logger(
+            level="INFO",
+            format_string="[%(levelname)s] %(message)s"
+        )
+        ```
+    """
+    # Map string levels to logging constants for validation and conversion
+    level_map = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO, 
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL
+    }
+    
+    numeric_level = level_map.get(level.upper(), logging.INFO)
+    logger.setLevel(numeric_level)
+    
+    # Remove existing handlers if any
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+    
+    # Create formatter
+    formatter = logging.Formatter(format_string)
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler (optional)
+    if log_file:
+        log_dir = os.path.dirname(log_file)
+        if log_dir:
+            os.makedirs(log_dir, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+configure_logger()

rapidata-2.27.2/src/rapidata/rapidata_client/logging/output_manager.py

@@ -0,0 +1,20 @@
+class RapidataOutputManager:
+    """Manages print outputs and progress bars for the Rapidata module."""
+    
+    silent_mode: bool = False
+
+    @classmethod
+    def enable_silent_mode(cls) -> None:
+        """Enable silent mode, suppressing all print outputs and progress bars, not logging."""
+        cls.silent_mode = True
+
+    @classmethod
+    def disable_silent_mode(cls) -> None:
+        """Disable silent mode, allowing outputs to be printed.
+        This is the default behavior.
+        """
+        cls.silent_mode = False
+
+def managed_print(*args, **kwargs) -> None:
+    if not RapidataOutputManager.silent_mode:
+        print(*args, **kwargs)

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -77,6 +77,9 @@ class RapidataOrderManager:
             private_notes: list[str] | None = None,
             default_labeling_amount: int = 3
         ) -> RapidataOrder:
+
+        if not assets:
+            raise ValueError("No datapoints provided")
         
         if contexts and len(contexts) != len(assets):
             raise ValueError("Number of contexts must match number of datapoints")

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/rapidata_client/selection/rapidata_selections.py

@@ -10,15 +10,16 @@ class RapidataSelections:
     """RapidataSelections Classes
 
     Selections are used to define what type of tasks and in what order they are shown to the user. 
-    All Tasks are called a "Session". A session can contain multiple tasks of different types.
+    All selections combined are called a "Session". A session can contain multiple tasks of different types of tasks.
+    As an example, a session might be 1 validation task, 2 labeling tasks.
 
     Attributes:
-        labeling (LabelingSelection): The LabelingSelection instance.
-        validation (ValidationSelection): The ValidationSelection instance.
-        conditional_validation (ConditionalValidationSelection): The ConditionalValidationSelection instance.
-        demographic (DemographicSelection): The DemographicSelection instance.
-        capped (CappedSelection): The CappedSelection instance.
-        shuffling (ShufflingSelection): The ShufflingSelection instance.
+        labeling (LabelingSelection): Decides how many actual datapoints you want to show per session.
+        validation (ValidationSelection): Decides how many validation rapids you want to show per session.
+        conditional_validation (ConditionalValidationSelection): Probabilistically decides how many validation rapids you want to show per session based on the user score.
+        demographic (DemographicSelection): Decides if and how many demographic questions you want to show per session.
+        capped (CappedSelection): Takes in different selections and caps the amount of rapids that can be shown.
+        shuffling (ShufflingSelection): Shuffles the selections provided in the list.
     
     Example:
         ```python

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/rapidata_client/settings/rapidata_settings.py

@@ -4,7 +4,6 @@ from rapidata.rapidata_client.settings import (
     FreeTextMinimumCharacters,
     NoShuffle,
     PlayVideoUntilTheEnd,
-    CustomSetting,
     )
 
 class RapidataSettings:
@@ -14,12 +13,11 @@ class RapidataSettings:
     Settings can be added to an order to determine the behaviour of the task.
     
     Attributes:
-        alert_on_fast_response (AlertOnFastResponse): The AlertOnFastResponse instance.
-        translation_behaviour (TranslationBehaviour): The TranslationBehaviour instance.
-        free_text_minimum_characters (FreeTextMinimumCharacters): The FreeTextMinimumCharacters instance.
-        no_shuffle (NoShuffle): The NoShuffle instance.
-        play_video_until_the_end (PlayVideoUntilTheEnd): The PlayVideoUntilTheEnd instance.
-        custom_setting (CustomSetting): The CustomSetting instance.
+        alert_on_fast_response (AlertOnFastResponse): Gives an alert as a pop up on the UI when the response time is less than the milliseconds.
+        translation_behaviour (TranslationBehaviour): Defines what's the behaviour of the translation in the UI.
+        free_text_minimum_characters (FreeTextMinimumCharacters): Only for free text tasks. Set the minimum number of characters a user has to type.
+        no_shuffle (NoShuffle): Only for classification and compare tasks. If true, the order of the categories / images will not be shuffled and presented in the same order as specified.
+        play_video_until_the_end (PlayVideoUntilTheEnd): Allows users to only answer once the video has finished playing.
 
     Example:
         ```python
@@ -35,5 +33,4 @@ class RapidataSettings:
     free_text_minimum_characters = FreeTextMinimumCharacters
     no_shuffle = NoShuffle
     play_video_until_the_end = PlayVideoUntilTheEnd
-    custom_setting = CustomSetting
 

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/rapidata_client/validation/validation_set_manager.py

@@ -5,7 +5,7 @@ from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.assets.data_type_enum import RapidataDataTypes
 from rapidata.rapidata_client.validation.rapids.rapids_manager import RapidsManager
 from rapidata.rapidata_client.validation.rapids.rapids import Rapid
-from rapidata.rapidata_client.metadata import PromptMetadata
+from rapidata.rapidata_client.metadata import PromptMetadata, MediaAssetMetadata
 
 from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.root_filter import RootFilter
@@ -39,6 +39,7 @@ class ValidationSetManager:
         truths: list[list[str]],
         data_type: str = RapidataDataTypes.MEDIA,
         contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         explanations: list[str | None] | None = None,
         dimensions: list[str] = [],
     ) -> RapidataValidationSet:
@@ -58,6 +59,9 @@ class ValidationSetManager:
             contexts (list[str], optional): The contexts for each datapoint. Defaults to None.\n
                 If provided has to be the same length as datapoints and will be shown in addition to the instruction and answer options. (Therefore will be different for each datapoint)
                 Will be match up with the datapoints using the list index.
+            media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. 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.
             explanations (list[str | None], optional): The explanations for each datapoint. Will be given to the annotators in case the answer is wrong. Defaults to None.
             dimensions (list[str], optional): The dimensions to add to the validation set accross which users will be tracked. Defaults to [] which is the default dimension.
 
@@ -79,12 +83,21 @@ class ValidationSetManager:
         if contexts and len(contexts) != len(datapoints):
             raise ValueError("The number of contexts and datapoints must be equal")
 
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("The number of media contexts and datapoints must be equal")
+
         if(explanations and len(explanations) != len(datapoints)):
             raise ValueError("The number of explanations and datapoints must be equal, the index must align, but can be padded with None")
+
        
         logger.debug("Creating classification rapids")
         rapids: list[Rapid] = []
         for i in range(len(datapoints)):
+            rapid_metadata = []
+            if contexts:
+                rapid_metadata.append(PromptMetadata(contexts[i]))
+            if media_contexts:
+                rapid_metadata.append(MediaAssetMetadata(media_contexts[i]))
             rapids.append(
                 self.rapid.classification_rapid(
                     instruction=instruction,
@@ -92,7 +105,7 @@ class ValidationSetManager:
                     datapoint=datapoints[i],
                     truths=truths[i],
                     data_type=data_type,
-                    metadata=[PromptMetadata(contexts[i])] if contexts else [],
+                    metadata=rapid_metadata,
                     explanation=explanations[i] if explanations != None else None
                 )
             )
@@ -107,6 +120,7 @@ class ValidationSetManager:
         truths: list[str],
         data_type: str = RapidataDataTypes.MEDIA,
         contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         explanation: list[str | None] | None = None,
         dimensions: list[str] = [],
     ) -> RapidataValidationSet:
@@ -126,6 +140,9 @@ class ValidationSetManager:
             contexts (list[str], optional): The contexts for each datapoint. Defaults to None.\n
                 If provided has to be the same length as datapoints and will be shown in addition to the instruction and truth. (Therefore will be different for each datapoint)
                 Will be match up with the datapoints using the list index.
+            media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. 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.
             explanation (list[str | None], optional): The explanations for each datapoint. Will be given to the annotators in case the answer is wrong. Defaults to None.
             dimensions (list[str], optional): The dimensions to add to the validation set accross which users will be tracked. Defaults to [] which is the default dimension.
 
@@ -146,6 +163,9 @@ class ValidationSetManager:
 
         if contexts and len(contexts) != len(datapoints):
             raise ValueError("The number of contexts and datapoints must be equal")
+
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("The number of media contexts and datapoints must be equal")
  
         if(explanation and len(explanation) != len(datapoints)):
             raise ValueError("The number of explanations and datapoints must be equal, the index must align, but can be padded with None")
@@ -153,13 +173,18 @@ class ValidationSetManager:
         logger.debug("Creating comparison rapids")
         rapids: list[Rapid] = []
         for i in range(len(datapoints)):
+            rapid_metadata = []
+            if contexts:
+                rapid_metadata.append(PromptMetadata(contexts[i]))
+            if media_contexts:
+                rapid_metadata.append(MediaAssetMetadata(media_contexts[i]))
             rapids.append(
                 self.rapid.compare_rapid(
                     instruction=instruction,
                     truth=truths[i],
                     datapoint=datapoints[i],
                     data_type=data_type,
-                    metadata=[PromptMetadata(contexts[i])] if contexts else [],
+                    metadata=rapid_metadata,
                     explanation=explanation[i] if explanation != None else None
                 )
             )
@@ -238,6 +263,7 @@ class ValidationSetManager:
         truths: list[list[Box]],
         datapoints: list[str],
         contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         explanation: list[str | None] | None = None,
         dimensions: list[str] = [],
     ) -> RapidataValidationSet:
@@ -252,6 +278,9 @@ class ValidationSetManager:
                     truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
             datapoints (list[str]): The datapoints that will be used for validation.
             contexts (list[str], optional): The contexts for each datapoint. Defaults to None.
+            media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. 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.
             explanation (list[str | None], optional): The explanations for each datapoint. Will be given to the annotators in case the answer is wrong. Defaults to None.
             dimensions (list[str], optional): The dimensions to add to the validation set accross which users will be tracked. Defaults to [] which is the default dimension.
 
@@ -272,6 +301,9 @@ class ValidationSetManager:
         if contexts and len(contexts) != len(datapoints):
             raise ValueError("The number of contexts and datapoints must be equal")
  
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("The number of media contexts and datapoints must be equal")
+
         if(explanation and len(explanation) != len(datapoints)):
             raise ValueError("The number of explanations and datapoints must be equal, the index must align, but can be padded with None")
         
@@ -279,12 +311,17 @@ class ValidationSetManager:
         rapids = []
         rapids: list[Rapid] = []
         for i in range(len(datapoints)):
+            rapid_metadata = []
+            if contexts:
+                rapid_metadata.append(PromptMetadata(contexts[i]))
+            if media_contexts:
+                rapid_metadata.append(MediaAssetMetadata(media_contexts[i]))
             rapids.append(
                 self.rapid.locate_rapid(
                     instruction=instruction,
                     truths=truths[i],
                     datapoint=datapoints[i],
-                    metadata=[PromptMetadata(contexts[i])] if contexts else [],
+                    metadata=rapid_metadata,
                     explanation=explanation[i] if explanation != None else None
 
                 )
@@ -299,6 +336,7 @@ class ValidationSetManager:
         truths: list[list[Box]],
         datapoints: list[str],
         contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         explanation: list[str | None] | None = None,
         dimensions: list[str] = [],
     ) -> RapidataValidationSet:
@@ -313,6 +351,9 @@ class ValidationSetManager:
                     truths: [[Box(0, 0, 100, 100)], [Box(50, 50, 150, 150)]] -> first datapoint the object is in the top left corner, second datapoint the object is in the center
             datapoints (list[str]): The datapoints that will be used for validation.
             contexts (list[str], optional): The contexts for each datapoint. Defaults to None.
+            media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. 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.
             explanation (list[str | None], optional): The explanations for each datapoint. Will be given to the annotators in case the answer is wrong. Defaults to None.
             dimensions (list[str], optional): The dimensions to add to the validation set accross which users will be tracked. Defaults to [] which is the default dimension.
 
@@ -333,18 +374,26 @@ class ValidationSetManager:
         if contexts and len(contexts) != len(datapoints):
             raise ValueError("The number of contexts and datapoints must be equal")
  
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("The number of media contexts and datapoints must be equal")
+
         if(explanation and len(explanation) != len(datapoints)):
             raise ValueError("The number of explanations and datapoints must be equal, the index must align, but can be padded with None")
 
         logger.debug("Creating draw rapids")
         rapids: list[Rapid] = []
         for i in range(len(datapoints)):
+            rapid_metadata = []
+            if contexts:
+                rapid_metadata.append(PromptMetadata(contexts[i]))
+            if media_contexts:
+                rapid_metadata.append(MediaAssetMetadata(media_contexts[i]))
             rapids.append(
                 self.rapid.draw_rapid(
                     instruction=instruction,
                     truths=truths[i],
                     datapoint=datapoints[i],
-                    metadata=[PromptMetadata(contexts[i])] if contexts else [],
+                    metadata=rapid_metadata,
                     explanation=explanation[i] if explanation != None else None
 
                 )
@@ -359,6 +408,7 @@ class ValidationSetManager:
         truths: list[list[tuple[int, int]]],
         datapoints: list[str],
         contexts: list[str] | None = None,
+        media_contexts: list[str] | None = None,
         explanation: list[str | None] | None = None,
         dimensions: list[str] = [],
     ) -> RapidataValidationSet:
@@ -374,6 +424,9 @@ class ValidationSetManager:
                     truths: [[(0, 10)], [(20, 30)]] -> first datapoint the correct interval is from 0 to 10, second datapoint the correct interval is from 20 to 30
             datapoints (list[str]): The datapoints that will be used for validation.
             contexts (list[str], optional): The contexts for each datapoint. Defaults to None.
+            media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. 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.
             explanation (list[str | None], optional): The explanations for each datapoint. Will be given to the annotators in case the answer is wrong. Defaults to None.
             dimensions (list[str], optional): The dimensions to add to the validation set accross which users will be tracked. Defaults to [] which is the default dimension.
 
@@ -394,18 +447,26 @@ class ValidationSetManager:
         if contexts and len(contexts) != len(datapoints):
             raise ValueError("The number of contexts and datapoints must be equal")
  
+        if media_contexts and len(media_contexts) != len(datapoints):
+            raise ValueError("The number of media contexts and datapoints must be equal")
+
         if(explanation and len(explanation) != len(datapoints)):
             raise ValueError("The number of explanations and datapoints must be equal, the index must align, but can be padded with None")
               
         logger.debug("Creating timestamp rapids")
         rapids: list[Rapid] = []
         for i in range(len(datapoints)):
+            rapid_metadata = []
+            if contexts:
+                rapid_metadata.append(PromptMetadata(contexts[i]))
+            if media_contexts:
+                rapid_metadata.append(MediaAssetMetadata(media_contexts[i]))
             rapids.append(
                 self.rapid.timestamp_rapid(
                     instruction=instruction,
                     truths=truths[i],
                     datapoint=datapoints[i],
-                    metadata=[PromptMetadata(contexts[i])] if contexts else [],
+                    metadata=rapid_metadata,
                     explanation=explanation[i] if explanation != None else None
                 )
             )

{rapidata-2.27.0 → rapidata-2.27.2}/src/rapidata/service/credential_manager.py

@@ -81,7 +81,9 @@ class CredentialManager:
 
         # Ensure file is only readable by the user
         os.chmod(self.config_path, 0o600)
-        logger.debug(f"Set permissions for {self.config_path} to read/write for user only.")
+        logger.debug(
+            f"Set permissions for {self.config_path} to read/write for user only."
+        )
 
     def _store_credential(self, credential: ClientCredential) -> None:
         credentials = self._read_credentials()
@@ -128,16 +130,14 @@ class CredentialManager:
         if self.endpoint in credentials:
             del credentials[self.endpoint]
             self._write_credentials(credentials)
-            logger.info(
-                f"Credentials for {self.endpoint} have been reset."
-            )
+            logger.info(f"Credentials for {self.endpoint} have been reset.")
 
     def _get_bridge_tokens(self) -> Optional[BridgeToken]:
         """Get bridge tokens from the identity endpoint."""
         logger.debug("Getting bridge tokens")
         try:
             bridge_endpoint = (
-                f"{self.endpoint}/Identity/CreateBridgeToken?clientId=rapidata-cli"
+                f"{self.endpoint}/identity/bridge-token?clientId=rapidata-cli"
             )
             response = requests.post(bridge_endpoint, verify=self.cert_path)
             if not response.ok:
@@ -152,7 +152,7 @@ class CredentialManager:
 
     def _poll_read_key(self, read_key: str) -> Optional[str]:
         """Poll the read key endpoint until we get an access token."""
-        read_endpoint = f"{self.endpoint}/Identity/ReadBridgeToken"
+        read_endpoint = f"{self.endpoint}/identity/bridge-token"
         start_time = time.time()
 
         while time.time() - start_time < self.poll_timeout:

rapidata-2.27.0/src/rapidata/rapidata_client/logging/logger.py

@@ -1,47 +0,0 @@
-import logging
-import os
-from typing import Optional
-
-# Create module-level logger
-logger = logging.getLogger("rapidata")
-
-def configure_logger(
-    level: str = "WARNING",
-    log_file: Optional[str] = None,
-    format_string: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-):
-    """Configure the Rapidata logger with custom settings."""
-    # Convert string level to logging level
-    level_map = {
-        "DEBUG": logging.DEBUG,
-        "INFO": logging.INFO, 
-        "WARNING": logging.WARNING,
-        "ERROR": logging.ERROR,
-        "CRITICAL": logging.CRITICAL
-    }
-    
-    numeric_level = level_map.get(level.upper(), logging.INFO)
-    logger.setLevel(numeric_level)
-    
-    # Remove existing handlers if any
-    for handler in logger.handlers[:]:
-        logger.removeHandler(handler)
-    
-    # Create formatter
-    formatter = logging.Formatter(format_string)
-    
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-    
-    # File handler (optional)
-    if log_file:
-        log_dir = os.path.dirname(log_file)
-        if log_dir:
-            os.makedirs(log_dir, exist_ok=True)
-        file_handler = logging.FileHandler(log_file)
-        file_handler.setFormatter(formatter)
-        logger.addHandler(file_handler)
-
-configure_logger()

rapidata-2.27.0/src/rapidata/rapidata_client/logging/output_manager.py

@@ -1,16 +0,0 @@
-class RapidataOutputManager:
-    silent_mode = False
-    
-    @classmethod
-    def enable_silent_mode(cls):
-        cls.silent_mode = True
-        
-    @classmethod
-    def disable_silent_mode(cls):
-        cls.silent_mode = False
-
-def managed_print(*args, **kwargs):
-    if not RapidataOutputManager.silent_mode:
-        print(*args, **kwargs)
-
-