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

rapidata/rapidata_client/filter/__init__.py

@@ -1,7 +1,13 @@
-from .base_filter import Filter
+from ._base_filter import RapidataFilter
 from .age_filter import AgeFilter, AgeGroup
 from .campaign_filter import CampaignFilter
 from .country_filter import CountryFilter
 from .gender_filter import GenderFilter, Gender
 from .language_filter import LanguageFilter
 from .user_score_filter import UserScoreFilter
+from .custom_filter import CustomFilter
+from .not_filter import NotFilter
+from .or_filter import OrFilter
+from .and_filter import AndFilter
+from .response_count_filter import ResponseCountFilter
+from .new_user_filter import NewUserFilter

rapidata/rapidata_client/filter/_base_filter.py

@@ -0,0 +1,62 @@
+from abc import abstractmethod
+
+from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+
+
+class RapidataFilter:
+    """The base class for all Rapidata Filters."""
+
+    @abstractmethod
+    def _to_model(self) -> IUserFilterModel:
+        pass
+
+    def __or__(self, other):
+        """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):
+                return OrFilter(self.filters + other.filters)
+            else:
+                return OrFilter(self.filters + [other])
+        # If other is an OrFilter, prepend self to its filters
+        elif isinstance(other, OrFilter):
+            return OrFilter([self] + other.filters)
+        # Neither is an OrFilter, create a new one
+        else:
+            return OrFilter([self, other])
+
+    def __and__(self, other):
+        """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):
+                return AndFilter(self.filters + other.filters)
+            else:
+                return AndFilter(self.filters + [other])
+        # If other is an AndFilter, prepend self to its filters
+        elif isinstance(other, AndFilter):
+            return AndFilter([self] + other.filters)
+        # Neither is an AndFilter, create a new one
+        else:
+            return AndFilter([self, other])
+
+    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(filter=self)

rapidata/rapidata_client/filter/age_filter.py

@@ -1,16 +1,34 @@
-from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
-from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
-from rapidata.api_client.models.age_group import AgeGroup
+from __future__ import annotations
 
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.rapidata_client.filter.models.age_group import AgeGroup
+from pydantic import BaseModel, ConfigDict
 
-class AgeFilter(Filter):
+
+class AgeFilter(RapidataFilter, BaseModel):
+    """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."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    age_groups: list[AgeGroup]
 
     def __init__(self, age_groups: list[AgeGroup]):
-        self.age_groups = age_groups
+        super().__init__(age_groups=age_groups)
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_age_user_filter_model import (
+            IUserFilterModelAgeUserFilterModel,
+        )
 
-    def to_model(self):
-        return AgeUserFilterModel(
-            _t="AgeFilter",
-            ageGroups=self.age_groups,
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelAgeUserFilterModel(
+                _t="AgeFilter",
+                ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
+            )
         )

rapidata/rapidata_client/filter/and_filter.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, ConfigDict
+
+
+class AndFilter(RapidataFilter, BaseModel):
+    """A filter that combines multiple filters with a logical AND operation.
+    This class implements a logical AND operation on a list of filters, where the condition is met if all of the filters' conditions are met.
+
+    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"])])
+        ```
+
+        This will match users who have their phone set to English AND are located in the United States.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    filters: list[RapidataFilter]
+
+    def __init__(self, filters: list[RapidataFilter]):
+        super().__init__(filters=filters)
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_and_user_filter_model import (
+            IUserFilterModelAndUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelAndUserFilterModel(
+                _t="AndFilter",
+                filters=[filter._to_model() for filter in self.filters],
+            )
+        )

rapidata/rapidata_client/filter/campaign_filter.py

@@ -1,17 +1,34 @@
-from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
-from rapidata.api_client.models.campaign_user_filter_model import (
-    CampaignUserFilterModel,
-)
+from __future__ import annotations
 
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel
 
-class CampaignFilter(Filter):
+
+class CampaignFilter(RapidataFilter, BaseModel):
+    """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.
+    """
+
+    campaign_ids: list[str]
 
     def __init__(self, campaign_ids: list[str]):
-        self.campaign_ids = campaign_ids
+        super().__init__(campaign_ids=campaign_ids)
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_campaign_user_filter_model import (
+            IUserFilterModelCampaignUserFilterModel,
+        )
 
-    def to_model(self):
-        return CampaignUserFilterModel(
-            _t="CampaignFilter",
-            campaignIds=self.campaign_ids,
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelCampaignUserFilterModel(
+                _t="CampaignFilter",
+                campaignIds=self.campaign_ids,
+            )
         )

rapidata/rapidata_client/filter/country_filter.py

@@ -1,19 +1,48 @@
-from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
-from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
+from __future__ import annotations
 
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
-class CountryFilter(Filter):
+
+class CountryFilter(RapidataFilter, BaseModel):
+    """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.
+    """
+
+    country_codes: list[str]
 
     def __init__(self, country_codes: list[str]):
-        # 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")
+        super().__init__(country_codes=country_codes)
+
+    @field_validator("country_codes")
+    @classmethod
+    def validate_country_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Country codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.upper():
+                logger.warning(
+                    f"Country code '{code}' should be uppercase. It will be uppercased automatically."
+                )
+            validated.append(code.upper())
+        return validated
 
-        self.country_codes = country_codes
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_country_user_filter_model import (
+            IUserFilterModelCountryUserFilterModel,
+        )
 
-    def to_model(self):
-        return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelCountryUserFilterModel(
+                _t="CountryFilter", countries=self.country_codes
+            )
+        )

rapidata/rapidata_client/filter/custom_filter.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel
+
+
+class CustomFilter(RapidataFilter, BaseModel):
+    """CustomFilter Class
+
+    Can be used to filter who to target based on custom filters.
+
+    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.
+    """
+
+    identifier: str
+    values: list[str]
+
+    def __init__(self, identifier: str, values: list[str]):
+        super().__init__(identifier=identifier, values=values)
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_custom_user_filter_model import (
+            IUserFilterModelCustomUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelCustomUserFilterModel(
+                _t="CustomFilter",
+                identifier=self.identifier,
+                values=self.values,
+            )
+        )

rapidata/rapidata_client/filter/gender_filter.py

@@ -1,16 +1,35 @@
-from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
-from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
-from rapidata.api_client.models.gender import Gender
+from __future__ import annotations
 
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.rapidata_client.filter.models.gender import Gender
+from pydantic import BaseModel, ConfigDict
 
-class GenderFilter(Filter):
+
+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):
+        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,
+        )
 
-    def to_model(self):
-        return GenderUserFilterModel(
-            _t="GenderFilter",
-            genders=self.genders,
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelGenderUserFilterModel(
+                _t="GenderFilter",
+                genders=[gender._to_backend_model() for gender in self.genders],
+            )
         )

rapidata/rapidata_client/filter/language_filter.py

@@ -1,21 +1,55 @@
-from typing import Any
-from rapidata.rapidata_client.filter.base_filter import Filter
-from rapidata.api_client.models.language_user_filter_model import (
-    LanguageUserFilterModel,
-)
+from __future__ import annotations
 
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
-class LanguageFilter(Filter):
+
+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:
+        ```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")
+        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
 
