rapidata 2.37.0__py3-none-any.whl → 2.39.0__py3-none-any.whl

rapidata/rapidata_client/config/upload_config.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+
+
+class UploadConfig(BaseModel):
+    """
+    Holds the configuration for the upload process.
+
+    Attributes:
+        maxWorkers (int): The maximum number of worker threads for processing media paths. Defaults to 10.
+        maxRetries (int): The maximum number of retries for failed uploads. Defaults to 3.
+    """
+
+    maxWorkers: int = Field(default=10)
+    maxRetries: int = Field(default=3)

rapidata/rapidata_client/datapoints/_datapoint.py

@@ -24,7 +24,7 @@ from rapidata.rapidata_client.datapoints.metadata._media_asset_metadata import (
     MediaAssetMetadata,
 )
 from rapidata.rapidata_client.datapoints.metadata._prompt_metadata import PromptMetadata
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
 
 
 class Datapoint:

rapidata/rapidata_client/datapoints/assets/__init__.py

@@ -2,6 +2,7 @@
 
 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

rapidata/rapidata_client/datapoints/assets/_base_asset.py

@@ -3,9 +3,11 @@
 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/datapoints/assets/_media_asset.py

@@ -17,7 +17,7 @@ from pydantic import StrictStr, StrictBytes
 import logging
 from functools import cached_property
 from rapidata.rapidata_client.datapoints.assets._sessions import SessionManager
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
 from rapidata.rapidata_client.datapoints.assets.constants import (
     ALLOWED_IMAGE_EXTENSIONS,
     ALLOWED_MEDIA_EXTENSIONS,

rapidata/rapidata_client/datapoints/assets/_sessions.py

@@ -18,8 +18,8 @@ class SessionManager:
             requests.Session: A singleton requests session with retry logic.
         """
         if cls._session is None:
-            max_retries: int = rapidata_config.uploadMaxRetries
-            max_workers: int = rapidata_config.maxUploadWorkers
+            max_retries: int = rapidata_config.upload.maxRetries
+            max_workers: int = rapidata_config.upload.maxWorkers
             cls._session = requests.Session()
             retries = Retry(
                 total=max_retries,

rapidata/rapidata_client/datapoints/assets/_text_asset.py

@@ -24,11 +24,11 @@ class TextAsset(BaseAsset):
         """
         if not isinstance(text, str):
             raise ValueError(f"Text must be a string, got {type(text)}")
-        
+
         self.text = text
 
     def __str__(self) -> str:
         return f"TextAsset(text={self.text})"
-    
+
     def __repr__(self) -> str:
         return f"TextAsset(text={self.text})"

rapidata/rapidata_client/datapoints/assets/data_type_enum.py

@@ -1,6 +1,6 @@
 class RapidataDataTypes:
     # deprecated use Literal["media", "text"] instead
-    MEDIA = "media" # any form of image, video or audio
+    MEDIA = "media"  # any form of image, video or audio
     TEXT = "text"
 
     @classmethod

rapidata/rapidata_client/datapoints/metadata/_media_asset_metadata.py

@@ -1,7 +1,11 @@
-from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
+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.datapoints.metadata._base_metadata import Metadata
-from rapidata.api_client.models.prompt_asset_metadata_input_asset import PromptAssetMetadataInputAsset
+from rapidata.api_client.models.prompt_asset_metadata_input_asset import (
+    PromptAssetMetadataInputAsset,
+)
 
 
 class MediaAssetMetadata(Metadata):
@@ -12,11 +16,8 @@ class MediaAssetMetadata(Metadata):
 
     def to_model(self):
         return PromptAssetMetadataInput(
-            _t="PromptAssetMetadataInput", 
+            _t="PromptAssetMetadataInput",
             asset=PromptAssetMetadataInputAsset(
-                actual_instance=UrlAssetInput(
-                    _t="UrlAssetInput", 
-                    url=self._url
-                )
-            )
+                actual_instance=UrlAssetInput(_t="UrlAssetInput", url=self._url)
+            ),
         )

rapidata/rapidata_client/datapoints/metadata/_prompt_metadata.py

@@ -10,9 +10,8 @@ class PromptMetadata(Metadata):
 
         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/demographic/demographic_manager.py

