rapidata 2.28.2__py3-none-any.whl → 2.44.3__py3-none-any.whl

rapidata/rapidata_client/leaderboard/rapidata_leaderboard.py

@@ -1,127 +0,0 @@
-from rapidata.api_client.models.create_leaderboard_participant_model import CreateLeaderboardParticipantModel
-from rapidata.api_client.models.page_info import PageInfo
-from rapidata.api_client.models.query_model import QueryModel
-
-from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
-from rapidata.rapidata_client.assets import MediaAsset
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.service.openapi_service import OpenAPIService
-
-
-class RapidataLeaderboard:
-    """
-    An instance of a Rapidata leaderboard.
-
-    Used to interact with a specific leaderboard in the Rapidata system, such as retrieving prompts and evaluating models.
-
-    Args:
-        name: The name that will be used to identify the leaderboard on the overview.
-        instruction: The instruction that will determine what how the models will be evaluated.
-        show_prompt: Whether to show the prompt to the users.
-        id: The ID of the leaderboard.
-        openapi_service: The OpenAPIService instance for API interaction.
-    """
-    def __init__(self, name: str, instruction: str, show_prompt: bool, id: str, openapi_service: OpenAPIService):
-        self.__openapi_service = openapi_service
-        self.name = name
-        self.instruction = instruction
-        self.show_prompt = show_prompt
-        self._prompts: list[str] = []
-        self.id = id
-
-    @property
-    def prompts(self) -> list[str]:
-        """
-        Returns the prompts that are registered for the leaderboard.
-        """
-        if not self._prompts:
-            current_page = 1
-            total_pages = None
-            
-            while True:
-                prompts_result = self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_prompts_get(
-                    leaderboard_id=self.id,
-                    request=QueryModel(
-                        page=PageInfo(
-                            index=current_page,
-                            size=100
-                        )
-                    )
-                )
-                
-                if prompts_result.total_pages is None:
-                    raise ValueError("An error occurred while fetching prompts: total_pages is None")
-                
-                total_pages = prompts_result.total_pages
-                
-                self._prompts.extend([prompt.prompt for prompt in prompts_result.items])
-                
-                if current_page >= total_pages:
-                    break
-                    
-                current_page += 1
-                
-        return self._prompts
-    
-    def _register_prompts(self, prompts: list[str]):
-        """
-        Registers the prompts for the leaderboard.
-        """
-        for prompt in prompts:
-            self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_prompts_post(
-                leaderboard_id=self.id,
-                body=prompt
-            )
-        self._prompts = prompts
-
-    def evaluate_model(self, name: str, media: list[str], prompts: list[str]) -> None:
-        """
-        Evaluates a model on the leaderboard.
-
-        Args:
-            name: The name of the model.
-            media: The generated images/videos that will be used to evaluate the model.
-            prompts: The prompts that correspond to the media. The order of the prompts must match the order of the media.
-                The prompts that are used must be registered for the leaderboard. To see the registered prompts, use the prompts property.
-        """
-        if not media:
-            raise ValueError("Media must be a non-empty list of strings")
-        
-        if len(media) != len(prompts):
-            raise ValueError("Media and prompts must have the same length")
-        
-        if not all(prompt in self.prompts for prompt in prompts):
-            raise ValueError("All prompts must be in the registered prompts list. To see the registered prompts, use the prompts property.")
-        
-        # happens before the creation of the participant to ensure all media paths are valid
-        assets = []
-        prompts_metadata: list[list[PromptMetadata]] = []
-        for media_path, prompt in zip(media, prompts):
-            assets.append(MediaAsset(media_path))
-            prompts_metadata.append([PromptMetadata(prompt)])
-
-        participant_result = self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_participants_post(
-            leaderboard_id=self.id,
-            create_leaderboard_participant_model=CreateLeaderboardParticipantModel(
-                name=name,
-            )
-        )
-        dataset = RapidataDataset(participant_result.dataset_id, self.__openapi_service)
-
-        dataset._add_datapoints(assets, prompts_metadata)
-
-        self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_participants_participant_id_submit_post(
-            leaderboard_id=self.id,
-            participant_id=participant_result.participant_id
-        )
-
-    def __str__(self) -> str:
-        return f"RapidataLeaderboard(name={self.name}, instruction={self.instruction}, show_prompt={self.show_prompt}, leaderboard_id={self.id})"
-    
-    def __repr__(self) -> str:
-        return self.__str__()
-
-
-        
-
-

rapidata/rapidata_client/leaderboard/rapidata_leaderboard_manager.py

