rapidata 1.8.3__py3-none-any.whl → 2.44.4__py3-none-any.whl

{rapidata-1.8.3.dist-info → rapidata-2.44.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

rapidata/constants.py

@@ -1 +0,0 @@
-MAX_TIME_IN_SECONDS_FOR_ONE_SESSION=25

rapidata/rapidata_client/assets/__init__.py

@@ -1,8 +0,0 @@
-"""Assets Package
-
-This package provides classes for different types of assets, including MediaAsset, TextAsset, and MultiAsset.
-"""
-from .base_asset import BaseAsset
-from .media_asset import MediaAsset
-from .text_asset import TextAsset
-from .multi_asset import MultiAsset

rapidata/rapidata_client/assets/base_asset.py

@@ -1,11 +0,0 @@
-"""Base Asset Module
-
-Defines the BaseAsset class, which serves as the abstract base class for all asset types.
-"""
-
-class BaseAsset:
-    """BaseAsset Class
-
-    An abstract base class for different types of assets. This class is intended to be subclassed by specific asset types.
-    """
-    pass

rapidata/rapidata_client/assets/media_asset.py

@@ -1,88 +0,0 @@
-"""Media Asset Module
-
-Defines the MediaAsset class for handling media file paths within assets.
-"""
-
-import os
-from io import BytesIO
-from rapidata.rapidata_client.assets.base_asset import BaseAsset
-import requests
-import re
-
-class MediaAsset(BaseAsset):
-    """MediaAsset Class
-
-    Represents a media asset by storing the file path.
-
-    Args:
-        path (str): The file system path to the media asset.
-
-    Raises:
-        FileNotFoundError: If the provided file path does not exist.
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize a MediaAsset instance.
-
-        Args:
-            path (str): The file system path to the media asset or a link to an image.
-
-        Raises:
-            FileNotFoundError: If the provided file path does not exist.
-        """
-        if not isinstance(path, str):
-            raise ValueError("Media must be a string, either a local file path or an image URL")
-
-        if re.match(r'^https?://', path):
-            self.path = MediaAsset.get_image_bytes(path)
-            self.name = path.split('/')[-1]
-            if not self.name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
-                self.name += '.jpg'
-            return
-        
-        if not os.path.exists(path):
-            raise FileNotFoundError(f"File not found: {path}, please provide a valid local file path.")
-        
-        self.path: str | bytes = path
-        self.name = path
-    
-    def set_custom_name(self, name: str) -> 'MediaAsset':
-        """
-        Set a custom name for the media asset, will only work with links.
-
-        Args:
-            name (str): The custom name to be set.
-        """
-        if isinstance(self.path, bytes):
-            if not name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
-                name += '.jpg'
-            self.name = name
-        else:
-            raise ValueError("Custom name can only be set for links.")
-        return self
-
-    @staticmethod
-    def get_image_bytes(image_url: str) -> bytes:
-        """
-        Downloads an image from a URL and converts it to bytes.
-        Validates that the URL points to an actual image.
-        
-        Args:
-            image_url (str): URL of the image
-            
-        Returns:
-            bytes: Image data as bytes
-            
-        Raises:
-            ValueError: If URL doesn't point to an image
-            requests.exceptions.RequestException: If download fails
-        """
-        response = requests.get(image_url)
-        response.raise_for_status()
-        
-        content_type = response.headers.get('content-type', '')
-        if not content_type.startswith('image/'):
-            raise ValueError(f'URL does not point to an image. Content-Type: {content_type}')
-        
-        return BytesIO(response.content).getvalue()

rapidata/rapidata_client/assets/multi_asset.py

@@ -1,55 +0,0 @@
-"""Multi Asset Module
-
-Defines the MultiAsset class for handling multiple BaseAsset instances.
-"""
-
-from rapidata.rapidata_client.assets.base_asset import BaseAsset
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset
-from typing import Iterator, Sequence
-
-
-class MultiAsset(BaseAsset):
-    """MultiAsset Class
-
-    Represents a collection of multiple BaseAsset instances.
-
-    Args:
-        assets (List[BaseAsset]): A list of BaseAsset instances to be managed together.
-    """
-
-    def __init__(self, assets: Sequence[BaseAsset]) -> None:
-        """
-        Initialize a MultiAsset instance.
-
-        Args:
-            assets (List[BaseAsset]): A list of BaseAsset instances to be managed together.
-        """
-        if len(assets) != 2:
-            raise ValueError("Assets must come in pairs for comparison tasks.")
-        
-        for asset in assets:
-            if not isinstance(asset, (TextAsset, MediaAsset)):
-                raise TypeError("All assets must be a TextAsset or MediaAsset.")    
-        
-        if not all(isinstance(asset, type(assets[0])) for asset in assets):
-            raise ValueError("All assets must be of the same type.")
-        
-        self.assets = assets
-        
-    def __len__(self) -> int:
-        """
-        Get the number of assets in the MultiAsset.
-
-        Returns:
-            int: The number of assets.
-        """
-        return len(self.assets)
-
-    def __iter__(self) -> Iterator[BaseAsset]:
-        """
-        Return an iterator over the assets in the MultiAsset.
-
-        Returns:
-            Iterator[BaseAsset]: An iterator over the assets.
-        """
-        return iter(self.assets)

rapidata/rapidata_client/assets/text_asset.py

@@ -1,28 +0,0 @@
-"""Text Asset Module
-
-Defines the TextAsset class for handling textual data within assets.
-"""
-
-from rapidata.rapidata_client.assets.base_asset import BaseAsset
-
-
-class TextAsset(BaseAsset):
-    """TextAsset Class
-
-    Represents a textual asset.
-
-    Args:
-        text (str): The text content of the asset.
-    """
-
-    def __init__(self, text: str):
-        """
-        Initialize a TextAsset instance.
-
-        Args:
-            text (str): The textual content of the asset.
-        """
-        if not isinstance(text, str):
-            raise ValueError("Text must be a string")
-        
-        self.text = text

rapidata/rapidata_client/country_codes/__init__.py

@@ -1 +0,0 @@
-from .country_codes import CountryCodes

rapidata/rapidata_client/country_codes/country_codes.py

@@ -1,19 +0,0 @@
-class CountryCodes:
-
-    ENGLISH_SPEAKING = [
-        "AU",
-        "BE",
-        "CA",
-        "DK",
-        "FI",
-        "IE",
-        "LU",
-        "NL",
-        "NZ",
-        "NO",
-        "SG",
-        "SE",
-        "GB",
-        "US",
-    ]
-    GERMAN_SPEAKING = ["AT", "DE"]

rapidata/rapidata_client/dataset/rapid_builders/__init__.py

@@ -1,4 +0,0 @@
-from .classify_rapid_builders import ClassifyRapidQuestionBuilder
-from .compare_rapid_builders import CompareRapidCriteriaBuilder
-from .transcription_rapid_builders import TranscriptionRapidInstructionBuilder
-from .base_rapid_builder import BaseRapidBuilder

rapidata/rapidata_client/dataset/rapid_builders/base_rapid_builder.py

@@ -1,33 +0,0 @@
-from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.dataset.rapid_builders import ClassifyRapidQuestionBuilder, CompareRapidCriteriaBuilder, TranscriptionRapidInstructionBuilder
-
-class BaseRapidBuilder:
-    """Base class for creating different types of rapids.
-    
-    This class provides factory methods to create specific rapids
-    """
-
-    def classify_rapid(self):
-        """Creates a classification rapid.
-        
-        Returns:
-            ClassifyRapidQuestionBuilder: A builder for creating the classification question.
-        """
-        return ClassifyRapidQuestionBuilder()
-    
-    def compare_rapid(self):    
-        """Creates a compare rapid.
-        
-        Returns:
-            CompareRapidCriteriaBuilder: A builder for creating a comparison criteria.
-        """
-        return CompareRapidCriteriaBuilder()
-    
-    def transcription_rapid(self):
-        """Creates a transcription rapid.
-        
-        Returns:
-            TranscriptionRapidInstructionBuilder: A builder for creating the transcription instruction.
-        """
-        return TranscriptionRapidInstructionBuilder()
-        

rapidata/rapidata_client/dataset/rapid_builders/classify_rapid_builders.py

@@ -1,166 +0,0 @@
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import ClassificationRapid
-
-class ClassifyRapidBuilder:
-    """Final builder class for classification rapid.
-    
-    This class handles the final construction of a classification rapid with all required parameters.
-    """
-    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset):
-        self._question = question
-        self._options = options
-        self._truths = truths
-        self._asset = asset
-        self._metadata = []
-
-    def prompt(self, prompt: str):
-        """Add a prompt to provide additional context for the classification task.
-        
-        Args:
-            prompt (str): Additional instructions or context
-            
-        Returns:
-            ClassifyRapidBuilder: The builder instance for method chaining
-        """
-        self._metadata.append(PromptMetadata(prompt))
-        return self
-    
-    def build(self):
-        """Constructs and returns the final classification rapid.
-        
-        Returns:
-            ClassificationRapid: The constructed classification rapid 
-        """
-        return ClassificationRapid(
-            question=self._question,
-            options=self._options,
-            truths=self._truths,
-            asset=self._asset,
-            metadata=self._metadata
-        )
-    
-class ClassifyRapidTruthBuilder:
-    """Builder class for the truths of the classification rapid.
-
-    This adds the truths to the classification rapid.
-    """
-    def __init__(self, question: str, options: list[str], asset: MediaAsset | TextAsset):
-        self._question = question
-        self._options = options
-        self._asset = asset
-        self._truths = None
-
-    def truths(self, truths: list[str]):
-        """Set the truths for the classification rapid.
-
-        Args:
-            truths (list[str]): The correct answers for the classification task"""
-        
-        if not isinstance(truths, list) or not all(isinstance(truth, str) for truth in truths):
-            raise ValueError("Truths must be a list of strings")
-        
-        if not all(truth in self._options for truth in truths):
-            raise ValueError("Truths must be one of the selectable options")
-        
-        self._truths = truths
-        return self._build()
-    
-    def _build(self):
-        if self._truths is None:
-            raise ValueError("Truths are required")
-        return ClassifyRapidBuilder(
-            question=self._question,
-            options=self._options,
-            asset=self._asset,
-            truths=self._truths,
-        )
-    
-class ClassifyRapidMediaBuilder:
-    """Builder class for the media asset of the classification rapid.
-
-    This class adds the media asset to the classification rapid.
-    """
-    def __init__(self, question: str, options: list[str]):
-        self._question = question
-        self._options = options
-        self._asset: MediaAsset | TextAsset | None = None
-
-    def media(self, media: str):
-        """Set the media asset for the classification rapid.
-
-        Args:
-            media (str): A local file path or an image URL. The image will be displayed with the classification task"""        
-        self._asset = MediaAsset(media)
-
-        return self._build()
-
-    def text(self, text: str):
-        """Set the text asset for the classification rapid.
-
-        Args:
-            text (str): The text to be displayed with the classification task"""
-        self._asset = TextAsset(text)
-
-        return self._build()
-
-    def _build(self):
-        if self._asset is None:
-            raise ValueError("Assets are required")
-        
-        return ClassifyRapidTruthBuilder(
-            question=self._question,
-            options=self._options,
-            asset=self._asset,
-        )
-
-class ClassifyRapidOptionsBuilder:
-    def __init__(self, question: str):
-        self._question = question
-        self._options = None
-
-    def options(self, options: list[str]):
-        """Set the options for the classification rapid.
-
-        Args:
-            options (list[str]): The selectable options for the classification task"""
-
-        if not isinstance(options, list) or not all(isinstance(option, str) for option in options):
-            raise ValueError("Options must be a list of strings")
-        
-        self._options = options
-        return self._build()
-    
-    def _build(self):
-        if self._options is None:
-            raise ValueError("Options are required")
-        
-        return ClassifyRapidMediaBuilder(
-            question=self._question,
-            options=self._options,
-        )
-
-
-class ClassifyRapidQuestionBuilder:
-    def __init__(self):
-        self._question = None
-
-    def question(self, question: str):
-        """Set the question for the classification rapid.
-
-        Args:
-            question (str): The question to be answered by the classification task"""
-        
-        if not isinstance(question, str):
-            raise ValueError("Question must be a string")
-        
-        self._question = question
-        return self._build()
-    
-    def _build(self):
-        if self._question is None:
-            raise ValueError("Question is required")
-        
-        return ClassifyRapidOptionsBuilder(
-            question=self._question,
-        )