@@ -1,29 +1,31 @@
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.datapoints.assets import MediaAsset
-from rapidata.api_client.models.create_demographic_rapid_model import CreateDemographicRapidModel
+from rapidata.api_client.models.create_demographic_rapid_model import (
+    CreateDemographicRapidModel,
+)
 from rapidata.api_client.models.classify_payload import ClassifyPayload
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
+
 
 class DemographicManager:
     def __init__(self, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         logger.debug("DemographicManager initialized")
-    
-    def create_demographic_rapid(self, 
-                                 instruction: str,
-                                 answer_options: list[str],
-                                 datapoint: str,
-                                 key: str):
-        
+
+    def create_demographic_rapid(
+        self, instruction: str, answer_options: list[str], datapoint: str, key: str
+    ):
+
         media = MediaAsset(path=datapoint)
         model = CreateDemographicRapidModel(
             key=key,
             payload=ClassifyPayload(
                 _t="ClassifyPayload",
                 possibleCategories=answer_options,
-                title=instruction
-            )
+                title=instruction,
+            ),
+        )
+
+        self._openapi_service.rapid_api.rapid_demographic_post(
+            model=model, file=[media.to_file()]
         )
-        
-        self._openapi_service.rapid_api.rapid_demographic_post(model=model, file=[media.to_file()])
-        

rapidata/rapidata_client/filter/_base_filter.py

@@ -13,9 +13,9 @@ class RapidataFilter:
         """Enable the | operator to create OrFilter combinations."""
         if not isinstance(other, RapidataFilter):
             return NotImplemented
-        
+
         from rapidata.rapidata_client.filter.or_filter import OrFilter
-        
+
         # If self is already an OrFilter, extend its filters list
         if isinstance(self, OrFilter):
             if isinstance(other, OrFilter):
@@ -33,9 +33,9 @@ class RapidataFilter:
         """Enable the & operator to create AndFilter combinations."""
         if not isinstance(other, RapidataFilter):
             return NotImplemented
-        
+
         from rapidata.rapidata_client.filter.and_filter import AndFilter
-        
+
         # If self is already an AndFilter, extend its filters list
         if isinstance(self, AndFilter):
             if isinstance(other, AndFilter):
@@ -52,10 +52,16 @@ class RapidataFilter:
     def __invert__(self):
         """Enable the ~ operator to create NotFilter negations."""
         from rapidata.rapidata_client.filter.not_filter import NotFilter
-        
+
         # If self is already a NotFilter, return the original filter (double negation)
         if isinstance(self, NotFilter):
             return self.filter
         # Create a new NotFilter
         else:
             return NotFilter(self)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"

rapidata/rapidata_client/filter/age_filter.py

@@ -6,10 +6,10 @@ from rapidata.rapidata_client.filter.models.age_group import AgeGroup
 
 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."""
 
@@ -21,3 +21,9 @@ class AgeFilter(RapidataFilter):
             _t="AgeFilter",
             ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
         )
+
+    def __str__(self) -> str:
+        return f"AgeFilter(age_groups={self.age_groups})"
+
+    def __repr__(self) -> str:
+        return f"AgeFilter(age_groups={self.age_groups!r})"

rapidata/rapidata_client/filter/and_filter.py

@@ -1,7 +1,9 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.and_user_filter_model import AndUserFilterModel
-from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class AndFilter(RapidataFilter):
@@ -10,21 +12,34 @@ class AndFilter(RapidataFilter):
 
     Args:
         filters (list[RapidataFilter]): A list of filters to be combined with AND.
-        
+
     Example:
         ```python
         from rapidata import AndFilter, LanguageFilter, CountryFilter
 
-        AndFilter([LanguageFilter(["en"]), CountryFilter(["US"])]) 
+        AndFilter([LanguageFilter(["en"]), CountryFilter(["US"])])
         ```
 
         This will match users who have their phone set to English AND are located in the United States.
     """
+
     def __init__(self, filters: list[RapidataFilter]):
         if not all(isinstance(filter, RapidataFilter) for filter in filters):
             raise ValueError("Filters must be a RapidataFilter object")
-        
+
         self.filters = filters
 
     def _to_model(self):
-        return AndUserFilterModel(_t="AndFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])
+        return AndUserFilterModel(
+            _t="AndFilter",
+            filters=[
+                AndUserFilterModelFiltersInner(filter._to_model())
+                for filter in self.filters
+            ],
+        )
+
+    def __str__(self) -> str:
+        return f"AndFilter(filters={self.filters})"
+
+    def __repr__(self) -> str:
+        return f"AndFilter(filters={self.filters!r})"

rapidata/rapidata_client/filter/campaign_filter.py

@@ -11,7 +11,7 @@ class CampaignFilter(RapidataFilter):
     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.
     """
@@ -24,3 +24,9 @@ class CampaignFilter(RapidataFilter):
             _t="CampaignFilter",
             campaignIds=self.campaign_ids,
         )
+
+    def __str__(self) -> str:
+        return f"CampaignFilter(campaign_ids={self.campaign_ids})"
+
+    def __repr__(self) -> str:
+        return f"CampaignFilter(campaign_ids={self.campaign_ids!r})"

rapidata/rapidata_client/filter/country_filter.py

@@ -7,7 +7,7 @@ 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 (capitalized) to filter by.
     """
@@ -16,7 +16,7 @@ class CountryFilter(RapidataFilter):
         # check that all characters in the country codes are uppercase
         if not isinstance(country_codes, list):
             raise ValueError("Country codes must be a list")
-        
+
         if not all([code.isupper() for code in country_codes]):
             raise ValueError("Country codes must be uppercase")
 
@@ -24,3 +24,9 @@ class CountryFilter(RapidataFilter):
 
     def _to_model(self):
         return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)
