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

rapidata/rapidata_client/datapoints/metadata/_private_text_metadata.py

@@ -2,16 +2,15 @@ from rapidata.api_client.models.private_text_metadata_input import (
     PrivateTextMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class PrivateTextMetadata(Metadata):
+class PrivateTextMetadata(Metadata, BaseModel):
 
-    def __init__(self, text: str, identifier: str = "private_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
+    text: str
+    identifier: str = "private_text"
 
     def to_model(self):
         return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier=self._identifier, text=self._text
+            _t="PrivateTextMetadataInput", identifier=self.identifier, text=self.text
         )

rapidata/rapidata_client/datapoints/metadata/_prompt_identifier_metadata.py

@@ -2,14 +2,13 @@ from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.api_client.models.private_text_metadata_input import (
     PrivateTextMetadataInput,
 )
+from pydantic import BaseModel
 
 
-class PromptIdentifierMetadata(Metadata):
-    def __init__(self, identifier: str):
-        super().__init__()
-        self._identifier = identifier
+class PromptIdentifierMetadata(Metadata, BaseModel):
+    identifier: str
 
     def to_model(self):
         return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self._identifier
+            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self.identifier
         )

rapidata/rapidata_client/datapoints/metadata/_public_text_metadata.py

@@ -2,16 +2,15 @@ from rapidata.api_client.models.public_text_metadata_input import (
     PublicTextMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class PublicTextMetadata(Metadata):
+class PublicTextMetadata(Metadata, BaseModel):
 
-    def __init__(self, text: str, identifier: str = "public_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
+    text: str
+    identifier: str = "public_text"
 
     def to_model(self):
         return PublicTextMetadataInput(
-            _t="PublicTextMetadataInput", identifier=self._identifier, text=self._text
+            _t="PublicTextMetadataInput", identifier=self.identifier, text=self.text
         )

rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py

@@ -2,14 +2,13 @@ from rapidata.api_client.models.transcription_metadata_input import (
     TranscriptionMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class SelectWordsMetadata(Metadata):
+class SelectWordsMetadata(Metadata, BaseModel):
     """SelectWordsMetadata Class is used to define the Sentence that will be display to the user."""
 
-    def __init__(self, select_words: str):
-        super().__init__()
-        self.select_words = select_words
+    select_words: str
 
     def to_model(self):
         return TranscriptionMetadataInput(

rapidata/rapidata_client/dataset/__init__.py

@@ -0,0 +1 @@
+from ._rapidata_dataset import RapidataDataset

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.datapoints.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/failed_upload_exception.py

@@ -1,53 +1,27 @@
-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 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 __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, 
+        self,
         dataset: RapidataDataset,
-        order: RapidataOrder,
-        failed_uploads: list[Datapoint]
+        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")