rapidata 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

rapidata/rapidata_client/filter/age_filter.py

@@ -0,0 +1,16 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
+from rapidata.api_client.models.age_group import AgeGroup
+
+
+class AgeFilter(Filter):
+
+    def __init__(self, age_groups: list[AgeGroup]):
+        self.age_groups = age_groups
+
+    def to_model(self):
+        return AgeUserFilterModel(
+            _t="AgeFilter",
+            ageGroups=self.age_groups,
+        )

rapidata/rapidata_client/filter/base_filter.py

@@ -0,0 +1,9 @@
+from abc import abstractmethod
+from typing import Any
+
+
+class Filter:
+
+    @abstractmethod
+    def to_model(self) -> Any:
+        pass

rapidata/rapidata_client/filter/campaign_filter.py

@@ -0,0 +1,17 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.campaign_user_filter_model import (
+    CampaignUserFilterModel,
+)
+
+
+class CampaignFilter(Filter):
+
+    def __init__(self, campaign_ids: list[str]):
+        self.campaign_ids = campaign_ids
+
+    def to_model(self):
+        return CampaignUserFilterModel(
+            _t="CampaignFilter",
+            campaignIds=self.campaign_ids,
+        )

rapidata/rapidata_client/filter/country_filter.py

@@ -0,0 +1,16 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
+
+
+class CountryFilter(Filter):
+
+    def __init__(self, country_codes: list[str]):
+        # check that all characters in the country codes are uppercase
+        if not all([code.isupper() for code in country_codes]):
+            raise ValueError("Country codes must be uppercase")
+
+        self.country_codes = country_codes
+
+    def to_model(self):
+        return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)

rapidata/rapidata_client/filter/gender_filter.py

@@ -0,0 +1,16 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
+from rapidata.api_client.models.gender import Gender
+
+
+class GenderFilter(Filter):
+
+    def __init__(self, genders: list[Gender]):
+        self.genders = genders
+
+    def to_model(self):
+        return GenderUserFilterModel(
+            _t="GenderFilter",
+            genders=self.genders,
+        )

rapidata/rapidata_client/filter/language_filter.py

@@ -0,0 +1,18 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.language_user_filter_model import (
+    LanguageUserFilterModel,
+)
+
+
+class LanguageFilter(Filter):
+
+    def __init__(self, language_codes: list[str]):
+        # 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")
+
+        self.languages = language_codes
+
+    def to_model(self):
+        return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)

rapidata/rapidata_client/filter/user_score_filter.py

@@ -0,0 +1,19 @@
+from typing import Any
+from rapidata.rapidata_client.filter.base_filter import Filter
+from rapidata.api_client.models.user_score_user_filter_model import (
+    UserScoreUserFilterModel,
+)
+
+
+class UserScoreFilter(Filter):
+
+    def __init__(self, lower_bound: int = 0, upper_bound: int = 1):
+        self.upper_bound = upper_bound
+        self.lower_bound = lower_bound
+
+    def to_model(self):
+        return UserScoreUserFilterModel(
+            _t="UserScoreFilter",
+            upperbound=self.upper_bound,
+            lowerbound=self.lower_bound,
+        )

rapidata/rapidata_client/order/rapidata_order_builder.py

