rapidata 2.28.2__py3-none-any.whl → 2.44.3__py3-none-any.whl

rapidata/rapidata_client/workflow/__init__.py

@@ -1,6 +1,6 @@
 from ._locate_workflow import LocateWorkflow
 from ._draw_workflow import DrawWorkflow
-from ._base_workflow import Workflow 
+from ._base_workflow import Workflow
 from ._classify_workflow import ClassifyWorkflow
 from ._compare_workflow import CompareWorkflow
 from ._free_text_workflow import FreeTextWorkflow
@@ -8,3 +8,4 @@ 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

@@ -1,17 +1,17 @@
 from abc import ABC, abstractmethod
 from typing import Any
 
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
-from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
-from rapidata.rapidata_client.referee._base_referee import Referee
+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
-        self._target_country_codes: list[str] = []
 
     def _to_dict(self) -> dict[str, Any]:
         return {
@@ -19,7 +19,25 @@ class Workflow(ABC):
         }
 
     @abstractmethod
-    def _to_model(
+    def _to_payload(
         self,
-    ) -> SimpleWorkflowModel | CompareWorkflowModel | EvaluationWorkflowModel:
+        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

@@ -1,8 +1,23 @@
 from typing import Any
-from rapidata.api_client.models.attach_category_rapid_blueprint import AttachCategoryRapidBlueprint
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
+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):
@@ -21,29 +36,57 @@ class ClassifyWorkflow(Workflow):
         _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._question = instruction
-        self._options = answer_options
+        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._question,
-                "possibleCategories": self._options,
-            }
+                "title": self._instruction,
+                "possibleCategories": self._answer_options,
+            },
         }
 
-    def _to_model(self) -> SimpleWorkflowModel:
-        blueprint = AttachCategoryRapidBlueprint(
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintAttachCategoryRapidBlueprint(
             _t="ClassifyBlueprint",
-            title=self._question,
-            possibleCategories=self._options,
+            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),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(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

@@ -1,8 +1,19 @@
 from typing import Any
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
+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.compare_rapid_blueprint import CompareRapidBlueprint
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
+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):
@@ -19,23 +30,47 @@ class CompareWorkflow(Workflow):
         instruction (str): The instruction to be used for comparison.
     """
 
-    def __init__(self, instruction: str):
+    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) -> SimpleWorkflowModel:
-        blueprint = CompareRapidBlueprint(
+    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),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(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

@@ -1,22 +1,52 @@
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.api_client.models.line_rapid_blueprint import LineRapidBlueprint
+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 _to_model(self) -> SimpleWorkflowModel:
-        blueprint = LineRapidBlueprint(
-            _t="LineBlueprint",
-            target=self._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),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(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

@@ -1,5 +1,10 @@
-from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
 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):
@@ -7,20 +12,36 @@ 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 _to_model(self):
-        return EvaluationWorkflowModel(
-            _t="EvaluationWorkflow",
-            validationSetId=self.validation_set_id,
-            shouldAcceptIncorrect=self.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

@@ -1,8 +1,19 @@
 from typing import Any
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
 from rapidata.rapidata_client.workflow import Workflow
-from rapidata.api_client.models.free_text_rapid_blueprint import FreeTextRapidBlueprint
+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):
@@ -17,11 +28,19 @@ class FreeTextWorkflow(Workflow):
 
     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'.
     """
 
-    def __init__(self, instruction: str):
+    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 {
@@ -29,16 +48,34 @@ class FreeTextWorkflow(Workflow):
             "blueprint": {
                 "_t": "FreeTextBlueprint",
                 "question": self._instruction,
+                "validationSystemPrompt": self._validation_system_prompt,
             },
         }
 
-    def _to_model(self) -> SimpleWorkflowModel:
-        blueprint = FreeTextRapidBlueprint(
+    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),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(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

@@ -1,22 +1,52 @@
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.api_client.models.locate_rapid_blueprint import LocateRapidBlueprint
+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 _to_model(self) -> SimpleWorkflowModel:
-        blueprint = LocateRapidBlueprint(
-            _t="LocateBlueprint",
-            target=self._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),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(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})"