rapidata 2.37.0__py3-none-any.whl → 3.0.0a8__py3-none-any.whl

rapidata/rapidata_client/filter/language_filter.py

@@ -1,37 +1,67 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.language_user_filter_model import (
-    LanguageUserFilterModel,
-)
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
 
-class LanguageFilter(RapidataFilter):
+class LanguageFilter(RapidataFilter, BaseModel):
     """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
     """
+
+    language_codes: list[str]
+
     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")
-
-        self.languages = language_codes
+        super().__init__(language_codes=language_codes)
+
+    @field_validator("language_codes")
+    @classmethod
+    def validate_language_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Language codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.lower():
+                logger.warning(
+                    f"Language code '{code}' should be lowercase. It will be lowercased automatically."
+                )
+            validated.append(code.lower())
+        return validated
 
     def _to_model(self):
-        return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_language_user_filter_model import (
+            IUserFilterModelLanguageUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelLanguageUserFilterModel(
+                _t="LanguageFilter",
+                languages=self.language_codes,
+            )
+        )
+
+    def _to_audience_model(self):
+        from rapidata.api_client.models.i_audience_filter import IAudienceFilter
+        from rapidata.api_client.models.i_audience_filter_language_audience_filter import (
+            IAudienceFilterLanguageAudienceFilter,
+        )
+
+        return IAudienceFilter(
+            actual_instance=IAudienceFilterLanguageAudienceFilter(
+                _t="LanguageFilter", languages=self.language_codes
+            )
+        )

rapidata/rapidata_client/filter/models/age_group.py

@@ -1,11 +1,14 @@
-from rapidata.api_client.models.age_group import AgeGroup as BackendAgeGroupModel
+from rapidata.api_client.models.age_user_filter_model_age_group import (
+    AgeUserFilterModelAgeGroup,
+)
 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,14 +16,13 @@ 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
-    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)
+    UNDER_18 = AgeUserFilterModelAgeGroup.ENUM_0_MINUS_17
+    BETWEEN_18_29 = AgeUserFilterModelAgeGroup.ENUM_18_MINUS_29
+    BETWEEN_30_39 = AgeUserFilterModelAgeGroup.ENUM_30_MINUS_39
+    BETWEEN_40_49 = AgeUserFilterModelAgeGroup.ENUM_40_MINUS_49
+    BETWEEN_50_64 = AgeUserFilterModelAgeGroup.ENUM_50_MINUS_64
+    OVER_65 = AgeUserFilterModelAgeGroup.ENUM_65_PLUS
 
+    def _to_backend_model(self) -> AgeUserFilterModelAgeGroup:
+        return AgeUserFilterModelAgeGroup(self.value)

rapidata/rapidata_client/filter/models/gender.py

@@ -1,19 +1,23 @@
 from enum import Enum
-from rapidata.api_client.models.gender import Gender as BackendGenderModel
+from rapidata.api_client.models.gender_user_filter_model_gender import (
+    GenderUserFilterModelGender,
+)
+
 
 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)
+    MALE = GenderUserFilterModelGender.MALE
+    FEMALE = GenderUserFilterModelGender.FEMALE
+    OTHER = GenderUserFilterModelGender.OTHER
+
+    def _to_backend_model(self) -> GenderUserFilterModelGender:
+        return GenderUserFilterModelGender(self.value)

rapidata/rapidata_client/filter/new_user_filter.py

@@ -1,13 +1,23 @@
+from __future__ import annotations
+
 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"
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_new_user_filter_model import (
+            IUserFilterModelNewUserFilterModel,
         )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelNewUserFilterModel(_t="NewUserFilter")
+        )
+
+    def _to_audience_model(self):
+        raise NotImplementedError("NewUserFilter is not supported for audiences")

rapidata/rapidata_client/filter/not_filter.py

@@ -1,30 +1,54 @@
-from typing import Any
+from __future__ import annotations
+
 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 pydantic import BaseModel, ConfigDict
 
 
-class NotFilter(RapidataFilter):
+class NotFilter(RapidataFilter, BaseModel):
     """A filter that negates another filter's condition.
     This class implements a logical NOT operation on a given filter, inverting its results.
 
     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.
     """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    filter: RapidataFilter
+
     def __init__(self, filter: RapidataFilter):
-        if not isinstance(filter, RapidataFilter):
-            raise ValueError("Filter must be a RapidataFilter object")
-        
-        self.filter = filter
+        super().__init__(filter=filter)
 
     def _to_model(self):
-        return NotUserFilterModel(_t="NotFilter", filter=AndUserFilterModelFiltersInner(self.filter._to_model()))
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_not_user_filter_model import (
+            IUserFilterModelNotUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelNotUserFilterModel(
+                _t="NotFilter",
+                filter=self.filter._to_model(),
+            )
+        )
+
+    def _to_audience_model(self):
+        from rapidata.api_client.models.i_audience_filter import IAudienceFilter
+        from rapidata.api_client.models.i_audience_filter_not_audience_filter import (
+            IAudienceFilterNotAudienceFilter,
+        )
+
+        return IAudienceFilter(
+            actual_instance=IAudienceFilterNotAudienceFilter(
+                _t="NotFilter", filter=self.filter._to_audience_model()
+            )
+        )

rapidata/rapidata_client/filter/or_filter.py

@@ -1,30 +1,55 @@
-from typing import Any
+from __future__ import annotations
+
 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 pydantic import BaseModel, ConfigDict
 
 
-class OrFilter(RapidataFilter):
+class OrFilter(RapidataFilter, BaseModel):
     """A filter that combines multiple filters with a logical OR operation.
     This class implements a logical OR operation on a list of filters, where the condition is met if any of the filters' conditions are met.
 
     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.
     """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    filters: list[RapidataFilter]
+
     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
+        super().__init__(filters=filters)
 
     def _to_model(self):
-        return OrUserFilterModel(_t="OrFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_or_user_filter_model import (
+            IUserFilterModelOrUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelOrUserFilterModel(
+                _t="OrFilter",
+                filters=[filter._to_model() for filter in self.filters],
+            )
+        )
+
+    def _to_audience_model(self):
+        from rapidata.api_client.models.i_audience_filter import IAudienceFilter
+        from rapidata.api_client.models.i_audience_filter_or_audience_filter import (
+            IAudienceFilterOrAudienceFilter,
+        )
+
+        return IAudienceFilter(
+            actual_instance=IAudienceFilterOrAudienceFilter(
+                _t="OrFilter",
+                filters=[filter._to_audience_model() for filter in self.filters],
+            )
+        )

rapidata/rapidata_client/filter/rapidata_filters.py

@@ -1,12 +1,11 @@
 from rapidata.rapidata_client.filter import (
-    AgeFilter, 
-    CountryFilter, 
-    GenderFilter, 
-    LanguageFilter, 
-    UserScoreFilter,
+    CountryFilter,
+    LanguageFilter,
     NotFilter,
     OrFilter,
-    AndFilter)
+    AndFilter,
+)
+
 
 class RapidataFilters:
     """RapidataFilters Classes
@@ -15,14 +14,11 @@ 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.
         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.
@@ -36,22 +32,20 @@ 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.
 
         ```python
-        from rapidata import AgeFilter, LanguageFilter, CountryFilter
-        filters=[~AgeFilter([AgeGroup.UNDER_18]), CountryFilter(["US"]) | (CountryFilter(["CA"]) & LanguageFilter(["en"]))]
+        from rapidata import LanguageFilter, CountryFilter
+        filters=[(CountryFilter(["US"]) & ~LanguageFilter(["fr"])) | (CountryFilter(["CA"]) & LanguageFilter(["en"]))]
         ```
 
-        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.
+        This would return users who are from the US and whose phones are not set to French or who are from Canada and whose phones are set to English.
     """
-    user_score = UserScoreFilter
-    age = AgeFilter 
-    country = CountryFilter
-    gender = GenderFilter
-    language = LanguageFilter
-    not_filter = NotFilter
-    or_filter = OrFilter
-    and_filter = AndFilter
+
+    Country = CountryFilter
+    Language = LanguageFilter
+    Not_filter = NotFilter
+    Or_filter = OrFilter
+    And_filter = AndFilter

rapidata/rapidata_client/filter/response_count_filter.py

@@ -1,12 +1,11 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.response_count_user_filter_model import (
-    ResponseCountUserFilterModel,
-)
 from rapidata.api_client.models.comparison_operator import ComparisonOperator
+from pydantic import BaseModel, ConfigDict
 
 
-class ResponseCountFilter(RapidataFilter):
+class ResponseCountFilter(RapidataFilter, BaseModel):
     """ResponseCountFilter Class
     Can be used to filter users based on the number of responses they have given on validation tasks with the specified dimension.
 
@@ -34,18 +33,45 @@ class ResponseCountFilter(RapidataFilter):
         This will filter users who have a response count greater than 10 for the "electrical" dimension.
     """
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    response_count: int
+    dimension: str
+    operator: ComparisonOperator
+
     def __init__(
         self, response_count: int, dimension: str, operator: ComparisonOperator
     ):
