rapidata 1.10.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

rapidata/rapidata_client/filter/age_filter.py

@@ -1,16 +1,23 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
-from rapidata.api_client.models.age_group import AgeGroup
+from rapidata.rapidata_client.filter.models.age_group import AgeGroup
 
 
-class AgeFilter(Filter):
+class AgeFilter(RapidataFilter):
+    """AgeFilter Class
+    
+    Can be used to filter who to target based on age groups.
+    
+    
+    Args:
+        age_groups (list[AgeGroup]): List of age groups to filter by."""
 
     def __init__(self, age_groups: list[AgeGroup]):
         self.age_groups = age_groups
 
-    def to_model(self):
+    def _to_model(self):
         return AgeUserFilterModel(
             _t="AgeFilter",
-            ageGroups=self.age_groups,
+            ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
         )

rapidata/rapidata_client/filter/campaign_filter.py

@@ -1,16 +1,25 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.campaign_user_filter_model import (
     CampaignUserFilterModel,
 )
 
 
-class CampaignFilter(Filter):
+class CampaignFilter(RapidataFilter):
+    """CampaignFilter Class
+
+    Can be used to filter who to target based on campaign IDs.
+
+    This filter can only be used when directly in contact with Rapidata.
+    
+    Args:
+        campaign_ids (list[str]): List of campaign IDs to filter by.
+    """
 
     def __init__(self, campaign_ids: list[str]):
         self.campaign_ids = campaign_ids
 
-    def to_model(self):
+    def _to_model(self):
         return CampaignUserFilterModel(
             _t="CampaignFilter",
             campaignIds=self.campaign_ids,

rapidata/rapidata_client/filter/country_filter.py

@@ -1,9 +1,16 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
 
 
-class CountryFilter(Filter):
+class CountryFilter(RapidataFilter):
+    """CountryFilter Class
+
+    Can be used to filter who to target based on country codes.
+    
+    Args:
+        country_codes (list[str]): List of country codes (capizalized) to filter by.
+    """
 
     def __init__(self, country_codes: list[str]):
         # check that all characters in the country codes are uppercase
@@ -15,5 +22,5 @@ class CountryFilter(Filter):
 
         self.country_codes = country_codes
 
-    def to_model(self):
+    def _to_model(self):
         return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)

rapidata/rapidata_client/filter/gender_filter.py

@@ -1,16 +1,23 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
-from rapidata.api_client.models.gender import Gender
+from rapidata.rapidata_client.filter.models.gender import Gender
 
 
-class GenderFilter(Filter):
+class GenderFilter(RapidataFilter):
+    """GenderFilter Class
+    
+    Can be used to filter who to target based on their gender.
+    
+    
+    Args:
+        genders (list[Gender]): List of genders to filter by."""
 
     def __init__(self, genders: list[Gender]):
         self.genders = genders
 
-    def to_model(self):
+    def _to_model(self):
         return GenderUserFilterModel(
             _t="GenderFilter",
-            genders=self.genders,
+            genders=[gender._to_backend_model() for gender in self.genders],
         )

rapidata/rapidata_client/filter/language_filter.py

@@ -1,12 +1,19 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.language_user_filter_model import (
     LanguageUserFilterModel,
 )
 
 
-class LanguageFilter(Filter):
+class LanguageFilter(RapidataFilter):
+    """LanguageFilter Class
+    
+    Can be used to filter who to target based on language codes.
+    
+    example: LanguageFilter(["en", "de"]) -> will limit the order to be shown to only people who have their phone set to english or german
 
+    Args:
+        language_codes (list[str]): List of language codes to filter by."""
     def __init__(self, language_codes: list[str]):
         if not isinstance(language_codes, list):
             raise ValueError("Language codes must be a list")
@@ -14,8 +21,12 @@ class LanguageFilter(Filter):
         # check that all characters in the language codes are lowercase
         if not all([code.islower() for code in language_codes]):
             raise ValueError("Language codes must be lowercase")
+        
+        for code in language_codes:
+            if not len(code) == 2:
+                raise ValueError("Language codes must be two characters long")
 
         self.languages = language_codes
 
-    def to_model(self):
+    def _to_model(self):
         return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)

rapidata/rapidata_client/filter/models/age_group.py