rapidata/rapidata_client/dataset/rapid_builders/compare_rapid_builders.py

@@ -1,145 +0,0 @@
-from rapidata.rapidata_client.assets import MultiAsset, TextAsset, MediaAsset
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.rapidata_client.dataset.rapid_builders.rapids import CompareRapid
-import re
-
-class CompareRapidBuilder:
-    """Final builder class for comparison rapid.
-    
-    This class handles the final construction of a comparison rapid with all required parameters.
-    """
-    def __init__(self, criteria: str, truth: str, asset: MultiAsset):
-        """Initialize the comparison rapid builder.
-        
-        Args:
-            criteria (str): The criteria for comparison
-            truth (str): The correct answer
-            asset (MultiAsset): Collection of assets to be compared
-        """
-        self._criteria = criteria
-        self._truth = truth
-        self._asset = asset
-        self._metadata = []
-
-    def prompt(self, prompt: str):
-        """Add a prompt to provide additional context for the comparison.
-        
-        Args:
-            prompt (str): Additional instructions or context
-            
-        Returns:
-            CompareRapidBuilder: The builder instance for method chaining
-        """
-        self._metadata.append(PromptMetadata(prompt))
-        return self
-
-    def build(self):
-        """Constructs and returns the final comparison rapid.
-        
-        Returns:
-            CompareRapid: The constructed comparison rapid
-        """
-        return CompareRapid(
-            criteria=self._criteria,
-            asset=self._asset,
-            truth=self._truth,
-            metadata=self._metadata
-        )
-
-class CompareRapidTruthBuilder:
-    """Builder class for the truth of the comparison rapid.
-
-    This adds the truth to the comparison rapid.    
-    """
-    def __init__(self, criteria: str, asset: MultiAsset):
-        self._criteria = criteria
-        self._asset = asset
-        self._truth = None
-    
-    def truth(self, truth: str):
-        """Set the truth for the comparison rapid.
-
-        Args:
-            truth (str): The correct answer for the comparison task. Is the string of the correct media/text asset"""
-        
-        if not isinstance(truth, str):
-            raise ValueError("Truth must be a string.")
-        
-        self._truth = MediaAsset(truth).name
-        
-        return self._build()
-    
-    def _build(self):
-        if self._truth is None:
-            raise ValueError("Truth is required")
-        
-        return CompareRapidBuilder(
-            criteria=self._criteria,
-            asset=self._asset,
-            truth=self._truth,
-        )
-
-class CompareRapidAssetBuilder:
-    """Builder class for the asset of the comparison rapid.
-
-    This adds the asset to the comparison rapid.
-    """
-    def __init__(self, criteria: str):
-        self._criteria = criteria
-        self._asset: MultiAsset | None = None
-
-    def media(self, medias: list[str]):
-        """Set the media assets for the comparison rapid.
-
-        Args:
-            medias (list[str]): The local file paths or links of the media assets to be compared"""
-        
-        media_assets = [MediaAsset(media) for media in medias]
-        self._asset = MultiAsset(media_assets)
-        return self._build()
-    
-    def text(self, texts: list[str]):
-        """Set the text assets for the comparison rapid.
-
-        Args:
-            texts (list[str]): The texts to be compared"""
-        
-        text_assets = [TextAsset(text) for text in texts]
-        self._asset = MultiAsset(text_assets)
-        return self._build()
-    
-    def _build(self):
-        if self._asset is None:
-            raise ValueError("Asset is required")
-
-        return CompareRapidTruthBuilder(
-            criteria=self._criteria,
-            asset=self._asset,
-        )
-
-class CompareRapidCriteriaBuilder:
-    """Builder class for the criteria of the comparison rapid.
-
-    This adds the criteria to the comparison rapid."""
-    def __init__(self):
-        self._criteria = None
-
-    def criteria(self, criteria: str):
-        """Set the criteria for the comparison rapid.
-
-        Args:
-            criteria (str): The criteria for comparison"""
-        
-        if not isinstance(criteria, str):
-            raise ValueError("Criteria must be a string")
-        
-        self._criteria = criteria
-        return self._build()
-
-    def _build(self):
-        if self._criteria is None:
-            raise ValueError("Criteria is required")
-
-        return CompareRapidAssetBuilder(
-            criteria=self._criteria,
-        )

rapidata/rapidata_client/dataset/rapid_builders/rapids.py

@@ -1,32 +0,0 @@
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
-from rapidata.rapidata_client.metadata import Metadata
-
-class Rapid:
-    pass
-
-class ClassificationRapid(Rapid):
-    """A classification rapid. This represents the question, options, truths, asset and metadata that will be given to the user."""
-    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset, metadata: list[Metadata]):
-        self.question = question
-        self.options = options
-        self.truths = truths
-        self.asset = asset
-        self.metadata = metadata
-
-class CompareRapid(Rapid):
-    """A comparison rapid. This represents the criteria, asset, truth and metadata that will be given to the user."""
-    def __init__(self, criteria: str, truth: str, asset: MultiAsset, metadata: list[Metadata]):
-        self.criteria = criteria
-        self.asset = asset
-        self.truth = truth
-        self.metadata = metadata
-
-class TranscriptionRapid(Rapid):
-    """A transcription rapid. This represents the instruction, truths, asset, transcription and strict grading that will be given to the user."""
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, transcription: str, strict_grading: bool):
-        self.instruction = instruction
-        self.truths = truths
-        self.asset = asset
-        self.transcription = transcription
-        self.strict_grading = strict_grading
-