+
+    def __str__(self) -> str:
+        return f"CountryFilter(country_codes={self.country_codes})"
+
+    def __repr__(self) -> str:
+        return f"CountryFilter(country_codes={self.country_codes!r})"

rapidata/rapidata_client/filter/custom_filter.py

@@ -8,10 +8,10 @@ class CustomFilter(RapidataFilter):
 
     Can be used to filter who to target based on custom filters.
 
-    Ought to be used with contact to Rapidata. 
-    
+    Ought to be used with contact to Rapidata.
+
     Warning: If identifier does not exist, order will not get any responses.
-    
+
     Args:
         identifier (str): Identifier of the custom filter.
         values (list[str]): List of values to filter by.
@@ -27,3 +27,9 @@ class CustomFilter(RapidataFilter):
             identifier=self.identifier,
             values=self.values,
         )
+
+    def __str__(self) -> str:
+        return f"CustomFilter(identifier={self.identifier}, values={self.values})"
+
+    def __repr__(self) -> str:
+        return f"CustomFilter(identifier={self.identifier!r}, values={self.values!r})"

rapidata/rapidata_client/filter/gender_filter.py

@@ -6,10 +6,10 @@ from rapidata.rapidata_client.filter.models.gender import Gender
 
 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."""
 
@@ -21,3 +21,9 @@ class GenderFilter(RapidataFilter):
             _t="GenderFilter",
             genders=[gender._to_backend_model() for gender in self.genders],
         )
+
+    def __str__(self) -> str:
+        return f"GenderFilter(genders={self.genders})"
+
+    def __repr__(self) -> str:
+        return f"GenderFilter(genders={self.genders!r})"

rapidata/rapidata_client/filter/language_filter.py

@@ -7,26 +7,27 @@ from rapidata.api_client.models.language_user_filter_model import (
 
 class LanguageFilter(RapidataFilter):
     """LanguageFilter Class
-    
+
     Can be used to filter who to target based on language codes.
 
     Args:
         language_codes (list[str]): List of language codes to filter by.
-            
-    Example: 
+
+    Example:
         ```python
         LanguageFilter(["en", "de"])
         ```
         This will limit the order to be shown to only people who have their phone set to english or german
     """
+
     def __init__(self, language_codes: list[str]):
         if not isinstance(language_codes, list):
             raise ValueError("Language codes must be a list")
-        
+
         # 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")
@@ -35,3 +36,9 @@ class LanguageFilter(RapidataFilter):
 
     def _to_model(self):
         return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)
+
+    def __str__(self):
+        return f"LanguageFilter({self.languages})"
+
+    def __repr__(self):
+        return f"LanguageFilter({self.languages})"

rapidata/rapidata_client/filter/models/age_group.py

@@ -1,11 +1,12 @@
 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.
@@ -13,7 +14,7 @@ class AgeGroup(Enum):
         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
@@ -23,4 +24,3 @@ class AgeGroup(Enum):
 
     def _to_backend_model(self) -> BackendAgeGroupModel:
         return BackendAgeGroupModel(self.value)
-

rapidata/rapidata_client/filter/models/gender.py

@@ -1,16 +1,18 @@
 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

rapidata/rapidata_client/filter/new_user_filter.py

@@ -1,13 +1,12 @@
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.new_user_filter_model import NewUserFilterModel
 
+
 class NewUserFilter(RapidataFilter):
     """NewUserFilter Class
-    
+
     Can be used to filter new users.
     """
 
     def _to_model(self):
-        return NewUserFilterModel(
-            _t="NewUserFilter"
-        )
+        return NewUserFilterModel(_t="NewUserFilter")

rapidata/rapidata_client/filter/not_filter.py

@@ -1,7 +1,9 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.not_user_filter_model import NotUserFilterModel
-from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class NotFilter(RapidataFilter):
@@ -10,21 +12,31 @@ class NotFilter(RapidataFilter):
 
     Args:
         filter (RapidataFilter): The filter whose condition should be negated.
-        
+
     Example:
         ```python
         from rapidata import NotFilter, LanguageFilter
 
-        NotFilter(LanguageFilter(["en"])) 
+        NotFilter(LanguageFilter(["en"]))
         ```
 
         This will limit the order to be shown to only people who have their phone set to a language other than English.
     """
