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

rapidata/rapidata_client/filter/response_count_filter.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from rapidata.api_client.models.comparison_operator import ComparisonOperator
+from pydantic import BaseModel, ConfigDict
+
+
+class ResponseCountFilter(RapidataFilter, BaseModel):
+    """ResponseCountFilter Class
+    Can be used to filter users based on the number of responses they have given on validation tasks with the specified dimension.
+
+        response_count (int): The number of user responses to filter by.
+        dimension (str): The dimension to apply the filter on (e.g. "default", "electrical", etc.).
+        operator (str): The comparison operator to use. Must be one of:
+            - ComparisonOperator.EQUAL
+            - ComparisonOperator.NOTEQUAL
+            - ComparisonOperator.LESSTHAN
+            - ComparisonOperator.LESSTHANOREQUAL
+            - ComparisonOperator.GREATERTHAN
+            - ComparisonOperator.GREATERTHANOREQUAL
+
+    Raises:
+        ValueError: If `response_count` is not an integer.
+        ValueError: If `dimension` is not a string.
+        ValueError: If `operator` is not a string or not one of the allowed values.
+
+    Example:
+        ```python
+        from rapidata import ResponseCountFilter
+
+        filter = ResponseCountFilter(response_count=10, dimension="electrical", operator=ComparisonOperator.GREATERTHAN)
+        ```
+        This will filter users who have a response count greater than 10 for the "electrical" dimension.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    response_count: int
+    dimension: str
+    operator: ComparisonOperator
+
+    def __init__(
+        self, response_count: int, dimension: str, operator: ComparisonOperator
+    ):
+        super().__init__(
+            response_count=response_count, dimension=dimension, operator=operator
+        )
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_response_count_user_filter_model import (
+            IUserFilterModelResponseCountUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelResponseCountUserFilterModel(
+                _t="ResponseCountFilter",
+                responseCount=self.response_count,
+                dimension=self.dimension,
+                operator=self.operator,
+            )
+        )

rapidata/rapidata_client/filter/user_score_filter.py

@@ -1,19 +1,65 @@
-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,
-)
+from __future__ import annotations
 
+from pydantic_core.core_schema import FieldValidationInfo
+from rapidata.rapidata_client.filter._base_filter import RapidataFilter
+from pydantic import BaseModel, field_validator, model_validator
 
-class UserScoreFilter(Filter):
 
-    def __init__(self, lower_bound: int = 0, upper_bound: int = 1):
-        self.upper_bound = upper_bound
-        self.lower_bound = lower_bound
+class UserScoreFilter(RapidataFilter, BaseModel):
+    """UserScoreFilter Class
 