@@ -0,0 +1,26 @@
+from rapidata.api_client.models.age_group import AgeGroup as BackendAgeGroupModel
+from enum import Enum
+
+class AgeGroup(Enum):
+    """AgeGroup Enum
+    
+    Represents the age group of a user. Used to filter who to target based on age groups.
+    
+    Attributes:
+        UNDER_18 (AgeGroup): Represents the age group of users under 18.
+        BETWEEN_18_29 (AgeGroup): Represents the age group of users between 18 and 29.
+        BETWEEN_30_39 (AgeGroup): Represents the age group of users between 30 and 39.
+        BETWEEN_40_49 (AgeGroup): Represents the age group of users between 40 and 49.
+        BETWEEN_50_64 (AgeGroup): Represents the age group of users between 50 and 64.
+        OVER_65 (AgeGroup): Represents the age group of users over 65."""
+    
+    UNDER_18 = BackendAgeGroupModel.ENUM_0_MINUS_17
+    BETWEEN_18_29 = BackendAgeGroupModel.ENUM_18_MINUS_29
+    BETWEEN_30_39 = BackendAgeGroupModel.ENUM_30_MINUS_39
+    BETWEEN_40_49 = BackendAgeGroupModel.ENUM_40_MINUS_49
+    BETWEEN_50_64 = BackendAgeGroupModel.ENUM_50_MINUS_64
+    OVER_65 = BackendAgeGroupModel.ENUM_65_PLUS
+
+    def _to_backend_model(self) -> BackendAgeGroupModel:
+        return BackendAgeGroupModel(self.value)
+

rapidata/rapidata_client/filter/models/gender.py

@@ -0,0 +1,19 @@
+from enum import Enum
+from rapidata.api_client.models.gender import Gender as BackendGenderModel
+
+class Gender(Enum):
+    """Gender Enum
+    
+    Represents the gender of a user. Used to filter who to target based on genders.
+    
+    Attributes:
+        MALE (Gender): Represents the Male gender.
+        FEMALE (Gender): Represents the Female gender.
+        OTHER (Gender): Represents any other gender.
+    """
+    MALE = BackendGenderModel.MALE
+    FEMALE = BackendGenderModel.FEMALE
+    OTHER = BackendGenderModel.OTHER
+
+    def _to_backend_model(self) -> BackendGenderModel:
+        return BackendGenderModel(self.value)

rapidata/rapidata_client/filter/rapidata_filters.py

@@ -0,0 +1,31 @@
+from rapidata.rapidata_client.filter import (
+    AgeFilter, 
+    CampaignFilter, 
+    CountryFilter, 
+    GenderFilter, 
+    LanguageFilter, 
+    UserScoreFilter)
+
+class RapidataFilters:
+    """RapidataFilters Classes
+
+    These filters can be added to the order to specifically target a certain group of users.
+
+    Note that adding multiple filters to the same order will result in a logical AND operation between the filters.
+
+    Warning: this might significantly slow down the number of responses you receive.
+    
+    Attributes:
+        user_score (UserScoreFilter): The UserScoreFilter instance.
+        age (AgeFilter): The AgeFilter instance.
+        campaign (CampaignFilter): The CampaignFilter instance.
+        country (CountryFilter): The CountryFilter instance.
+        campaign (CampaignFilter): The CampaignFilter instance
+        gender (GenderFilter): The GenderFilter instance.
+        language (LanguageFilter): The LanguageFilter instance."""
+    user_score = UserScoreFilter
+    age = AgeFilter 
+    campaign = CampaignFilter
+    country = CountryFilter
+    gender = GenderFilter
+    language = LanguageFilter

rapidata/rapidata_client/filter/user_score_filter.py

@@ -1,17 +1,33 @@
 from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.user_score_user_filter_model import (
     UserScoreUserFilterModel,
 )
 
 
-class UserScoreFilter(Filter):
+class UserScoreFilter(RapidataFilter):
+    """UserScoreFilter Class
+    
+    Can be used to filter who to target based on their user score.
+    
+    example: UserScoreFilter(0.5, 0.9) -> will only show the order to users that have a UserScore of >=0.5 and <=0.9
 
-    def __init__(self, lower_bound: int = 0, upper_bound: int = 1):
+    Args:
+        lower_bound (float): The lower bound of the user score.
+        upper_bound (float): The upper bound of the user score.
+    """
+    def __init__(self, lower_bound: float = 0.0, upper_bound: float = 1.0):
+        if lower_bound < 0 or lower_bound > 1:
+            raise ValueError("The lower bound must be between 0 and 1.")
+        if upper_bound < 0 or upper_bound > 1:
+            raise ValueError("The upper bound must be between 0 and 1.")
+        if lower_bound >= upper_bound:
+            raise ValueError("The lower bound must be less than the upper bound.")
+        
         self.upper_bound = upper_bound
         self.lower_bound = lower_bound
 