+
     def __init__(self, filter: RapidataFilter):
         if not isinstance(filter, RapidataFilter):
             raise ValueError("Filter must be a RapidataFilter object")
-        
+
         self.filter = filter
 
     def _to_model(self):
-        return NotUserFilterModel(_t="NotFilter", filter=AndUserFilterModelFiltersInner(self.filter._to_model()))
+        return NotUserFilterModel(
+            _t="NotFilter",
+            filter=AndUserFilterModelFiltersInner(self.filter._to_model()),
+        )
+
+    def __str__(self) -> str:
+        return f"NotFilter(filter={self.filter})"
+
+    def __repr__(self) -> str:
+        return f"NotFilter(filter={self.filter!r})"

rapidata/rapidata_client/filter/or_filter.py

@@ -1,7 +1,9 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.or_user_filter_model import OrUserFilterModel
-from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
+from rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class OrFilter(RapidataFilter):
@@ -10,21 +12,34 @@ class OrFilter(RapidataFilter):
 
     Args:
         filters (list[RapidataFilter]): A list of filters to be combined with OR.
-        
+
     Example:
         ```python
         from rapidata import OrFilter, LanguageFilter, CountryFilter
 
-        OrFilter([LanguageFilter(["en"]), CountryFilter(["US"])]) 
+        OrFilter([LanguageFilter(["en"]), CountryFilter(["US"])])
         ```
 
         This will match users who either have their phone set to English OR are located in the United States.
     """
+
     def __init__(self, filters: list[RapidataFilter]):
         if not all(isinstance(filter, RapidataFilter) for filter in filters):
             raise ValueError("Filters must be a RapidataFilter object")
-        
+
         self.filters = filters
 
     def _to_model(self):
-        return OrUserFilterModel(_t="OrFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])
+        return OrUserFilterModel(
+            _t="OrFilter",
+            filters=[
+                AndUserFilterModelFiltersInner(filter._to_model())
+                for filter in self.filters
+            ],
+        )
+
+    def __str__(self) -> str:
+        return f"OrFilter(filters={self.filters})"
+
+    def __repr__(self) -> str:
+        return f"OrFilter(filters={self.filters!r})"

rapidata/rapidata_client/filter/rapidata_filters.py

@@ -1,12 +1,14 @@
 from rapidata.rapidata_client.filter import (
-    AgeFilter, 
-    CountryFilter, 
-    GenderFilter, 
-    LanguageFilter, 
+    AgeFilter,
+    CountryFilter,
+    GenderFilter,
+    LanguageFilter,
     UserScoreFilter,
     NotFilter,
     OrFilter,
-    AndFilter)
+    AndFilter,
+)
+
 
 class RapidataFilters:
     """RapidataFilters Classes
@@ -15,9 +17,9 @@ class RapidataFilters:
 
     Note that adding multiple filters to the same order will result in a logical AND operation between the filters.
 
-    Warning: 
+    Warning:
         This might significantly slow down the number of responses you receive.
-    
+
     Attributes:
         user_score (UserScoreFilter): Filters for users with a specific user score.
         age (AgeFilter): Filters for users with a specific age.
@@ -36,7 +38,7 @@ class RapidataFilters:
 
         This ensures the order is only shown to users in the US and Germany whose phones are set to English.
 
-    Info:        
+    Info:
         The OR, AND and NOT filter support the |, & and ~ operators respectively.
         The AND is additionally given by the elements in the list.
 
@@ -47,8 +49,9 @@ class RapidataFilters:
 
         This would return users who are not under 18 years old and are from the US or who are from Canada and whose phones are set to English.
     """
+
     user_score = UserScoreFilter
-    age = AgeFilter 
+    age = AgeFilter
     country = CountryFilter
     gender = GenderFilter
     language = LanguageFilter

rapidata/rapidata_client/filter/response_count_filter.py

@@ -49,3 +49,9 @@ class ResponseCountFilter(RapidataFilter):
             dimension=self.dimension,
             operator=self.operator,
         )
+
+    def __str__(self) -> str:
+        return f"ResponseCountFilter(response_count={self.response_count}, dimension={self.dimension}, operator={self.operator})"
+
+    def __repr__(self) -> str:
+        return f"ResponseCountFilter(response_count={self.response_count!r}, dimension={self.dimension!r}, operator={self.operator!r})"