rapidata 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

rapidata/rapidata_client/order/dataset/validation_set_builder.py

@@ -0,0 +1,187 @@
+from dataclasses import dataclass
+import os
+from typing import Any, Union
+from openapi_client.models.add_validation_rapid_model import AddValidationRapidModel
+from openapi_client.models.add_validation_rapid_model_payload import (
+    AddValidationRapidModelPayload,
+)
+from openapi_client.models.add_validation_rapid_model_truth import (
+    AddValidationRapidModelTruth,
+)
+from openapi_client.models.attach_category_truth import AttachCategoryTruth
+from openapi_client.models.bounding_box_payload import BoundingBoxPayload
+from openapi_client.models.bounding_box_truth import BoundingBoxTruth
+from openapi_client.models.classify_payload import ClassifyPayload
+from openapi_client.models.compare_payload import ComparePayload
+from openapi_client.models.compare_truth import CompareTruth
+from openapi_client.models.empty_validation_truth import EmptyValidationTruth
+from openapi_client.models.free_text_payload import FreeTextPayload
+from openapi_client.models.line_payload import LinePayload
+from openapi_client.models.line_truth import LineTruth
+from openapi_client.models.locate_box_truth import LocateBoxTruth
+from openapi_client.models.locate_payload import LocatePayload
+from openapi_client.models.named_entity_payload import NamedEntityPayload
+from openapi_client.models.named_entity_truth import NamedEntityTruth
+from openapi_client.models.polygon_payload import PolygonPayload
+from openapi_client.models.polygon_truth import PolygonTruth
+from openapi_client.models.transcription_payload import TranscriptionPayload
+from openapi_client.models.transcription_truth import TranscriptionTruth
+from openapi_client.models.transcription_word import TranscriptionWord
+from rapidata.service.openapi_service import OpenAPIService
+
+
+@dataclass
+class ValidatioRapidParts:
+    question: str
+    media_paths: str | list[str]
+    payload: Union[
+        BoundingBoxPayload,
+        ClassifyPayload,
+        ComparePayload,
+        FreeTextPayload,
+        LinePayload,
+        LocatePayload,
+        NamedEntityPayload,
+        PolygonPayload,
+        TranscriptionPayload,
+    ]
+    truths: Union[
+        AttachCategoryTruth,
+        BoundingBoxTruth,
+        CompareTruth,
+        EmptyValidationTruth,
+        LineTruth,
+        LocateBoxTruth,
+        NamedEntityTruth,
+        PolygonTruth,
+        TranscriptionTruth,
+    ]
+    metadata: Any
+    randomCorrectProbability: float
+
+
+class ValidationSetBuilder:
+
+    def __init__(self, name: str, openapi_service: OpenAPIService):
+        self.name = name
+        self.openapi_service = openapi_service
+        self.validation_set_id: str | None = None
+        self._rapid_parts: list[ValidatioRapidParts] = []
+
+    def create(self):
+        result = (
+            self.openapi_service.validation_api.validation_create_validation_set_post(
+                name=self.name
+            )
+        )
+        self.validation_set_id = result.validation_set_id
+
+        if self.validation_set_id is None:
+            raise ValueError("Failed to create validation set")
+
+        for rapid_part in self._rapid_parts:
+            model = AddValidationRapidModel(
+                validationSetId=self.validation_set_id,
+                payload=AddValidationRapidModelPayload(rapid_part.payload),
+                truth=AddValidationRapidModelTruth(rapid_part.truths),
+                metadata=rapid_part.metadata or [],
+                randomCorrectProbability=rapid_part.randomCorrectProbability,
+            )
+
+            self.openapi_service.validation_api.validation_add_validation_rapid_post(
+                model=model, files=rapid_part.media_paths if isinstance(rapid_part.media_paths, list) else [rapid_part.media_paths]  # type: ignore
+            )
+
+        return str(self.validation_set_id)
+
+    def add_classify_rapid(
+        self, media_path: str, question: str, categories: list[str], truths: list[str]
+    ):
+        payload = ClassifyPayload(
+            _t="ClassifyPaylod", possibleCategories=categories, title=question
+        )
+        model_truth = AttachCategoryTruth(
+            correctCategories=truths, _t="AttachCategoryTruth"
+        )
+
+        self._rapid_parts.append(
+            ValidatioRapidParts(
+                question=question,
+                media_paths=media_path,
+                payload=payload,
+                truths=model_truth,
+                metadata=None,
+                randomCorrectProbability=len(truths) / len(categories),
+            )
+        )
+
+        return self
+
+    def add_compare_rapid(self, media_paths: list[str], question: str, truth: str):
+        payload = ComparePayload(_t="ComparePayload", criteria=question)
+        model_truth = CompareTruth(_t="CompareTruth", winnerId=truth)
+
+        if len(media_paths) != 2:
+            raise ValueError("Compare rapid requires exactly two media paths")
+
+        # check that files exist
+        for media_path in media_paths:
+            if not os.path.exists(media_path):
+                raise FileNotFoundError(f"File not found: {media_path}")
+
+        self._rapid_parts.append(
+            ValidatioRapidParts(
+                question=question,
+                media_paths=media_paths,
+                payload=payload,
+                truths=model_truth,
+                metadata=None,
+                randomCorrectProbability=1 / len(media_paths),
+            )
+        )
+
+        return self
+
+    def add_transcription_rapid(
+        self,
+        media_path: str,
+        question: str,
+        transcription: list[str],
+        correct_words: list[str],
+        strict_grading: bool | None = None,
+    ):
+        transcription_words = [
+            TranscriptionWord(word=word, wordIndex=i)
+            for i, word in enumerate(transcription)
+        ]
+
+        correct_transcription_words = []
+        for word in correct_words:
+            if word not in transcription:
+                raise ValueError(f"Correct word '{word}' not found in transcription")
+            correct_transcription_words.append(
+                TranscriptionWord(word=word, wordIndex=transcription.index(word))
+            )
+
+        payload = TranscriptionPayload(
+            _t="TranscriptionPayload", title=question, transcription=transcription_words
+        )
+
+        model_truth = TranscriptionTruth(
+            _t="TranscriptionTruth",
+            correctWords=correct_transcription_words,
+            strictGrading=strict_grading,
+        )
+
+        self._rapid_parts.append(
+            ValidatioRapidParts(
+                question=question,
+                media_paths=media_path,
+                payload=payload,
+                truths=model_truth,
+                metadata=None,
+                randomCorrectProbability=1 / len(transcription),
+            )
+        )
+
+        return self

rapidata/rapidata_client/order/rapidata_order.py

@@ -1,6 +1,11 @@
+import time
+from openapi_client.models.create_order_model_referee import CreateOrderModelReferee
+from openapi_client.models.create_order_model_workflow import CreateOrderModelWorkflow
 from rapidata.rapidata_client.order.dataset.rapidata_dataset import RapidataDataset
 from rapidata.rapidata_client.workflow import Workflow
-from rapidata.service import RapidataService
+from openapi_client.models.create_order_model import CreateOrderModel
+from rapidata.rapidata_client.referee import Referee
+from rapidata.service.openapi_service import OpenAPIService
 
 
 class RapidataOrder:
@@ -16,13 +21,14 @@ class RapidataOrder:
     """
 
     def __init__(
-        self, name: str, workflow: Workflow, rapidata_service: RapidataService
+        self,
+        order_id: str,
+        dataset: RapidataDataset,
+        openapi_service: OpenAPIService,
     ):
-        self.name = name
-        self.workflow = workflow
-        self.rapidata_service = rapidata_service
-        self.order_id = None
-        self._dataset = None
+        self.openapi_service = openapi_service
+        self.order_id = order_id
+        self._dataset = dataset
 
     def create(self):
         """
@@ -31,41 +37,61 @@ class RapidataOrder:
         :return: The created RapidataOrder instance.
         :rtype: RapidataOrder
         """
-        self.order_id, dataset_id = self.rapidata_service.order.create_order(self.name, self.workflow.to_dict())
-        self._dataset = RapidataDataset(dataset_id, self.rapidata_service)
-        return self
 
     def submit(self):
         """
         Submits the order for processing.
-
-        :raises ValueError: If the order has not been created.
         """
-        if self.order_id is None:
-            raise ValueError("You must create the order before submitting it.")
 
-        self.rapidata_service.order.submit(self.order_id)
+        self.openapi_service.order_api.order_submit_post(self.order_id)
 
     def approve(self):
         """
         Approves the order for execution.
+        """
+        self.openapi_service.order_api.order_approve_post(self.order_id)
+
+    def get_status(self):
+        """
+        Gets the status of the order.
+
+        :return: The status of the order.
+        :rtype: str
+        """
+        return self.openapi_service.order_api.order_get_by_id_get(self.order_id)
 
-        :raises ValueError: If the order has not been created.
+    def wait_for_done(self):
         """
-        if self.order_id is None:
-            raise ValueError("You must create the order before approving it.")
+        Blocking call that waits for the order to be done. Exponential backoff is used to check the status of the order.
+        """
+        wait_time = 2
+        back_off_factor = 1.5
+        minimum_poll_interval = 60 * 10  # 10 minutes
+
+        while True:
+            time.sleep(wait_time)
+            result = self.get_status()
+            if result.state == "Completed":
+                break
+            wait_time = max(
+                minimum_poll_interval, wait_time * back_off_factor
+            )  # poll at least every 10 minutes
+
+    def get_results(self):
+        """
+        Gets the results of the order.
 
-        self.rapidata_service.order.approve(self.order_id)
+        :return: The results of the order.
+        :rtype: dict
+        """
+        # return self.openapi_service.order_api.order_get_order_results_get(self.order_id) # throws error
+        raise NotImplementedError("Currently not supported")
 
     @property
     def dataset(self):
         """
         The dataset associated with the order.
-
-        :raises ValueError: If the order has not been submitted.
         :return: The RapidataDataset instance.
         :rtype: RapidataDataset
         """
-        if self._dataset is None:
-            raise ValueError("You must submit the order before accessing the dataset.")
         return self._dataset

rapidata/rapidata_client/order/rapidata_order_builder.py

@@ -1,6 +1,15 @@
+from openapi_client.models.aggregator_type import AggregatorType
+from openapi_client.models.create_order_model import CreateOrderModel
+from openapi_client.models.create_order_model_referee import CreateOrderModelReferee
+from openapi_client.models.create_order_model_workflow import CreateOrderModelWorkflow
+from rapidata.rapidata_client.feature_flags import FeatureFlags
+from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.order.dataset.rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.workflow import Workflow
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.service import RapidataService
+from rapidata.rapidata_client.referee import Referee
+from rapidata.service.openapi_service import OpenAPIService
 
 
 class RapidataOrderBuilder:
@@ -17,16 +26,22 @@ class RapidataOrderBuilder:
 
     def __init__(
         self,
-        rapidata_service: RapidataService,
+        openapi_service: OpenAPIService,
         name: str,
     ):
         self._name = name
-        self._rapidata_service = rapidata_service
+        self._openapi_service = openapi_service
         self._workflow: Workflow | None = None
+        self._referee: Referee | None = None
+        self._media_paths: list[str] = []
+        self._metadata: list[Metadata] | None = None 
+        self._aggregator: AggregatorType | None = None
+        self._validation_set_id: str | None = None
+        self._feature_flags: FeatureFlags | None = None
 
-    def create(self) -> RapidataOrder:
+    def create(self, submit=True) -> RapidataOrder:
         """
-        Create a RapidataOrder instance based on the configured settings.
+        Actually makes the API calls to create the order based on how the order builder was configures. Returns a RapidataOrder instance based on the created order with order_id and dataset_id.
 
         :return: The created RapidataOrder instance.
         :rtype: RapidataOrder
@@ -35,9 +50,33 @@ class RapidataOrderBuilder:
         if self._workflow is None:
             raise ValueError("You must provide a blueprint to create an order.")
 
-        return RapidataOrder(
-            name=self._name, workflow=self._workflow, rapidata_service=self._rapidata_service
-        ).create()
+        if self._referee is None:
+            print("No referee provided, using default NaiveReferee.")
+            self._referee = NaiveReferee()
+
+        order_model = CreateOrderModel(
+            orderName=self._name,
+            workflow=CreateOrderModelWorkflow(self._workflow.to_model()),
+            userFilters=[],
+            referee=CreateOrderModelReferee(self._referee.to_model()),
+            validationSetId=self._validation_set_id,
+            featureFlags=self._feature_flags.to_list() if self._feature_flags is not None else None,
+        )
+
+        result = self._openapi_service.order_api.order_create_post(
+            create_order_model=order_model
+        )
+
+        self.order_id = result.order_id
+        self._dataset = RapidataDataset(result.dataset_id, self._openapi_service)
+        order = RapidataOrder(order_id=self.order_id, dataset=self._dataset, openapi_service=self._openapi_service)
+
+        order.dataset.add_media_from_paths(self._media_paths, self._metadata)
+
+        if submit:
+            order.submit()
+
+        return order
 
     def workflow(self, workflow: Workflow):
         """
@@ -50,3 +89,82 @@ class RapidataOrderBuilder:
         """
         self._workflow = workflow
         return self
+
+    def referee(self, referee: Referee):
+        """
+        Set the referee for the order.
+
+        :param referee: The referee to be set.
+        :type referee: Referee
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._referee = referee
+        return self
+
+    def media(
+        self, media_paths: list[str], metadata: list[Metadata] | None = None):
+        """
+        Set the media assets for the order.
+
+        :param media_paths: The paths of the media assets to be set.
+        :type media_paths: list[str]
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._media_paths = media_paths
+        self._metadata = metadata
+        return self
+
+    def feature_flags(self, feature_flags: FeatureFlags):
+        """
+        Set the feature flags for the order.
+
+        :param feature_flags: The feature flags to be set.
+        :type feature_flags: FeatureFlags
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._feature_flags = feature_flags
+        return self
+
+    def target_country_codes(self, country_codes: list[str]):
+        """
+        Set the target country codes for the order.
+
+        :param country_codes: The country codes to be set.
+        :type country_codes: list[str]
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        if self._workflow is None:
+            raise ValueError(
+                "You must set the workflow before setting the target country codes."
+            )
+
+        self._workflow.target_country_codes(country_codes)
+        return self
+
+    def aggregator(self, aggregator: AggregatorType):
+        """
+        Set the aggregator for the order.
+
+        :param aggregator: The aggregator to be set.
+        :type aggregator: AggregatorType
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._aggregator = aggregator
+        return self
+    
+    def validation_set(self, validation_set_id: str):
+        """
+        Set the validation set for the order.
+
+        :param validation_set_id: The validation set ID to be set.
+        :type validation_set_id: str
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._validation_set_id = validation_set_id
+        return self

rapidata/rapidata_client/rapidata_client.py

@@ -1,6 +1,6 @@
+from rapidata.rapidata_client.order.dataset.validation_set_builder import ValidationSetBuilder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
-from rapidata.service import RapidataService
-
+from rapidata.service.openapi_service import OpenAPIService
 
 class RapidataClient:
     """
@@ -11,7 +11,7 @@ class RapidataClient:
         self,
         client_id: str,
         client_secret: str,
-        endpoint: str = "https://api.rapidata.ai",
+        endpoint: str = "https://api.app.rapidata.ai",
     ):
         """
         Initialize the RapidataClient.
@@ -20,10 +20,12 @@ class RapidataClient:
         :param client_secret: The client secret for authentication.
         :param endpoint: The API endpoint URL. Defaults to "https://api.rapidata.ai".
         """
-        self._rapidata_service = RapidataService(
+        self.openapi_service = OpenAPIService(
             client_id=client_id, client_secret=client_secret, endpoint=endpoint
         )
 
+        
+
     def new_order(self, name: str) -> RapidataOrderBuilder:
         """
         Create a new order using a RapidataOrderBuilder instance.
@@ -31,4 +33,14 @@ class RapidataClient:
         :param name: The name of the order.
         :return: A RapidataOrderBuilder instance.
         """
-        return RapidataOrderBuilder(rapidata_service=self._rapidata_service, name=name)
+        return RapidataOrderBuilder(openapi_service=self.openapi_service, name=name)
+    
+
+    def new_validation_set(self, name: str) -> ValidationSetBuilder:
+        """
+        Create a new validation set using a ValidationDatasetBuilder instance.
+
+        :param name: The name of the validation set.
+        :return: A ValidationDatasetBuilder instance.
+        """
+        return ValidationSetBuilder(name=name, openapi_service=self.openapi_service)

rapidata/rapidata_client/{workflow/referee → referee}/base_referee.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Mapping
-
+from typing import Any, Mapping
 
 class Referee(ABC):
     """
@@ -11,4 +10,11 @@ class Referee(ABC):
         """
         Convert the referee to a referee configuration dict.
         """
+        pass
+
+    @abstractmethod
+    def to_model(self) -> Any:
+        """
+        Convert the referee to a referee configuration model.
+        """
         pass

rapidata/rapidata_client/{workflow/referee → referee}/classify_early_stopping_referee.py

@@ -1,4 +1,4 @@
-from rapidata.rapidata_client.workflow.referee.base_referee import Referee
+from rapidata.rapidata_client.referee.base_referee import Referee
 
 
 class ClassifyEarlyStoppingReferee(Referee):

rapidata/rapidata_client/{workflow/referee → referee}/naive_referee.py

@@ -1,4 +1,5 @@
-from rapidata.rapidata_client.workflow.referee.base_referee import Referee
+from openapi_client.models.naive_referee_model import NaiveRefereeModel
+from rapidata.rapidata_client.referee.base_referee import Referee
 
 
 class NaiveReferee(Referee):
@@ -16,3 +17,6 @@ class NaiveReferee(Referee):
             "_t": "NaiveRefereeConfig",
             "guessesRequired": self.required_guesses,
         }
+
+    def to_model(self):
+        return NaiveRefereeModel(_t="NaiveReferee", totalVotes=self.required_guesses)

rapidata/rapidata_client/workflow/__init__.py

@@ -2,5 +2,3 @@ from .base_workflow import Workflow as Workflow
 from .classify_workflow import ClassifyWorkflow as ClassifyWorkflow
 from .compare_workflow import CompareWorkflow as CompareWorkflow
 from .free_text_workflow import FreeTextWorkflow as FreeTextWorkflow
-from .feature_flags import FeatureFlags as FeatureFlags
-from .country_codes import CountryCodes as CountryCodes

rapidata/rapidata_client/workflow/base_workflow.py

@@ -1,16 +1,16 @@
-from abc import ABC
+from abc import ABC, abstractmethod
 from typing import Any
 
-from rapidata.rapidata_client.workflow.feature_flags import FeatureFlags
-from rapidata.rapidata_client.workflow.referee.base_referee import Referee
-from rapidata.rapidata_client.workflow.referee.naive_referee import NaiveReferee
+from openapi_client.models.simple_workflow_model import SimpleWorkflowModel
+from rapidata.rapidata_client.feature_flags import FeatureFlags
+from rapidata.rapidata_client.referee.base_referee import Referee
+from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 
 
 class Workflow(ABC):
     
     def __init__(self, type: str):
         self._type = type
-        self._referee = NaiveReferee()
         self._target_country_codes: list[str] = []
         self._feature_flags: FeatureFlags = FeatureFlags()
 
@@ -21,6 +21,10 @@ class Workflow(ABC):
             "targetCountryCodes": self._target_country_codes,
             "featureFlags": self._feature_flags.to_list(),
         }
+    
+    @abstractmethod
+    def to_model(self) -> SimpleWorkflowModel:
+        pass
 
     def referee(self, referee: Referee):
         self._referee = referee

rapidata/rapidata_client/workflow/classify_workflow.py

@@ -1,12 +1,15 @@
 from typing import Any
+from openapi_client.models.attach_category_rapid_blueprint import AttachCategoryRapidBlueprint
+from openapi_client.models.simple_workflow_model import SimpleWorkflowModel
+from openapi_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
 from rapidata.rapidata_client.workflow import Workflow
 
 
 class ClassifyWorkflow(Workflow):
-    def __init__(self, question: str, categories: list[str]):
+    def __init__(self, question: str, options: list[str]):
         super().__init__(type="SimpleWorkflowConfig")
         self._question = question
-        self._categories = categories
+        self._options = options
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -14,6 +17,18 @@ class ClassifyWorkflow(Workflow):
             "blueprint": {
                 "_t": "ClassifyBlueprint",
                 "title": self._question,
-                "possibleCategories": self._categories,
+                "possibleCategories": self._options,
             }
         }
+
+    def to_model(self) -> SimpleWorkflowModel:
+        blueprint = AttachCategoryRapidBlueprint(
+            _t="ClassifyBlueprint",
+            title=self._question,
+            possibleCategories=self._options,
+        )
+
+        return SimpleWorkflowModel(
+            _t="SimpleWorkflow",
+            blueprint=SimpleWorkflowModelBlueprint(blueprint),
+        )

rapidata/rapidata_client/workflow/compare_workflow.py

@@ -1,14 +1,14 @@
 from typing import Any
+from openapi_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
 from rapidata.rapidata_client.workflow import Workflow
+from openapi_client.models.compare_rapid_blueprint import CompareRapidBlueprint
+from openapi_client.models.simple_workflow_model import SimpleWorkflowModel
 
 
 class CompareWorkflow(Workflow):
     def __init__(self, criteria: str):
         super().__init__(type="CompareWorkflowConfig")
         self._criteria = criteria
-        self._k_factor = 40
-        self._match_size = 2
-        self._matches_until_completed = 10
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -16,15 +16,14 @@ class CompareWorkflow(Workflow):
             "criteria": self._criteria,
         }
     
-    def k_factor(self, k_factor: int):
-        self._k_factor = k_factor
-        return self
-    
-    def match_size(self, match_size: int):
-        self._match_size = match_size
-        return self
-    
-    def matches_until_completed(self, matches_until_completed: int):
-        self._matches_until_completed = matches_until_completed
-        return self
+    def to_model(self) -> SimpleWorkflowModel:
+        blueprint = CompareRapidBlueprint(
+            _t="CompareBlueprint",
+            criteria=self._criteria,
+        )
+
+        return SimpleWorkflowModel(
+            _t="SimpleWorkflow",
+            blueprint=SimpleWorkflowModelBlueprint(blueprint),
+        )