-
-        self.response_count = response_count
-        self.dimension = dimension
-        self.operator = operator
+        super().__init__(
+            response_count=response_count, dimension=dimension, operator=operator
+        )
 
     def _to_model(self):
-        return ResponseCountUserFilterModel(
-            _t="ResponseCountFilter",
-            responseCount=self.response_count,
-            dimension=self.dimension,
-            operator=self.operator,
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_response_count_user_filter_model import (
+            IUserFilterModelResponseCountUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelResponseCountUserFilterModel(
+                _t="ResponseCountFilter",
+                responseCount=self.response_count,
+                dimension=self.dimension,
+                operator=self.operator,
+            )
+        )
+
+    def _to_campaign_model(self):
+        from rapidata.api_client.models.i_campaign_filter import ICampaignFilter
+        from rapidata.api_client.models.i_campaign_filter_response_count_filter import (
+            ICampaignFilterResponseCountFilter,
+        )
+
+        return ICampaignFilter(
+            actual_instance=ICampaignFilterResponseCountFilter(
+                _t="ResponseCountFilter",
+                responseCount=self.response_count,
+                dimension=self.dimension,
+                operator=self.operator,
+            )
         )

rapidata/rapidata_client/filter/user_score_filter.py

@@ -1,42 +1,80 @@
-from typing import Any
+from __future__ import annotations
+
+from pydantic_core.core_schema import FieldValidationInfo
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.user_score_user_filter_model import (
-    UserScoreUserFilterModel,
-)
+from pydantic import BaseModel, field_validator, model_validator
 
 
-class UserScoreFilter(RapidataFilter):
+class UserScoreFilter(RapidataFilter, BaseModel):
     """UserScoreFilter Class
-    
+
     Can be used to filter who to target based on their user score.
-    
+
     Args:
         lower_bound (float): The lower bound of the user score.
         upper_bound (float): The upper bound of the user score.
         dimension (str): The dimension of the userScore to be considerd for the filter.
 
-    Example: 
+    Example:
         ```python
         UserScoreFilter(0.5, 0.9)
         ```
         This will only show the order to users that have a UserScore of >=0.5 and <=0.9
     """
-    def __init__(self, lower_bound: float = 0.0, upper_bound: float = 1.0, dimension: str | None = None):
-        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
-        self.dimension = dimension
+
+    lower_bound: float
+    upper_bound: float
+    dimension: str | None = None
+
+    def __init__(
+        self,
+        lower_bound: float = 0.0,
+        upper_bound: float = 1.0,
+        dimension: str | None = None,
+    ):
+        super().__init__(
+            lower_bound=lower_bound, upper_bound=upper_bound, dimension=dimension
+        )
+
+    @field_validator("lower_bound", "upper_bound")
+    @classmethod
+    def validate_bounds(cls, v: float, info: FieldValidationInfo) -> float:
+        if v < 0 or v > 1:
+            raise ValueError(f"{info.field_name} must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def validate_bounds_relationship(self) -> "UserScoreFilter":
+        if self.lower_bound >= self.upper_bound:
+            raise ValueError("lower_bound must be less than upper_bound")
+        return self
 
     def _to_model(self):
-        return UserScoreUserFilterModel(
-            _t="UserScoreFilter",
-            upperbound=self.upper_bound,
-            lowerbound=self.lower_bound,
-            dimension=self.dimension,
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_user_score_user_filter_model import (
+            IUserFilterModelUserScoreUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelUserScoreUserFilterModel(
+                _t="UserScoreFilter",
+                upperbound=self.upper_bound,
+                lowerbound=self.lower_bound,
+                dimension=self.dimension,
+            )
+        )
+
+    def _to_campaign_model(self):
+        from rapidata.api_client.models.i_campaign_filter import ICampaignFilter
+        from rapidata.api_client.models.i_campaign_filter_user_score_filter import (
+            ICampaignFilterUserScoreFilter,
+        )
+
+        return ICampaignFilter(
+            actual_instance=ICampaignFilterUserScoreFilter(
+                _t="UserScoreFilter",
+                upperbound=self.upper_bound,
+                lowerbound=self.lower_bound,
+                dimension=self.dimension if self.dimension else "global",
+            )
         )

rapidata/rapidata_client/job/__init__.py

@@ -0,0 +1,3 @@
+from .job_definition import JobDefinition
+from .job_manager import JobManager
+from .rapidata_job import RapidataJob