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

rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -1,17 +1,11 @@
-from typing import cast
-from rapidata.api_client.models.file_asset_model import FileAssetModel
-from rapidata.api_client.models.get_failed_datapoints_result import (
-    GetFailedDatapointsResult,
-)
-from rapidata.api_client.models.multi_asset_model import MultiAssetModel
-from rapidata.api_client.models.original_filename_metadata_model import (
-    OriginalFilenameMetadataModel,
-)
-from rapidata.api_client.models.source_url_metadata_model import SourceUrlMetadataModel
-from rapidata.rapidata_client.datapoints.assets import MediaAsset, MultiAsset
+from __future__ import annotations
 from rapidata.rapidata_client.datapoints._datapoint import Datapoint
-from rapidata.rapidata_client.order._rapidata_dataset import RapidataDataset
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from rapidata.rapidata_client.dataset._rapidata_dataset import RapidataDataset
+    from rapidata.rapidata_client.job.job_definition import JobDefinition
+    from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 
 
 class FailedUploadException(Exception):
@@ -20,63 +14,14 @@ class FailedUploadException(Exception):
     def __init__(
         self,
         dataset: RapidataDataset,
-        order: RapidataOrder,
         failed_uploads: list[Datapoint],
+        order: Optional[RapidataOrder] = None,
+        job: Optional[JobDefinition] = None,
     ):
         self.dataset = dataset
         self.order = order
+        self.job = job
         self.failed_uploads = failed_uploads
 
     def __str__(self) -> str:
         return f"Failed to upload {self.failed_uploads}"
-
-
-def _parse_failed_uploads(failed_uploads: GetFailedDatapointsResult) -> list[Datapoint]:
-    failed_datapoints = failed_uploads.datapoints
-    if not failed_datapoints:
-        return []
-    if isinstance(failed_datapoints[0].asset.actual_instance, FileAssetModel):
-        failed_assets = [
-            MediaAsset(
-                __get_asset_name(cast(FileAssetModel, datapoint.asset.actual_instance))
-            )
-            for datapoint in failed_datapoints
-        ]
-    elif isinstance(failed_datapoints[0].asset.actual_instance, MultiAssetModel):
-        failed_assets = []
-        backend_assets = [
-            cast(MultiAssetModel, failed_upload.asset.actual_instance).assets
-            for failed_upload in failed_datapoints
-        ]
-        for assets in backend_assets:
-            failed_assets.append(
-                MultiAsset(
-                    [
-                        MediaAsset(
-                            __get_asset_name(
-                                cast(FileAssetModel, asset.actual_instance)
-                            )
-                        )
-                        for asset in assets
-                        if isinstance(asset.actual_instance, FileAssetModel)
-                    ]
-                )
-            )
-    else:
-        raise ValueError(
-            f"Unsupported asset type: {type(failed_datapoints[0].asset.actual_instance)}"
-        )
-
-    return [Datapoint(asset=asset) for asset in failed_assets]
-
-
-def __get_asset_name(failed_datapoint: FileAssetModel) -> str:
-    metadata = failed_datapoint.metadata
-    if "sourceUrl" in metadata:
-        return cast(SourceUrlMetadataModel, metadata["sourceUrl"].actual_instance).url
-    elif "originalFilename" in metadata:
-        return cast(
-            OriginalFilenameMetadataModel, metadata["originalFilename"].actual_instance
-        ).original_filename
-    else:
-        return ""

rapidata/rapidata_client/filter/_backend_filter_mapper.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rapidata.api_client.models.i_audience_filter import (
+        IAudienceFilter,
+    )
+    from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+
+
+class BackendFilterMapper:
+    """Maps backend API filter models to client-side RapidataFilter instances."""
+
+    # Cache for imported modules to avoid repeated imports
+    _imported_backend_filters: dict[str, Any] = {}
+    _imported_client_filters: dict[str, Any] = {}
+
+    @classmethod
+    def _ensure_backend_filters_imported(cls) -> None:
+        """Lazy import all backend filter models."""
+        if cls._imported_backend_filters:
+            return
+
+        from rapidata.api_client.models.i_audience_filter_and_audience_filter import (
+            IAudienceFilterAndAudienceFilter,
+        )
+        from rapidata.api_client.models.i_audience_filter_or_audience_filter import (
+            IAudienceFilterOrAudienceFilter,
+        )
+        from rapidata.api_client.models.i_audience_filter_not_audience_filter import (
+            IAudienceFilterNotAudienceFilter,
+        )
+        from rapidata.api_client.models.i_audience_filter_country_audience_filter import (
+            IAudienceFilterCountryAudienceFilter,
+        )
+        from rapidata.api_client.models.i_audience_filter_language_audience_filter import (
+            IAudienceFilterLanguageAudienceFilter,
+        )
+
+        cls._imported_backend_filters = {
+            "AndAudienceFilter": IAudienceFilterAndAudienceFilter,
+            "OrAudienceFilter": IAudienceFilterOrAudienceFilter,
+            "NotAudienceFilter": IAudienceFilterNotAudienceFilter,
+            "CountryAudienceFilter": IAudienceFilterCountryAudienceFilter,
+            "LanguageAudienceFilter": IAudienceFilterLanguageAudienceFilter,
+        }
+
+    @classmethod
+    def _ensure_client_filters_imported(cls) -> None:
+        """Lazy import all client filter models."""
+        if cls._imported_client_filters:
+            return
+
+        from rapidata.rapidata_client.filter.and_filter import AndFilter
+        from rapidata.rapidata_client.filter.country_filter import CountryFilter
+        from rapidata.rapidata_client.filter.language_filter import LanguageFilter
+        from rapidata.rapidata_client.filter.not_filter import NotFilter
+        from rapidata.rapidata_client.filter.or_filter import OrFilter
+
+        cls._imported_client_filters = {
+            "AndFilter": AndFilter,
+            "CountryFilter": CountryFilter,
+            "LanguageFilter": LanguageFilter,
+            "NotFilter": NotFilter,
+            "OrFilter": OrFilter,
+        }
+
+    @classmethod
+    def backend_filter_from_rapidata_filter(
+        cls, filter: IAudienceFilter
+    ) -> RapidataFilter:
+        """Convert a backend API filter model to a client-side RapidataFilter instance.
+
+        Args:
+            filter: Backend API filter wrapped in IAudienceFilter
+
+        Returns:
+            RapidataFilter: Client-side filter instance
+        """
+        cls._ensure_backend_filters_imported()
+        cls._ensure_client_filters_imported()
+
+        actual_instance = filter.actual_instance
+        if actual_instance is None:
+            raise ValueError("Filter actual_instance is None")
+
+        # Import backend models for isinstance checks
+        BackendAndAudienceFilter = cls._imported_backend_filters["AndAudienceFilter"]
+        BackendOrAudienceFilter = cls._imported_backend_filters["OrAudienceFilter"]
+        BackendNotAudienceFilter = cls._imported_backend_filters["NotAudienceFilter"]
+        BackendCountryAudienceFilter = cls._imported_backend_filters[
+            "CountryAudienceFilter"
+        ]
+        BackendLanguageAudienceFilter = cls._imported_backend_filters[
+            "LanguageAudienceFilter"
+        ]
+
+        # Import client models
+        ClientAndFilter = cls._imported_client_filters["AndFilter"]
+        ClientOrFilter = cls._imported_client_filters["OrFilter"]
+        ClientNotFilter = cls._imported_client_filters["NotFilter"]
+        ClientCountryFilter = cls._imported_client_filters["CountryFilter"]
+        ClientLanguageFilter = cls._imported_client_filters["LanguageFilter"]
+
+        # Handle recursive filters (AndFilter, OrFilter, NotFilter)
+        if isinstance(actual_instance, BackendAndAudienceFilter):
+            return ClientAndFilter(
+                [
+                    cls.backend_filter_from_rapidata_filter(child_filter)
+                    for child_filter in actual_instance.filters  # type: ignore[attr-defined]
+                ]
+            )
+        elif isinstance(actual_instance, BackendOrAudienceFilter):
+            return ClientOrFilter(
+                [
+                    cls.backend_filter_from_rapidata_filter(child_filter)
+                    for child_filter in actual_instance.filters  # type: ignore[attr-defined]
+                ]
+            )
+        elif isinstance(actual_instance, BackendNotAudienceFilter):
+            return ClientNotFilter(
+                cls.backend_filter_from_rapidata_filter(actual_instance.filter)  # type: ignore[attr-defined]
+            )
+
+        # Handle simple filters with straightforward mappings
+        elif isinstance(actual_instance, BackendCountryAudienceFilter):
+            return ClientCountryFilter(actual_instance.countries)  # type: ignore[attr-defined]
+        elif isinstance(actual_instance, BackendLanguageAudienceFilter):
+            return ClientLanguageFilter(actual_instance.languages)  # type: ignore[attr-defined]
+
+        else:
+            backend_type_name = type(actual_instance).__name__
+            raise ValueError(f"Unhandled filter type: {backend_type_name}")

rapidata/rapidata_client/filter/_base_filter.py

@@ -1,21 +1,26 @@
 from abc import abstractmethod
-from typing import Any
+
+from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+from rapidata.api_client.models.i_audience_filter import IAudienceFilter
 
 
 class RapidataFilter:
     """The base class for all Rapidata Filters."""
 
     @abstractmethod
-    def _to_model(self) -> Any:
+    def _to_model(self) -> IUserFilterModel:
         pass
 
+    def _to_audience_model(self) -> IAudienceFilter:
+        raise NotImplementedError("This filter is not supported for audiences")
+
     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):
@@ -33,9 +38,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 +57,10 @@ 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)
+            return NotFilter(filter=self)

rapidata/rapidata_client/filter/age_filter.py

@@ -1,23 +1,39 @@
-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
+                ],
+            )
         )
+
+    def _to_audience_model(self):
+        raise NotImplementedError("AgeFilter is not supported for audiences")

rapidata/rapidata_client/filter/and_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.and_user_filter_model import AndUserFilterModel
-from rapidata.api_client.models.and_user_filter_model_filters_inner import AndUserFilterModelFiltersInner
+from pydantic import BaseModel, ConfigDict
 
 
-class AndFilter(RapidataFilter):
+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"])]) 
+        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]):
-        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 AndUserFilterModel(_t="AndFilter", 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_and_user_filter_model import (
+            IUserFilterModelAndUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelAndUserFilterModel(
+                _t="AndFilter",
+                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_and_audience_filter import (
+            IAudienceFilterAndAudienceFilter,
+        )
+
+        return IAudienceFilter(
+            actual_instance=IAudienceFilterAndAudienceFilter(
+                _t="AndFilter",
+                filters=[filter._to_audience_model() for filter in self.filters],
+            ),
+        )

rapidata/rapidata_client/filter/campaign_filter.py

@@ -1,26 +1,37 @@
-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,
+            )
+        )
+
+    def _to_campaign_model(self):
+        raise NotImplementedError("CampaignFilter is not supported for audiences")

rapidata/rapidata_client/filter/country_filter.py

@@ -1,26 +1,60 @@
-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
+            )
+        )
+
+    def _to_audience_model(self):
+        from rapidata.api_client.models.i_audience_filter import IAudienceFilter
+        from rapidata.api_client.models.i_audience_filter_country_audience_filter import (
+            IAudienceFilterCountryAudienceFilter,
+        )
+
+        return IAudienceFilter(
+            actual_instance=IAudienceFilterCountryAudienceFilter(
+                _t="CountryFilter", countries=self.country_codes
+            )
+        )

rapidata/rapidata_client/filter/custom_filter.py

@@ -1,29 +1,42 @@
-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,
+            )
+        )
+
+    def _to_audience_model(self):
+        raise NotImplementedError("CustomFilter cannot be used in campaigns")

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")