-    def to_model(self):
-        return UserScoreUserFilterModel(
-            _t="UserScoreFilter",
-            upperbound=self.upper_bound,
-            lowerbound=self.lower_bound,
+    Can be used to filter who to target based on their user score.
+
+    Args:
+        lower_bound (float): The lower bound of the user score.
+        upper_bound (float): The upper bound of the user score.
+        dimension (str): The dimension of the userScore to be considerd for the filter.
+
+    Example:
+        ```python
+        UserScoreFilter(0.5, 0.9)
+        ```
+        This will only show the order to users that have a UserScore of >=0.5 and <=0.9
+    """
+
+    lower_bound: float
+    upper_bound: float
+    dimension: str | None = None
+
+    def __init__(
+        self,
+        lower_bound: float = 0.0,
+        upper_bound: float = 1.0,
+        dimension: str | None = None,
+    ):
+        super().__init__(
+            lower_bound=lower_bound, upper_bound=upper_bound, dimension=dimension
+        )
+
+    @field_validator("lower_bound", "upper_bound")
+    @classmethod
+    def validate_bounds(cls, v: float, info: FieldValidationInfo) -> float:
+        if v < 0 or v > 1:
+            raise ValueError(f"{info.field_name} must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def validate_bounds_relationship(self) -> "UserScoreFilter":
+        if self.lower_bound >= self.upper_bound:
+            raise ValueError("lower_bound must be less than upper_bound")
+        return self
+
+    def _to_model(self):
+        from rapidata.api_client.models.i_user_filter_model import IUserFilterModel
+        from rapidata.api_client.models.i_user_filter_model_user_score_user_filter_model import (
+            IUserFilterModelUserScoreUserFilterModel,
+        )
+
+        return IUserFilterModel(
+            actual_instance=IUserFilterModelUserScoreUserFilterModel(
+                _t="UserScoreFilter",
+                upperbound=self.upper_bound,
+                lowerbound=self.lower_bound,
+                dimension=self.dimension,
+            )
         )

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -0,0 +1,481 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional, Sequence, get_args
+import random
+import secrets
+
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+
+if TYPE_CHECKING:
+    from rapidata.api_client.models.create_order_model import CreateOrderModel
+from rapidata.rapidata_client.exceptions.failed_upload_exception import (
+    FailedUploadException,
+)
+from rapidata.rapidata_client.filter import RapidataFilter, UserScoreFilter
+from rapidata.rapidata_client.config import (
+    logger,
+    managed_print,
+    rapidata_config,
+    tracer,
+)
+from rapidata.rapidata_client.validation.validation_set_manager import (
+    ValidationSetManager,
+)
+from rapidata.rapidata_client.validation.rapidata_validation_set import (
+    RapidataValidationSet,
+)
+from rapidata.rapidata_client.order.dataset._rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+from rapidata.rapidata_client.referee import Referee
+from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+from rapidata.rapidata_client.settings import RapidataSetting
+from rapidata.rapidata_client.workflow import (
+    Workflow,
+    CompareWorkflow,
+    ClassifyWorkflow,
+)
+from rapidata.rapidata_client.selection import (
+    ConditionalValidationSelection,
+    LabelingSelection,
+    CappedSelection,
+)
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.api.rapidata_api_client import (
+    suppress_rapidata_error_logging,
+)
+
+StickyStateLiteral = Literal["Temporary", "Permanent", "Passive"]
+
+
+class RapidataOrderBuilder:
+    """Builder object for creating Rapidata orders.
+
+    Use the fluent interface to set the desired configuration. Add a workflow to the order using `.workflow()` and finally call `.create()` to create the order.
+
+    Args:
+        openapi_service (OpenAPIService): The OpenAPIService instance.
+        name (str): The name of the order.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        openapi_service: OpenAPIService,
+    ):
+        self._name = name
+        self._openapi_service = openapi_service
+        self._dataset: Optional[RapidataDataset] = None
+        self._workflow: Workflow | None = None
+        self._referee: Referee | None = None
+        self._validation_set: RapidataValidationSet | None = None
+        self._settings: Sequence[RapidataSetting] | None = None
+        self._user_filters: list[RapidataFilter] = []
+        self._selections: Sequence[RapidataSelection] = []
+        self._priority: int | None = None
+        self._datapoints: list[Datapoint] = []
+        self._sticky_state_value: StickyStateLiteral | None = None
+        self._temporary_sticky_enabled: bool = False
+        self._validation_set_manager: ValidationSetManager = ValidationSetManager(
+            self._openapi_service
+        )
+
+    def _to_model(self) -> CreateOrderModel:
+        """
+        Convert the builder configuration to a CreateOrderModel.
+
+        Raises:
+            ValueError: If no workflow is provided.
+
+        Returns:
+            CreateOrderModel: The model representing the order configuration.
+        """
+        if self._workflow is None:
+            raise ValueError("You must provide a workflow to create an order.")
+
+        if self._referee is None:
+            managed_print("No referee provided, using default NaiveReferee.")
+            self._referee = NaiveReferee()
+
+        sticky_state = self._sticky_state_value
+        if not sticky_state and self._temporary_sticky_enabled:
+            sticky_state = "Temporary"
+            logger.debug(
+                "Setting sticky state to Temporary due to temporary sticky enabled."
+            )
+
+        validation_set_id = (
+            self._validation_set.id
+            if (self._validation_set and not self._selections)
+            else None
+        )
+        from rapidata.api_client.models.create_order_model import CreateOrderModel
+        from rapidata.api_client.models.sticky_state import StickyState
+
+        return CreateOrderModel(
+            orderName=self._name,
+            workflow=self._workflow._to_model(),
+            userFilters=[user_filter._to_model() for user_filter in self._user_filters],
+            referee=self._referee._to_model(),
+            validationSetId=validation_set_id,
+            featureFlags=(
+                [setting._to_feature_flag() for setting in self._settings]
+                if self._settings is not None
+                else None
+            ),
+            selections=(
+                [selection._to_model() for selection in self._selections]
+                if self._selections
+                else None
+            ),
+            priority=self._priority,
+            stickyState=(StickyState(sticky_state) if sticky_state else None),
+        )
+
+    def _generate_id(self, length=9):
+        """Optimal balance: fast comparisons + low collision risk"""
+        alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+        return "".join(secrets.choice(alphabet) for _ in range(length))
+
+    def _attach_validation_set_id(self) -> None:
+        """
+        Sets the validation set for the order.
+        """
+        assert self._workflow is not None
+
+        required_amount = min(int(len(self._datapoints) * 0.01) or 3, 15)
+
+        if self._validation_set is None:
+            try:
+                with suppress_rapidata_error_logging():
+                    val_set_id = (
+                        (
+                            self._openapi_service.validation_api.validation_set_recommended_get(
+                                asset_type=[self._datapoints[0].get_asset_type()],
+                                modality=[self._workflow.modality],
+                                instruction=self._workflow._get_instruction(),
+                                prompt_type=[
+                                    t.value
+                                    for t in self._datapoints[0].get_prompt_type()
+                                ],
+                            )
+                        )
+                        .validation_sets[0]
+                        .id
+                    )
+                    self._validation_set = (
+                        self._validation_set_manager.get_validation_set_by_id(
+                            val_set_id
+                        )
+                    )
+
+            except Exception as e:
+                logger.debug("No recommended validation set found, error: %s", e)
+
+        sufficient_rapids_count = False
+        if self._validation_set is not None:
+            sufficient_rapids_count = (
+                self._validation_set_manager._get_total_and_labeled_rapids_count(
+                    self._validation_set.id
+                )[1]
+                >= required_amount
+            )
+
+        if self._validation_set is None or not sufficient_rapids_count:
+            if (
+                len(self._datapoints)
+                < rapidata_config.order.minOrderDatapointsForValidation
+            ):
+                logger.debug(
+                    "No recommended validation set found, dataset too small to create one."
+                )
+                return
+
+            logger.info("No recommended validation set found, creating new one.")
+            managed_print()
+            managed_print(
+                f"No recommended validation set found, new one will be created."
+            )
+
+            new_dimension = self._generate_id()
+            logger.debug("New dimension created: %s", new_dimension)
+            rng = random.Random(42)
+            self._validation_set = (
+                self._validation_set_manager._create_order_validation_set(
+                    workflow=self._workflow,
+                    name=self._name,
+                    datapoints=rng.sample(
+                        self._datapoints, len(self._datapoints)
+                    ),  # shuffle the datapoints with a specific seed
+                    required_amount=required_amount,
+                    settings=self._settings,
+                    dimensions=[new_dimension],
+                )
+            )
+
+        self._validation_set.update_should_alert(False)
+        self._validation_set.update_can_be_flagged(False)
+
+        logger.debug("New validation set created for order: %s", self._validation_set)
+
+        self._selections = [
+            CappedSelection(
+                selections=[
+                    ConditionalValidationSelection(
+                        validation_set_id=self._validation_set.id,
+                        dimensions=self._validation_set.dimensions,
+                        thresholds=[0, 0.5, 0.7],
+                        chances=[1, 1, 0.2],
+                        rapid_counts=[10, 1, 1],
+                    ),
+                    LabelingSelection(amount=1),
+                ],
+                max_rapids=3,
+            )
+        ]
+
+        for dimension in self._validation_set.dimensions:
+            self._user_filters.append(
+                UserScoreFilter(
+                    lower_bound=0.3,
+                    upper_bound=1,
+                    dimension=dimension,
+                )
+            )
+
+    def _create(self) -> RapidataOrder:
+        """
+        Create the Rapidata order by making the necessary API calls based on the builder's configuration.
+
+        Raises:
+            ValueError: If both media paths and texts are provided, or if neither is provided.
+            AssertionError: If the workflow is a CompareWorkflow and media paths are not in pairs.
+
+        Returns:
+            RapidataOrder: The created RapidataOrder instance.
+        """
+        if (
+            rapidata_config.order.autoValidationSetCreation
+            and isinstance(self._workflow, (CompareWorkflow, ClassifyWorkflow))
+            and not self._selections
+            and rapidata_config.enableBetaFeatures
+        ):
+            self._attach_validation_set_id()
+            self._temporary_sticky_enabled = True
+            logger.debug("Temporary sticky enabled for order creation.")
+
+        order_model = self._to_model()
+        logger.debug("Creating order with model: %s", order_model)
+
+        self._temporary_sticky_enabled = False
+        logger.debug("Disabling temporary sticky after order creation.")
+
+        result = self._openapi_service.order_api.order_post(
+            create_order_model=order_model
+        )
+
+        order = RapidataOrder(
+            order_id=str(result.order_id),
+            openapi_service=self._openapi_service,
+            name=self._name,
+        )
+        logger.debug("Order created: %s", order)
+
+        if not result.dataset_id:
+            logger.error("No Dataset was created for order %s", order.id)
+            return order
+
+        self._dataset = RapidataDataset(result.dataset_id, self._openapi_service)
+
+        logger.debug("Dataset created with ID: %s", self._dataset.id)
+        logger.debug("Adding datapoints to the order.")
+        with tracer.start_as_current_span("add_datapoints"):
+            _, failed_uploads = self._dataset.add_datapoints(self._datapoints)
+
+            if failed_uploads:
+                raise FailedUploadException(self._dataset, order, failed_uploads)
+
+        logger.debug("Datapoints added to the order.")
+        logger.debug("Setting order to preview")
+        try:
+            self._openapi_service.order_api.order_order_id_preview_post(order.id)
+        except Exception:
+            raise FailedUploadException(self._dataset, order, failed_uploads)
+        return order
+
+    def _set_workflow(self, workflow: Workflow) -> RapidataOrderBuilder:
+        """
+        Set the workflow for the order.
+
+        Args:
+            workflow (Workflow): The workflow to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if not isinstance(workflow, Workflow):
+            raise TypeError("Workflow must be of type Workflow.")
+
+        self._workflow = workflow
+        return self
+
+    def _set_referee(self, referee: Referee) -> "RapidataOrderBuilder":
+        """
+        Set the referee for the order.
+
+        Args:
+            referee (Referee): The referee to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if not isinstance(referee, Referee):
+            raise TypeError("Referee must be of type Referee.")
+
+        self._referee = referee
+        return self
+
+    def _set_datapoints(
+        self,
+        datapoints: list[Datapoint],
+    ) -> RapidataOrderBuilder:
+        """
+        Set the datapoints for the order.
+
+        Args:
+            datapoints: (Sequence[Datapoint]): The datapoints to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if not isinstance(datapoints, list):
+            raise TypeError(
+                "Datapoints must be provided as a list of Datapoint objects."
+            )
+
+        self._datapoints = datapoints
+        return self
+
+    def _set_settings(
+        self, settings: Sequence[RapidataSetting]
+    ) -> RapidataOrderBuilder:
+        """
+        Set the settings for the order.
+
+        Args:
+            settings (Settings): The settings to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+
+        if not isinstance(settings, list):
+            raise TypeError("Settings must be provided as a list of Setting objects.")
+
+        for s in settings:
+            if not isinstance(s, RapidataSetting):
+                raise TypeError("The settings list must only contain Setting objects.")
+
+        self._settings = settings
+        return self
+
+    def _set_filters(self, filters: Sequence[RapidataFilter]) -> 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, RapidataFilter):
+                raise TypeError("Filters must be of type Filter.")
+
+        if len(self._user_filters) > 0:
+            managed_print("Overwriting existing user filters.")
+
+        self._user_filters = filters
+        return self
+
+    def _set_validation_set_id(
+        self, validation_set_id: str | None = None
+    ) -> RapidataOrderBuilder:
+        """
+        Set the validation set ID for the order.
+
+        Args:
+            validation_set_id (str): The validation set ID to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if validation_set_id is not None and not isinstance(validation_set_id, str):
+            raise TypeError("Validation set ID must be of type str.")
+        if validation_set_id is not None:
+            self._validation_set = (
+                self._validation_set_manager.get_validation_set_by_id(validation_set_id)
+            )
+            return self
+        self._validation_set = validation_set_id
+        return self
+
+    def _set_selections(
+        self, selections: Sequence[RapidataSelection]
+    ) -> RapidataOrderBuilder:
+        """
+        Set the selections for the order.
+
+        Args:
+            selections (Sequence[Selection]): The selections to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        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, RapidataSelection):
+                raise TypeError("Selections must be of type Selection.")
+
+        self._selections = selections  # type: ignore
+        return self
+
+    def _set_priority(self, priority: int | None = None) -> RapidataOrderBuilder:
+        """
+        Set the priority for the order.
+
+        Args:
+            priority (int): The priority to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        if priority is not None and not isinstance(priority, int):
+            raise TypeError("Priority must be of type int.")
+
+        self._priority = priority
+        return self
+
+    def _set_sticky_state(
+        self, sticky_state: StickyStateLiteral | None = None
+    ) -> RapidataOrderBuilder:
+        """
+        Set the sticky state for the order.
+        """
+        sticky_state_valid_values = get_args(StickyStateLiteral)
+
+        if sticky_state is not None and sticky_state not in sticky_state_valid_values:
+            raise ValueError(
+                f"Sticky state must be one of {sticky_state_valid_values} or None"
+            )
+
+        self._sticky_state_value = sticky_state
+        return self