rapidata 2.23.2__py3-none-any.whl → 3.0.1__py3-none-any.whl

rapidata/rapidata_client/filter/device_filter.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.rapidata_client.filter.models.device_type import DeviceType
+from pydantic import BaseModel, ConfigDict
+
+
+class DeviceFilter(RapidataFilter, BaseModel):
+    """DeviceFilter Class
+
+    Can be used to filter who to target based on their device type.
+
+    Args:
+        device_types (list[DeviceType]): List of device types to filter by.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    device_types: list[DeviceType]
+
+    def __init__(self, device_types: list[DeviceType]):
+        super().__init__(device_types=device_types)
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_device_user_filter_model import (
+            IUserFilterModelDeviceUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelDeviceUserFilterModel(
+                _t="DeviceFilter",
+                deviceTypes=[dt._to_backend_model() for dt in self.device_types],
+            )
+        )
+
+    def _to_audience_model(self):
+        raise NotImplementedError("DeviceFilter is not supported for audiences")

rapidata/rapidata_client/filter/gender_filter.py

@@ -1,23 +1,38 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
 from rapidata.rapidata_client.filter.models.gender import Gender
+from pydantic import BaseModel, ConfigDict
 
 
-class GenderFilter(RapidataFilter):
+class GenderFilter(RapidataFilter, BaseModel):
     """GenderFilter Class
-    
+
     Can be used to filter who to target based on their gender.
-    
-    
+
+
     Args:
         genders (list[Gender]): List of genders to filter by."""
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    genders: list[Gender]
+
     def __init__(self, genders: list[Gender]):
-        self.genders = genders
+        super().__init__(genders=genders)
 
     def _to_model(self):
-        return GenderUserFilterModel(
-            _t="GenderFilter",
-            genders=[gender._to_backend_model() for gender in self.genders],
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_gender_user_filter_model import (
+            IUserFilterModelGenderUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelGenderUserFilterModel(
+                _t="GenderFilter",
+                genders=[gender._to_backend_model() for gender in self.genders],
+            )
         )
+
+    def _to_audience_model(self):
+        raise NotImplementedError("GenderFilter is not supported for audiences")

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/device_type.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class DeviceType(Enum):
+    """DeviceType Enum
+
+    Represents the device type of a user. Used to filter who to target based on device types.
+
+    Attributes:
+        UNKNOWN (DeviceType): Unknown device type.
+        PHONE (DeviceType): Phone device.
+        TABLET (DeviceType): Tablet device.
+    """
+
+    UNKNOWN = "Unknown"
+    PHONE = "Phone"
+    TABLET = "Tablet"
+
+    def _to_backend_model(self) -> str:
+        return 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.create_order_model_user_filters_inner import CreateOrderModelUserFiltersInner
+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=CreateOrderModelUserFiltersInner(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.create_order_model_user_filters_inner import CreateOrderModelUserFiltersInner
+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=[CreateOrderModelUserFiltersInner(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, 
-    CampaignFilter, 
-    CountryFilter, 
-    GenderFilter, 
-    LanguageFilter, 
-    UserScoreFilter,
+    CountryFilter,
+    LanguageFilter,
     NotFilter,
-    OrFilter)
+    OrFilter,
+    AndFilter,
+)
+
 
 class RapidataFilters:
     """RapidataFilters Classes
@@ -15,18 +14,15 @@ 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): The UserScoreFilter instance.
-        age (AgeFilter): The AgeFilter instance.
-        campaign (CampaignFilter): The CampaignFilter instance.
-        country (CountryFilter): The CountryFilter instance.
-        gender (GenderFilter): The GenderFilter instance.
-        language (LanguageFilter): The LanguageFilter instance.
-        not_filter (NotFilter): The NotFilter instance.
-        or_filter (OrFilter): The OrFilter instance.
+        country (CountryFilter): Filters for users with a specific country.
+        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.
+        and_filter (AndFilter): Combines multiple filters with a logical AND operation.
 
     Example:
         ```python
@@ -35,12 +31,21 @@ class RapidataFilters:
         ```
 
         This ensures the order is only shown to users in the US and Germany whose phones are set to English.
+
+    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 LanguageFilter, CountryFilter
+        filters=[(CountryFilter(["US"]) & ~LanguageFilter(["fr"])) | (CountryFilter(["CA"]) & LanguageFilter(["en"]))]
+        ```
+
+        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 
-    campaign = CampaignFilter
-    country = CountryFilter
-    gender = GenderFilter
-    language = LanguageFilter
-    not_filter = NotFilter
-    or_filter = OrFilter
+
+    Country = CountryFilter
+    Language = LanguageFilter
+    Not_filter = NotFilter
+    Or_filter = OrFilter
+    And_filter = AndFilter

rapidata/rapidata_client/filter/response_count_filter.py

@@ -1,22 +1,23 @@
-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.
 
         response_count (int): The number of user responses to filter by.
         dimension (str): The dimension to apply the filter on (e.g. "default", "electrical", etc.).
         operator (str): The comparison operator to use. Must be one of:
-            - "Equal"
-            - "NotEqual"
-            - "LessThan"
-            - "LessThanOrEqual"
-            - "GreaterThan"
-            - "GreaterThanOrEqual"
+            - ComparisonOperator.EQUAL
+            - ComparisonOperator.NOTEQUAL
+            - ComparisonOperator.LESSTHAN
+            - ComparisonOperator.LESSTHANOREQUAL
+            - ComparisonOperator.GREATERTHAN
+            - ComparisonOperator.GREATERTHANOREQUAL
 
     Raises:
         ValueError: If `response_count` is not an integer.
@@ -27,20 +28,50 @@ class ResponseCountFilter(RapidataFilter):
         ```python
         from rapidata import ResponseCountFilter
 
-        filter = ResponseCountFilter(response_count=10, dimension="electrical", operator="GreaterThan")
+        filter = ResponseCountFilter(response_count=10, dimension="electrical", operator=ComparisonOperator.GREATERTHAN)
         ```
         This will filter users who have a response count greater than 10 for the "electrical" dimension.
     """
 
-    def __init__(self, response_count: int, dimension: str, operator: str):
-        if operator not in ["Equal", "NotEqual", "LessThan", "LessThanOrEqual", "GreaterThan", "GreaterThanOrEqual"]:
-            raise ValueError("Operator must be one of Equal, NotEqual, LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.response_count = response_count
-        self.dimension = dimension
-        self.operator = operator
+    response_count: int
+    dimension: str
+    operator: ComparisonOperator
+
+    def __init__(
+        self, response_count: int, dimension: str, operator: ComparisonOperator
+    ):
+        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,
+            )
         )