-    def to_model(self):
+    def _to_model(self):
         return UserScoreUserFilterModel(
             _t="UserScoreFilter",
             upperbound=self.upper_bound,

rapidata/rapidata_client/metadata/__init__.py

@@ -1,5 +1,5 @@
-from .base_metadata import Metadata
-from .private_text_metadata import PrivateTextMetadata
-from .public_text_metadata import PublicTextMetadata
-from .prompt_metadata import PromptMetadata
-from .select_words_metadata import SelectWordsMetadata
+from ._base_metadata import Metadata
+from ._private_text_metadata import PrivateTextMetadata
+from ._public_text_metadata import PublicTextMetadata
+from ._prompt_metadata import PromptMetadata
+from ._select_words_metadata import SelectWordsMetadata

rapidata/rapidata_client/metadata/{base_metadata.py → _base_metadata.py}

@@ -3,10 +3,11 @@ from typing import Any
 
 
 class Metadata:
+    """The base class for all Rapidata Metadata."""
 
     def __init__(self, identifier: str):
         self._identifier = identifier
 
     @abstractmethod
-    def to_model(self) -> Any:
+    def _to_model(self) -> Any:
         pass

rapidata/rapidata_client/metadata/{private_text_metadata.py → _private_text_metadata.py}

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

rapidata/rapidata_client/metadata/{prompt_metadata.py → _prompt_metadata.py}

@@ -1,8 +1,9 @@
-from rapidata.rapidata_client.metadata.base_metadata import Metadata
+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, identifier: str = "prompt"):
         super().__init__(identifier=identifier)
@@ -13,5 +14,5 @@ class PromptMetadata(Metadata):
         self._prompt = prompt
     
 
-    def to_model(self):
+    def _to_model(self):
         return PromptMetadataInput(_t="PromptMetadataInput", identifier=self._identifier, prompt=self._prompt)

rapidata/rapidata_client/metadata/{public_text_metadata.py → _public_text_metadata.py}

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

rapidata/rapidata_client/metadata/{select_words_metadata.py → _select_words_metadata.py}

@@ -1,17 +1,18 @@
 from rapidata.api_client.models.transcription_metadata_input import (
     TranscriptionMetadataInput,
 )
-from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.metadata._base_metadata import Metadata
 
 
 class SelectWordsMetadata(Metadata):
+    """SelectWordsMetadata Class is used to define the Sentence that will be display to the user."""
 
     def __init__(self, select_words: str, identifier: str = "transcription"):
         super().__init__(identifier=identifier)
         self.identifier = identifier
         self.select_words = select_words
 
-    def to_model(self):
+    def _to_model(self):
         return TranscriptionMetadataInput(
             _t="TranscriptionMetadataInput",
             identifier=self.identifier,

rapidata/rapidata_client/{dataset/rapidata_dataset.py → order/_rapidata_dataset.py}

@@ -1,5 +1,4 @@
 from itertools import zip_longest
-import os
 
 from rapidata.api_client.models.datapoint_metadata_model import DatapointMetadataModel
 from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
@@ -8,14 +7,14 @@ from rapidata.api_client.models.datapoint_metadata_model_metadata_inner import (
 from rapidata.api_client.models.upload_text_sources_to_dataset_model import (
     UploadTextSourcesToDatasetModel,
 )
-from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.metadata._base_metadata import Metadata
 from rapidata.rapidata_client.assets import TextAsset, MediaAsset, MultiAsset
 from rapidata.service import LocalFileService
 from rapidata.service.openapi_service import OpenAPIService
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
 
-from typing import cast
+from typing import cast, Sequence
 
 
 class RapidataDataset:
@@ -25,7 +24,7 @@ class RapidataDataset:
         self.openapi_service = openapi_service
         self.local_file_service = LocalFileService()
 
-    def add_texts(
+    def _add_texts(
         self,
         text_assets: list[TextAsset] | list[MultiAsset],
         max_workers: int = 10,
@@ -63,17 +62,17 @@ class RapidataDataset:
                     future.result()  # This will raise any exceptions that occurred during execution
                     pbar.update(1)
 
-    def add_media_from_paths(
+    def _add_media_from_paths(
         self,
         media_paths: list[MediaAsset] |  list[MultiAsset], # where multiasset is a list of media assets
-        metadata: list[Metadata] | None = None,
+        metadata: Sequence[Metadata] | None = None,
         max_workers: int = 10,
     ):
         if metadata is not None and len(metadata) != len(media_paths):
             raise ValueError(
                 "metadata must be None or have the same length as media_paths"
             )
-
+        
         for media_path in media_paths:
             if isinstance(media_path, MultiAsset):
                 assert all(
@@ -88,7 +87,7 @@ class RapidataDataset:
             else:
                 raise ValueError(f"Unsupported asset type: {type(media_asset)}")
 
-            meta_model = meta.to_model() if meta else None
+            meta_model = meta._to_model() if meta else None
             model = DatapointMetadataModel(
                 datasetId=self.dataset_id,
                 metadata=(