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

rapidata/rapidata_client/dataset/_rapidata_dataset.py

@@ -0,0 +1,55 @@
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.config import logger
+from rapidata.rapidata_client.datapoints._datapoint_uploader import DatapointUploader
+from rapidata.rapidata_client.utils.threaded_uploader import ThreadedUploader
+
+
+class RapidataDataset:
+    def __init__(self, dataset_id: str, openapi_service: OpenAPIService):
+        self.id = dataset_id
+        self.openapi_service = openapi_service
+        self.datapoint_uploader = DatapointUploader(openapi_service)
+
+    def add_datapoints(
+        self,
+        datapoints: list[Datapoint],
+    ) -> tuple[list[Datapoint], list[Datapoint]]:
+        """
+        Process uploads in chunks with a ThreadPoolExecutor.
+
+        Args:
+            datapoints: List of datapoints to upload
+
+        Returns:
+            tuple[list[Datapoint], list[Datapoint]]: Lists of successful and failed uploads
+        """
+
+        def upload_single_datapoint(datapoint: Datapoint, index: int) -> None:
+            self.datapoint_uploader.upload_datapoint(
+                dataset_id=self.id,
+                datapoint=datapoint,
+                index=index,
+            )
+
+        uploader: ThreadedUploader[Datapoint] = ThreadedUploader(
+            upload_fn=upload_single_datapoint,
+            description="Uploading datapoints",
+        )
+
+        successful_uploads, failed_uploads = uploader.upload(datapoints)
+
+        if failed_uploads:
+            logger.error(
+                "Upload failed for %s datapoints: %s",
+                len(failed_uploads),
+                failed_uploads,
+            )
+
+        return successful_uploads, failed_uploads
+
+    def __str__(self) -> str:
+        return f"RapidataDataset(id={self.id})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/demographic/demographic_manager.py

@@ -1,29 +1,54 @@
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.assets import MediaAsset
-from rapidata.api_client.models.create_demographic_rapid_model import CreateDemographicRapidModel
-from rapidata.api_client.models.classify_payload import ClassifyPayload
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+
 
 class DemographicManager:
     def __init__(self, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
+        self._asset_uploader = AssetUploader(openapi_service)
         logger.debug("DemographicManager initialized")
-    
-    def create_demographic_rapid(self, 
-                                 instruction: str,
-                                 answer_options: list[str],
-                                 datapoint: str,
-                                 key: str):
-        
-        media = MediaAsset(path=datapoint)
+
+    def create_demographic_rapid(
+        self, instruction: str, answer_options: list[str], datapoint: str, key: str
+    ):
+        from rapidata.api_client.models.classify_payload import ClassifyPayload
+        from rapidata.api_client.models.classify_payload_category import (
+            ClassifyPayloadCategory,
+        )
+        from rapidata.api_client.models.create_demographic_rapid_model import (
+            CreateDemographicRapidModel,
+        )
+        from rapidata.api_client.models.i_asset_input import IAssetInput
+        from rapidata.api_client.models.i_asset_input_existing_asset_input import (
+            IAssetInputExistingAssetInput,
+        )
+
         model = CreateDemographicRapidModel(
             key=key,
             payload=ClassifyPayload(
-                _t="ClassifyPayload",
-                possibleCategories=answer_options,
-                title=instruction
-            )
+                categories=[
+                    ClassifyPayloadCategory(label=option, value=option)
+                    for option in answer_options
+                ],
+                title=instruction,
+            ),
+            asset=IAssetInput(
+                actual_instance=IAssetInputExistingAssetInput(
+                    _t="ExistingAssetInput",
+                    name=self._asset_uploader.upload_asset(datapoint),
+                ),
+            ),
+        )
+
+        result = self._openapi_service.rapid_api.rapid_demographic_post(
+            create_demographic_rapid_model=model
         )
-        
-        self._openapi_service.rapid_api.rapid_demographic_post(model=model, file=[media.to_file()])
-        
+        logger.info(f"Demographic Rapid created: {result.rapid_id}")
+        return result.rapid_id
+
+    def __str__(self) -> str:
+        return "DemographicManager"
+
+    def __repr__(self) -> str:
+        return self.__str__()

rapidata/rapidata_client/exceptions/__init__.py

@@ -0,0 +1 @@
+from .failed_upload_exception import FailedUploadException

rapidata/rapidata_client/exceptions/failed_upload_exception.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+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):
+    """Custom error class for Failed Uploads to the Rapidata order."""
+
+    def __init__(
+        self,
+        dataset: RapidataDataset,
+        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}"

rapidata/rapidata_client/filter/__init__.py

@@ -8,5 +8,8 @@ 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
+from .device_filter import DeviceFilter
+from .models.device_type import DeviceType

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,10 +1,66 @@
 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):
+                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,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

@@ -0,0 +1,55 @@
+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],
+            )
+        )
+
+    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")