-        self.languages = language_codes
+    def _to_model(self):
+        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,
+        )
 
-    def to_model(self):
-        return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelLanguageUserFilterModel(
+                _t="LanguageFilter",
+                languages=self.language_codes,
+            )
+        )

rapidata/rapidata_client/filter/models/age_group.py

@@ -0,0 +1,28 @@
+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.
+        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 = 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

@@ -0,0 +1,23 @@
+from enum import Enum
+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 = 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

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+
+
+class NewUserFilter(RapidataFilter):
+    """NewUserFilter Class
+
+    Can be used to filter new users.
+    """
+
+    def _to_model(self):
+        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")
+        )

rapidata/rapidata_client/filter/not_filter.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, ConfigDict
+
+
+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"]))
+        ```
+
+        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):
+        super().__init__(filter=filter)
+
+    def _to_model(self):
+        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(),
+            )
+        )

rapidata/rapidata_client/filter/or_filter.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, ConfigDict
+
+
+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"])])
+        ```
+
+        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]):
+        super().__init__(filters=filters)
+
+    def _to_model(self):
+        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],
+            )
+        )

rapidata/rapidata_client/filter/rapidata_filters.py

@@ -0,0 +1,60 @@
+from rapidata.rapidata_client.filter import (
+    AgeFilter,
+    CountryFilter,
+    GenderFilter,
+    LanguageFilter,
+    UserScoreFilter,
+    NotFilter,
+    OrFilter,
+    AndFilter,
+)
+
+
+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): 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.
+        and_filter (AndFilter): Combines multiple filters with a logical AND operation.
+
+    Example:
+        ```python
+        from rapidata import CountryFilter, LanguageFilter
+        filters=[CountryFilter(["US", "DE"]), LanguageFilter(["en"])]
+        ```
+
+        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 AgeFilter, LanguageFilter, CountryFilter
+        filters=[~AgeFilter([AgeGroup.UNDER_18]), CountryFilter(["US"]) | (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.
+    """
+
+    user_score = UserScoreFilter
+    age = AgeFilter
+    country = CountryFilter
+    gender = GenderFilter
+    language = LanguageFilter
+    not_filter = NotFilter
+    or_filter = OrFilter
+    and_filter = AndFilter