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

rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -0,0 +1,20 @@
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.rapidata_client.order.dataset._rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+
+
+class FailedUploadException(Exception):
+    """Custom error class for Failed Uploads to the Rapidata order."""
+
+    def __init__(
+        self,
+        dataset: RapidataDataset,
+        order: RapidataOrder,
+        failed_uploads: list[Datapoint],
+    ):
+        self.dataset = dataset
+        self.order = order
+        self.failed_uploads = failed_uploads
+
+    def __str__(self) -> str:
+        return f"Failed to upload {self.failed_uploads}"

rapidata/rapidata_client/filter/__init__.py

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

@@ -1,21 +1,22 @@
 from abc import abstractmethod
-from typing import Any
+
+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) -> Any:
+    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):
@@ -29,13 +30,33 @@ class RapidataFilter:
         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(self)
+            return NotFilter(filter=self)

rapidata/rapidata_client/filter/age_filter.py

@@ -1,23 +1,34 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
 from rapidata.rapidata_client.filter.models.age_group import AgeGroup
+from pydantic import BaseModel, ConfigDict
 
 
-class AgeFilter(RapidataFilter):
+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):
-        return AgeUserFilterModel(
-            _t="AgeFilter",
-            ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
+        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,
+        )
+
+        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,26 +1,34 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.campaign_user_filter_model import (
-    CampaignUserFilterModel,
-)
+from pydantic import BaseModel
 
 
-class CampaignFilter(RapidataFilter):
+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):
-        return CampaignUserFilterModel(
-            _t="CampaignFilter",
-            campaignIds=self.campaign_ids,
+        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,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelCampaignUserFilterModel(
+                _t="CampaignFilter",
+                campaignIds=self.campaign_ids,
+            )
         )

rapidata/rapidata_client/filter/country_filter.py

@@ -1,26 +1,48 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
 
-class CountryFilter(RapidataFilter):
+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)
 
-        self.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
 
     def _to_model(self):
-        return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)
+        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,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelCountryUserFilterModel(
+                _t="CountryFilter", countries=self.country_codes
+            )
+        )

rapidata/rapidata_client/filter/custom_filter.py

@@ -1,29 +1,39 @@
-from typing import Any
+from __future__ import annotations
+
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
-from rapidata.api_client.models.custom_user_filter_model import CustomUserFilterModel
+from pydantic import BaseModel
 
 
-class CustomFilter(RapidataFilter):
+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. 
-    
+    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]):
-        self.identifier = identifier
-        self.values = values
+        super().__init__(identifier=identifier, values=values)
 
     def _to_model(self):
-        return CustomUserFilterModel(
-            _t="CustomFilter",
-            identifier=self.identifier,
-            values=self.values,
+        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,23 +1,35 @@
-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],
+            )
         )

rapidata/rapidata_client/filter/language_filter.py

@@ -1,37 +1,55 @@
-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,
+            )
+        )

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,20 @@
+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")
         )

rapidata/rapidata_client/filter/not_filter.py

@@ -1,30 +1,42 @@
-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(),
+            )
+        )