@@ -1,92 +0,0 @@
-from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.leaderboard.rapidata_leaderboard import RapidataLeaderboard
-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.create_leaderboard_model import CreateLeaderboardModel
-
-class RapidataLeaderboardManager:
-    """
-    A manager for leaderboards.
-
-    Used to create and retrieve leaderboards.
-
-    Args:
-        openapi_service: The OpenAPIService instance for API interaction.
-    """
-    def __init__(self, openapi_service: OpenAPIService):
-        self.__openapi_service = openapi_service
-
-    def create_new_leaderboard(self, name: str, instruction: str, prompts: list[str], show_prompt: bool = False) -> RapidataLeaderboard:
-        """
-        Creates a new leaderboard with the given name, instruction, and prompts.
-
-        Args:
-            leaderboard_name: The name of the leaderboard. Will be used to identify the leaderboard on the overview.
-            instruction: The instruction for the leaderboard. Will determine how the models will be evaluated.
-            prompts: The prompts for the leaderboard. Will be registered for the leaderboard and able to be retrieved again later.
-            show_prompt: Whether to show the prompt to the users when they are evaluating the models.
-        """
-        if not isinstance(name, str):
-            raise ValueError("Name must be a string.")
-        
-        if not isinstance(instruction, str):
-            raise ValueError("Instruction must be a string.")
-        
-        if not isinstance(show_prompt, bool):
-            raise ValueError("Show prompt must be a boolean.")
-        
-        if not isinstance(prompts, list) or not all(isinstance(prompt, str) for prompt in prompts):
-            raise ValueError("Prompts must be a list of strings.")
-
-        leaderboard_id = self.__register_new_leaderboard(name, instruction, show_prompt)
-        leaderboard = RapidataLeaderboard(name, instruction, show_prompt, leaderboard_id, self.__openapi_service)
-        leaderboard._register_prompts(prompts)
-        return leaderboard
-    
-    def get_leaderboard_by_id(self, leaderboard_id: str) -> RapidataLeaderboard:
-        """
-        Retrieves a leaderboard by its ID.
-
-        Args:
-            leaderboard_id: The ID of the leaderboard.
-        """
-        leaderboard_result = self.__openapi_service.leaderboard_api.leaderboard_leaderboard_id_get(
-            leaderboard_id=leaderboard_id
-        )
-        return RapidataLeaderboard(leaderboard_result.name, leaderboard_result.instruction, leaderboard_result.show_prompt, leaderboard_id, self.__openapi_service)
-    
-    def find_leaderboards(self, name: str = "", amount: int = 10) -> list[RapidataLeaderboard]:
-        """
-        Find your recent leaderboards given criteria. If nothing is provided, it will return the most recent leaderboard.
-
-        Args:
-            name (str, optional): The name of the leaderboard - matching leaderboard will contain the name. Defaults to "" for any leaderboard.
-            amount (int, optional): The amount of leaderboards to return. Defaults to 10.
-        """
-        leaderboard_result = self.__openapi_service.leaderboard_api.leaderboards_get(
-            request=QueryModel(
-                page=PageInfo(
-                    index=1,
-                    size=amount
-                ),
-                filter=RootFilter(filters=[Filter(field="Name", operator="Contains", value=name)]),
-                sortCriteria=[SortCriterion(direction="Desc", propertyName="CreatedAt")]
-            )
-        )
-        leaderboards = []
-        for leaderboard in leaderboard_result.items:
-            leaderboards.append(RapidataLeaderboard(leaderboard.name, leaderboard.instruction, leaderboard.show_prompt, leaderboard.id, self.__openapi_service))
-        return leaderboards
-
-    def __register_new_leaderboard(self, name: str, instruction: str, show_prompt: bool) -> str:
-        leaderboard_id = self.__openapi_service.leaderboard_api.leaderboard_post(
-            CreateLeaderboardModel(
-                name=name,
-                instruction=instruction,
-                showPrompt=show_prompt
-            )
-        ).id
-        return leaderboard_id

rapidata/rapidata_client/logging/__init__.py

@@ -1,2 +0,0 @@
-from .logger import configure_logger, logger
-from .output_manager import managed_print, RapidataOutputManager

rapidata/rapidata_client/logging/logger.py

@@ -1,122 +0,0 @@
-"""
-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/rapidata_client/logging/output_manager.py

@@ -1,20 +0,0 @@
-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/rapidata_client/metadata/_media_asset_metadata.py

@@ -1,15 +0,0 @@
-from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
-from rapidata.api_client.models.url_asset_input import UrlAssetInput
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-
-
-class MediaAssetMetadata(Metadata):
-
-    def __init__(self, url: str):
-        super().__init__()
-        self._url = url
-
-    def to_model(self):
-        return PromptAssetMetadataInput(
-            _t="PromptAssetMetadataInput", asset=UrlAssetInput(_t="UrlAssetInput", url=self._url)
-        )

rapidata/rapidata_client/metadata/_private_text_metadata.py

@@ -1,17 +0,0 @@
-from rapidata.api_client.models.private_text_metadata_input import (
-    PrivateTextMetadataInput,
-)
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-
-
-class PrivateTextMetadata(Metadata):
-
-    def __init__(self, text: str, identifier: str = "private_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
-
-    def to_model(self):
-        return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier=self._identifier, text=self._text
-        )

rapidata/rapidata_client/metadata/_prompt_metadata.py

@@ -1,18 +0,0 @@
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
-
-
-class PromptMetadata(Metadata):
-    """The PromptMetadata class is used to display a prompt to the user."""
-
-    def __init__(self, prompt: str):
-        super().__init__()
-
-        if not isinstance(prompt, str):
-            raise ValueError("Prompt must be a string")
-        
-        self._prompt = prompt
-    
-
-    def to_model(self):
-        return PromptMetadataInput(_t="PromptMetadataInput", prompt=self._prompt)

rapidata/rapidata_client/metadata/_public_text_metadata.py

@@ -1,17 +0,0 @@
-from rapidata.api_client.models.public_text_metadata_input import (
-    PublicTextMetadataInput,
-)
-from rapidata.rapidata_client.metadata._base_metadata import Metadata
-
-
-class PublicTextMetadata(Metadata):
-
-    def __init__(self, text: str, identifier: str = "public_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
-
-    def to_model(self):
-        return PublicTextMetadataInput(
-            _t="PublicTextMetadataInput", identifier=self._identifier, text=self._text
-        )