@@ -1,3 +1,5 @@
+from warnings import warn
+
 from rapidata.api_client.models.aggregator_type import AggregatorType
 from rapidata.api_client.models.capped_selection_selections_inner import (
     CappedSelectionSelectionsInner,
@@ -21,6 +23,7 @@ from rapidata.rapidata_client.metadata.base_metadata import Metadata
 from rapidata.rapidata_client.dataset.rapidata_dataset import RapidataDataset
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
 from rapidata.rapidata_client.workflow import Workflow
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.referee import Referee
@@ -63,8 +66,7 @@ class RapidataOrderBuilder:
         self._aggregator: AggregatorType | None = None
         self._validation_set_id: str | None = None
         self._feature_flags: FeatureFlags | None = None
-        self._country_codes: list[str] | None = None
-        self._language_codes: list[str] | None = None
+        self._user_filters: list[Filter] = []
         self._selections: list[Selection] = []
         self._rapids_per_bag: int = 2
         self._priority: int = 50
@@ -87,31 +89,14 @@ class RapidataOrderBuilder:
             print("No referee provided, using default NaiveReferee.")
             self._referee = NaiveReferee()
 
-        user_filters = []
-
-        if self._country_codes is not None:
-            user_filters.append(
-                CreateOrderModelUserFiltersInner(
-                    CountryUserFilterModel(
-                        _t="CountryFilter", countries=self._country_codes
-                    )
-                )
-            )
-
-        if self._language_codes is not None:
-            user_filters.append(
-                CreateOrderModelUserFiltersInner(
-                    LanguageUserFilterModel(
-                        _t="LanguageFilter", languages=self._language_codes
-                    )
-                )
-            )
-
         return CreateOrderModel(
             _t="CreateOrderModel",
             orderName=self._name,
             workflow=CreateOrderModelWorkflow(self._workflow.to_model()),
-            userFilters=user_filters,
+            userFilters=[
+                CreateOrderModelUserFiltersInner(user_filter.to_model())
+                for user_filter in self._user_filters
+            ],
             referee=CreateOrderModelReferee(self._referee.to_model()),
             validationSetId=self._validation_set_id,
             featureFlags=(
@@ -141,17 +126,17 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrder: The created RapidataOrder instance.
         """
+        if not self._workflow or not self._assets:
+            raise ValueError(
+                "You must provide a workflow and assets to create an order. Use the .workflow() and .media() methods respecitvely."
+            )
         order_model = self._to_model()
         if isinstance(
             self._workflow, CompareWorkflow
         ):  # Temporary fix; will be handled by backend in the future
-            assert all(isinstance(item, MultiAsset) for item in self._assets), (
-                "The media paths must be of type MultiAsset for comparison tasks."
-            )
-            media_paths = cast(list[MultiAsset], self._assets)
             assert all(
-                [len(path) == 2 for path in media_paths]
-            ), "The media paths must come in pairs for comparison tasks."
+                isinstance(item, MultiAsset) for item in self._assets
+            ), "The media paths must be of type MultiAsset for comparison tasks."
 
         result = self._openapi_service.order_api.order_create_post(
             create_order_model=order_model
@@ -165,18 +150,45 @@ class RapidataOrderBuilder:
             openapi_service=self._openapi_service,
         )
 
-        if not self._assets:
-            raise ValueError(
-                "You must provide assets to start the order."
-            )
-        if all(isinstance(item, TextAsset) for item in self._assets):
+        if all(isinstance(item, MediaAsset) for item in self._assets):
+            assets = cast(list[MediaAsset], self._assets)
+            order.dataset.add_media_from_paths(assets, self._metadata, max_workers)
+
+        elif all(isinstance(item, TextAsset) for item in self._assets):
             assets = cast(list[TextAsset], self._assets)
             order.dataset.add_texts(assets)
 
-        elif all(isinstance(item, (MediaAsset, MultiAsset)) for item in self._assets):
-            assets = cast(list[MediaAsset | MultiAsset], self._assets)
-            order.dataset.add_media_from_paths(
-                assets, self._metadata, max_workers
+        elif all(isinstance(item, MultiAsset) for item in self._assets):
+            multi_assets = cast(list[MultiAsset], self._assets)
+
+            # Check if all MultiAssets contain the same type of assets
+            first_asset_type = type(multi_assets[0].assets[0])
+            if not all(
+                isinstance(asset, first_asset_type)
+                for multi_asset in multi_assets
+                for asset in multi_asset.assets
+            ):
+                raise ValueError(
+                    "All MultiAssets must contain the same type of assets (either all MediaAssets or all TextAssets)."
+                )
+
+            # Process based on the asset type
+            if issubclass(first_asset_type, MediaAsset):
+                order.dataset.add_media_from_paths(
+                    multi_assets, self._metadata, max_workers
+                )
+
+            elif issubclass(first_asset_type, TextAsset):
+                order.dataset.add_texts(multi_assets)
+
+            else:
+                raise ValueError(
+                    "MultiAsset must contain MediaAssets or TextAssets objects."
+                )
+
+        else:
+            raise ValueError(
+                "Media paths must be of type MediaAsset, TextAsset, or MultiAsset."
             )
 
         if submit:
@@ -194,6 +206,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(workflow, Workflow):
+            raise TypeError("Workflow must be of type Workflow.")
+
         self._workflow = workflow
         return self
 
@@ -207,6 +222,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(referee, Referee):
+            raise TypeError("Referee must be of type Referee.")
+
         self._referee = referee
         return self
 
@@ -225,8 +243,22 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(asset, list):
+            raise TypeError("Media paths must be provided as a list of paths.")
+
+        for a in asset:
+            if not isinstance(a, (MediaAsset, TextAsset, MultiAsset)):
+                raise TypeError(
+                    "Media paths must be of type MediaAsset, TextAsset, or MultiAsset."
+                )
+
+        if metadata:
+            for data in metadata:
+                if not isinstance(data, Metadata):
+                    raise TypeError("Metadata must be of type Metadata.")
+
         self._assets = asset
-        self._metadata = metadata # type: ignore
+        self._metadata = metadata  # type: ignore
         return self
 
     def feature_flags(self, feature_flags: FeatureFlags) -> "RapidataOrderBuilder":
@@ -239,9 +271,35 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(feature_flags, FeatureFlags):
+            raise TypeError("Feature flags must be of type FeatureFlags.")
+
         self._feature_flags = feature_flags
         return self
 
+    def filters(self, filters: Sequence[Filter]) -> "RapidataOrderBuilder":
+        """
+        Set the filters for the order, e.g., country, language, userscore, etc.
+
+        Args:
+            filters (Sequence[Filters]): The user filters to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if not isinstance(filters, list):
+            raise TypeError("Filters must be provided as a list of Filter objects.")
+
+        for f in filters:
+            if not isinstance(f, Filter):
+                raise TypeError("Filters must be of type Filter.")
+
+        if len(self._user_filters) > 0:
+            print("Overwriting existing user filters.")
+
+        self._user_filters = filters
+        return self
+
     def country_filter(self, country_codes: list[str]) -> "RapidataOrderBuilder":
         """
         Set the target country codes for the order. E.g. `country_codes=["DE", "CH", "AT"]` for Germany, Switzerland, and Austria.
@@ -252,7 +310,18 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        self._country_codes = country_codes
+        warn(
+            "The country_filter method is deprecated. Use the filters method instead.",
+            DeprecationWarning,
+        )
+        if not isinstance(country_codes, list):
+            raise TypeError("Country codes must be provided as a list of strings.")
+
+        for code in country_codes:
+            if not isinstance(code, str):
+                raise TypeError("Country codes must be of type str.")
+
+        self._user_filters.append(CountryFilter(country_codes))
         return self
 
     def language_filter(self, language_codes: list[str]) -> "RapidataOrderBuilder":
@@ -265,7 +334,17 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        self._language_codes = language_codes
+        warn(
+            "The language_filter method is deprecated. Use the filters method instead.",
+            DeprecationWarning,
+        )
+        if not isinstance(language_codes, list):
+            raise TypeError("Language codes must be provided as a list of strings.")
+
+        if not all(isinstance(code, str) for code in language_codes):
+            raise TypeError("Language codes must be of type str.")
+
+        self._user_filters.append(LanguageFilter(language_codes))
         return self
 
     def aggregator(self, aggregator: AggregatorType) -> "RapidataOrderBuilder":
@@ -278,6 +357,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(aggregator, AggregatorType):
+            raise TypeError("Aggregator must be of type AggregatorType.")
+
         self._aggregator = aggregator
         return self
 
@@ -291,6 +373,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(validation_set_id, str):
+            raise TypeError("Validation set ID must be of type str.")
+
         self._validation_set_id = validation_set_id
         return self
 
@@ -309,17 +394,26 @@ class RapidataOrderBuilder:
         """
         raise NotImplementedError("Not implemented yet.")
 
-    def selections(self, selections: list[Selection]) -> "RapidataOrderBuilder":
+    def selections(self, selections: Sequence[Selection]) -> "RapidataOrderBuilder":
         """
         Set the selections for the order.
 
         Args:
-            selections (list[Selection]): The selections to be set.
+            selections (Sequence[Selection]): The selections to be set.
 
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        self._selections = selections
+        if not isinstance(selections, list):
+            raise TypeError(
+                "Selections must be provided as a list of Selection objects."
+            )
+
+        for selection in selections:
+            if not isinstance(selection, Selection):
+                raise TypeError("Selections must be of type Selection.")
+
+        self._selections = selections  # type: ignore
         return self
 
     def priority(self, priority: int) -> "RapidataOrderBuilder":
@@ -332,5 +426,8 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(priority, int):
+            raise TypeError("Priority must be of type int.")
+
         self._priority = priority
         return self

rapidata/rapidata_client/selection/demographic_selection.py

@@ -5,8 +5,9 @@ from rapidata.api_client.models.demographic_selection import DemographicSelectio
 class DemographicSelection(Selection):
     """Demographic selection class."""
 
-    def __init__(self, keys: list[str]):
+    def __init__(self, keys: list[str], maxRapids: int):
         self.keys = keys
+        self.maxRapids = maxRapids
 
     def to_model(self):
-        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys)
+        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys, maxRapids=self.maxRapids)

{rapidata-1.2.0.dist-info → rapidata-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapidata
-Version: 1.2.0
+Version: 1.2.2
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG