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

rapidata/rapidata_client/workflow/__init__.py

@@ -1,6 +1,11 @@
-from .base_workflow import Workflow 
-from .classify_workflow import ClassifyWorkflow
-from .compare_workflow import CompareWorkflow
-from .free_text_workflow import FreeTextWorkflow
-from .transcription_workflow import TranscriptionWorkflow
-from .evaluation_workflow import EvaluationWorkflow
+from ._locate_workflow import LocateWorkflow
+from ._draw_workflow import DrawWorkflow
+from ._base_workflow import Workflow
+from ._classify_workflow import ClassifyWorkflow
+from ._compare_workflow import CompareWorkflow
+from ._free_text_workflow import FreeTextWorkflow
+from ._select_words_workflow import SelectWordsWorkflow
+from ._evaluation_workflow import EvaluationWorkflow
+from ._timestamp_workflow import TimestampWorkflow
+from ._ranking_workflow import RankingWorkflow
+from ._multi_ranking_workflow import MultiRankingWorkflow

rapidata/rapidata_client/workflow/_base_workflow.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+
+
+class Workflow(ABC):
+    modality: RapidModality
+
+    def __init__(self, type: str):
+        self._type = type
+
+    def _to_dict(self) -> dict[str, Any]:
+        return {
+            "_t": self._type,
+        }
+
+    @abstractmethod
+    def _to_payload(
+        self,
+        datapoint: Datapoint,
+    ) -> IRapidPayload:
+        pass
+
+    @abstractmethod
+    def _get_instruction(self) -> str:
+        pass
+
+    @abstractmethod
+    def _to_model(self) -> IOrderWorkflowModel:
+        pass
+
+    def _format_datapoints(self, datapoints: list[Datapoint]) -> list[Datapoint]:
+        return datapoints
+
+    def __str__(self) -> str:
+        return self._type
+
+    def __repr__(self) -> str:
+        return self._type

rapidata/rapidata_client/workflow/_classify_workflow.py

@@ -0,0 +1,92 @@
+from typing import Any
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.attach_category_rapid_blueprint_category import (
+    AttachCategoryRapidBlueprintCategory,
+)
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_classify_payload import (
+    IRapidPayloadClassifyPayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.classify_payload_category import ClassifyPayloadCategory
+from rapidata.api_client.models.i_rapid_blueprint_attach_category_rapid_blueprint import (
+    IRapidBlueprintAttachCategoryRapidBlueprint,
+)
+
+
+class ClassifyWorkflow(Workflow):
+    """
+    A workflow for classification tasks.
+
+    This class represents a classification workflow where a question is presented
+    along with a list of possible options for classification.
+
+    Args:
+        question (str): The classification question to be presented.
+        options (list[str]): A list of possible classification options.
+
+    Attributes:
+        _question (str): The classification question.
+        _options (list[str]): The list of classification options.
+    """
+
+    modality = RapidModality.CLASSIFY
+
+    def __init__(self, instruction: str, answer_options: list[str]):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._instruction = instruction
+        self._answer_options = answer_options
+
+    def _get_instruction(self) -> str:
+        return self._instruction
+
+    def _to_dict(self) -> dict[str, Any]:
+        return {
+            **super()._to_dict(),
+            "blueprint": {
+                "_t": "ClassifyBlueprint",
+                "title": self._instruction,
+                "possibleCategories": self._answer_options,
+            },
+        }
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintAttachCategoryRapidBlueprint(
+            _t="ClassifyBlueprint",
+            title=self._instruction,
+            categories=[
+                AttachCategoryRapidBlueprintCategory(label=option, value=option)
+                for option in self._answer_options
+            ],
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadClassifyPayload(
+                _t="ClassifyPayload",
+                categories=[
+                    ClassifyPayloadCategory(label=option, value=option)
+                    for option in self._answer_options
+                ],
+                title=self._instruction,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"ClassifyWorkflow(instruction='{self._instruction}', options={self._answer_options})"
+
+    def __repr__(self) -> str:
+        return f"ClassifyWorkflow(instruction='{self._instruction}', answer_options={self._answer_options!r})"

rapidata/rapidata_client/workflow/_compare_workflow.py

@@ -0,0 +1,76 @@
+from typing import Any
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint_compare_rapid_blueprint import (
+    IRapidBlueprintCompareRapidBlueprint,
+)
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_compare_payload import (
+    IRapidPayloadComparePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.rapid_modality import RapidModality
+
+
+class CompareWorkflow(Workflow):
+    """
+    A workflow for comparison tasks.
+
+    This class represents a comparison workflow where items are compared based on
+    specified instruction.
+
+    Attributes:
+        _instruction (str): The instruction used for comparison.
+
+    Args:
+        instruction (str): The instruction to be used for comparison.
+    """
+
+    modality = RapidModality.COMPARE
+
+    def __init__(self, instruction: str, a_b_names: list[str] | None = None):
+        super().__init__(type="CompareWorkflowConfig")
+        self._instruction = instruction
+        self._a_b_names = a_b_names
+
+    def _get_instruction(self) -> str:
+        return self._instruction
+
+    def _to_dict(self) -> dict[str, Any]:
+        return {
+            **super()._to_dict(),
+            "criteria": self._instruction,
+            "indexIdentifiers": self._a_b_names,
+        }
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintCompareRapidBlueprint(
+            _t="CompareBlueprint",
+            criteria=self._instruction,
+            indexIdentifiers=self._a_b_names,
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadComparePayload(
+                _t="ComparePayload",
+                criteria=self._instruction,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"CompareWorkflow(instruction='{self._instruction}', a_b_names={self._a_b_names})"
+
+    def __repr__(self) -> str:
+        return f"CompareWorkflow(instruction={self._instruction!r}, a_b_names={self._a_b_names!r})"

rapidata/rapidata_client/workflow/_draw_workflow.py

@@ -0,0 +1,52 @@
+from rapidata.api_client.models.add_validation_rapid_model import IRapidPayload
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_rapid_blueprint_line_rapid_blueprint import (
+    IRapidBlueprintLineRapidBlueprint,
+)
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_line_payload import (
+    IRapidPayloadLinePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+
+
+class DrawWorkflow(Workflow):
+    modality = RapidModality.LINE
+
+    def __init__(self, target: str):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._target = target
+
+    def _get_instruction(self) -> str:
+        return self._target
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintLineRapidBlueprint(
+            _t="LineBlueprint", target=self._target
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadLinePayload(
+                _t="LinePayload",
+                target=self._target,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"DrawWorkflow(target='{self._target}')"
+
+    def __repr__(self) -> str:
+        return f"DrawWorkflow(target={self._target!r})"

rapidata/rapidata_client/workflow/_evaluation_workflow.py

@@ -0,0 +1,47 @@
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_evaluation_workflow_model import (
+    IOrderWorkflowModelEvaluationWorkflowModel,
+)
+
+
+class EvaluationWorkflow(Workflow):
+    """
+    A workflow to run evaluation orders.
+
+    This is used internally only and should not be necessary to be used by clients.
+
+    Args:
+        validation_set_id (str): a source for the tasks that will be sent to the user
+        should_accept_incorrect (bool): indicates if the user should get feedback on their answers if they answer wrong. If set to true the user will not notice that he was tested.
+    """
+
+    modality = RapidModality.NONE
+
+    def __init__(self, validation_set_id: str, should_accept_incorrect: bool):
+        super().__init__("EvaluationWorkflow")
+        self.validation_set_id = validation_set_id
+        self.should_accept_incorrect = should_accept_incorrect
+
+    def _get_instruction(self) -> str:
+        return ""
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelEvaluationWorkflowModel(
+                _t="EvaluationWorkflow",
+                validationSetId=self.validation_set_id,
+                shouldAcceptIncorrect=self.should_accept_incorrect,
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint):
+        raise NotImplementedError("EvaluationWorkflow does not have a payload")
+
+    def __str__(self) -> str:
+        return f"EvaluationWorkflow(validation_set_id='{self.validation_set_id}', should_accept_incorrect={self.should_accept_incorrect})"
+
+    def __repr__(self) -> str:
+        return f"EvaluationWorkflow(validation_set_id={self.validation_set_id!r}, should_accept_incorrect={self.should_accept_incorrect!r})"

rapidata/rapidata_client/workflow/_free_text_workflow.py

@@ -0,0 +1,81 @@
+from typing import Any
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_free_text_payload import (
+    IRapidPayloadFreeTextPayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_rapid_blueprint_free_text_rapid_blueprint import (
+    IRapidBlueprintFreeTextRapidBlueprint,
+)
+
+
+class FreeTextWorkflow(Workflow):
+    """
+    A workflow for free text input tasks.
+
+    This class represents a workflow where users can provide free-form text responses
+    to a given instruction.
+
+    Attributes:
+        _instruction (str): The instruction to be answered with free text.
+
+    Args:
+        instruction (str): The instruction to be presented for free text input.
+        validation_system_prompt (str): The system prompt to determine if the provided free text response is spam or not.
+            Should always specify that the LLM should respond with 'not spam' or 'spam'.
+    """
+
+    modality = RapidModality.FREETEXT
+
+    def __init__(self, instruction: str, validation_system_prompt: str | None = None):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._instruction = instruction
+        self._validation_system_prompt = validation_system_prompt
+
+    def _get_instruction(self) -> str:
+        return self._instruction
+
+    def _to_dict(self) -> dict[str, Any]:
+        return {
+            **super()._to_dict(),
+            "blueprint": {
+                "_t": "FreeTextBlueprint",
+                "question": self._instruction,
+                "validationSystemPrompt": self._validation_system_prompt,
+            },
+        }
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintFreeTextRapidBlueprint(
+            _t="FreeTextBlueprint",
+            question=self._instruction,
+            validationSystemPrompt=self._validation_system_prompt,
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadFreeTextPayload(
+                _t="FreeTextPayload",
+                question=self._instruction,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"FreeTextWorkflow(instruction='{self._instruction}', validation_system_prompt={self._validation_system_prompt})"
+
+    def __repr__(self) -> str:
+        return f"FreeTextWorkflow(instruction={self._instruction!r}, validation_system_prompt={self._validation_system_prompt!r})"

rapidata/rapidata_client/workflow/_locate_workflow.py

@@ -0,0 +1,52 @@
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_rapid_blueprint_locate_rapid_blueprint import (
+    IRapidBlueprintLocateRapidBlueprint,
+)
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_locate_payload import (
+    IRapidPayloadLocatePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+
+
+class LocateWorkflow(Workflow):
+    modality = RapidModality.LOCATE
+
+    def __init__(self, target: str):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._target = target
+
+    def _get_instruction(self) -> str:
+        return self._target
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintLocateRapidBlueprint(
+            _t="LocateBlueprint", target=self._target
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadLocatePayload(
+                _t="LocatePayload",
+                target=self._target,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"LocateWorkflow(target='{self._target}')"
+
+    def __repr__(self) -> str:
+        return f"LocateWorkflow(target={self._target!r})"

rapidata/rapidata_client/workflow/_multi_ranking_workflow.py

@@ -0,0 +1,87 @@
+from rapidata.api_client import (
+    CompareWorkflowModelPairMakerConfig,
+    OnlinePairMakerConfigModel,
+    EloConfigModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model import IRapidPayload
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_grouped_ranking_workflow_model import (
+    IOrderWorkflowModelGroupedRankingWorkflowModel,
+)
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_compare_payload import (
+    IRapidPayloadComparePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.i_asset_input import IAssetInput
+
+
+class MultiRankingWorkflow(Workflow):
+    modality = RapidModality.COMPARE
+
+    def __init__(
+        self,
+        instruction: str,
+        comparison_budget_per_ranking: int,
+        random_comparisons_ratio,
+        elo_start: int = 1200,
+        elo_k_factor: int = 40,
+        elo_scaling_factor: int = 400,
+        contexts: dict[str, str] | None = None,
+        media_contexts: dict[str, IAssetInput] | None = None,
+    ):
+        super().__init__(type="CompareWorkflowConfig")
+
+        self.contexts = contexts
+        self.media_contexts = media_contexts
+
+        self.instruction = instruction
+        self.comparison_budget_per_ranking = comparison_budget_per_ranking
+        self.random_comparisons_ratio = random_comparisons_ratio
+        self.elo_start = elo_start
+        self.elo_k_factor = elo_k_factor
+        self.elo_scaling_factor = elo_scaling_factor
+
+        self.pair_maker_config = CompareWorkflowModelPairMakerConfig(
+            OnlinePairMakerConfigModel(
+                _t="OnlinePairMaker",
+                totalComparisonBudget=comparison_budget_per_ranking,
+                randomMatchesRatio=random_comparisons_ratio,
+            )
+        )
+
+        self.elo_config = EloConfigModel(
+            startingElo=elo_start,
+            kFactor=elo_k_factor,
+            scalingFactor=elo_scaling_factor,
+        )
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelGroupedRankingWorkflowModel(
+                _t="GroupedRankingWorkflow",
+                criteria=self.instruction,
+                eloConfig=self.elo_config,
+                pairMakerConfig=self.pair_maker_config,
+                contexts=self.contexts,
+                contextAssets=self.media_contexts,
+            )
+        )
+
+    def _get_instruction(self) -> str:
+        return self.instruction
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadComparePayload(
+                _t="ComparePayload",
+                criteria=self.instruction,
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"MultiRankingWorkflow(instruction='{self.instruction}')"
+
+    def __repr__(self) -> str:
+        return f"MultiRankingWorkflow(instruction={self.instruction!r}, comparison_budget_per_ranking={self.comparison_budget_per_ranking!r}, random_comparisons_ratio={self.random_comparisons_ratio!r}, elo_start={self.elo_start!r}, elo_k_factor={self.elo_k_factor!r}, elo_scaling_factor={self.elo_scaling_factor!r})"

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -0,0 +1,131 @@
+from rapidata.api_client import (
+    CompareWorkflowModelPairMakerConfig,
+    OnlinePairMakerConfigModel,
+    EloConfigModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model import IRapidPayload
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_compare_workflow_model import (
+    IOrderWorkflowModelCompareWorkflowModel,
+)
+from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_compare_payload import (
+    IRapidPayloadComparePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.rapidata_client.datapoints.metadata import (
+    MediaAssetMetadata,
+    PromptMetadata,
+)
+from rapidata.api_client.models.metadata_i_order_metadata_input import (
+    MetadataIOrderMetadataInput,
+)
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+import itertools
+import random
+from typing import cast
+
+
+class RankingWorkflow(Workflow):
+    modality = RapidModality.COMPARE
+
+    def __init__(
+        self,
+        instruction: str,
+        total_comparison_budget: int,
+        random_comparisons_ratio,
+        elo_start: int = 1200,
+        elo_k_factor: int = 40,
+        elo_scaling_factor: int = 400,
+        media_context: str | None = None,
+        context: str | None = None,
+        file_uploader: AssetUploader | None = None,
+    ):
+        super().__init__(type="CompareWorkflowConfig")
+
+        self.media_context = media_context
+        self.context = context
+
+        self.metadatas = []
+        if media_context:
+            assert (
+                file_uploader is not None
+            ), "File uploader is required if media_context is provided"
+            self.metadatas.append(
+                MediaAssetMetadata(
+                    internal_file_name=file_uploader.upload_asset(media_context)
+                )
+            )
+        if context:
+            self.metadatas.append(PromptMetadata(prompt=context))
+
+        self.instruction = instruction
+        self.total_comparison_budget = total_comparison_budget
+        self.random_comparisons_ratio = random_comparisons_ratio
+        self.elo_start = elo_start
+        self.elo_k_factor = elo_k_factor
+        self.elo_scaling_factor = elo_scaling_factor
+
+        self.pair_maker_config = CompareWorkflowModelPairMakerConfig(
+            OnlinePairMakerConfigModel(
+                _t="OnlinePairMaker",
+                totalComparisonBudget=total_comparison_budget,
+                randomMatchesRatio=random_comparisons_ratio,
+            )
+        )
+
+        self.elo_config = EloConfigModel(
+            startingElo=elo_start,
+            kFactor=elo_k_factor,
+            scalingFactor=elo_scaling_factor,
+        )
+
+    def _get_instruction(self) -> str:
+        return self.instruction
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelCompareWorkflowModel(
+                _t="CompareWorkflow",
+                criteria=self.instruction,
+                eloConfig=self.elo_config,
+                pairMakerConfig=self.pair_maker_config,
+                metadata=[
+                    MetadataIOrderMetadataInput(metadata.to_model())
+                    for metadata in self.metadatas
+                ],
+            )
+        )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadComparePayload(
+                _t="ComparePayload",
+                criteria=self.instruction,
+            )
+        )
+
+    def _format_datapoints(self, datapoints: list[Datapoint]) -> list[Datapoint]:
+        if len(datapoints) < 3:
+            raise ValueError("RankingWorkflow requires at least three datapoints")
+        desired_length = len(datapoints)
+        assets = [datapoint.asset for datapoint in datapoints]
+        pairs = list(map(list, itertools.combinations(assets, 2)))
+        sampled_pairs = random.sample(pairs, desired_length)
+        formatted_datapoints = [
+            Datapoint(
+                asset=cast(list[str], pair),
+                data_type=datapoints[0].data_type,
+                context=self.context,
+                media_context=self.media_context,
+            )
+            for pair in sampled_pairs
+        ]
+        return formatted_datapoints
+
+    def __str__(self) -> str:
+        return f"RankingWorkflow(instruction='{self.instruction}', metadatas={self.metadatas})"
+
+    def __repr__(self) -> str:
+        return f"RankingWorkflow(instruction={self.instruction!r}, total_comparison_budget={self.total_comparison_budget!r}, random_comparisons_ratio={self.random_comparisons_ratio!r}, elo_start={self.elo_start!r}, elo_k_factor={self.elo_k_factor!r}, elo_scaling_factor={self.elo_scaling_factor!r}, metadatas={self.metadatas!r})"