rapidata 0.5.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

rapidata/rapidata_client/dataset/validation_set_builder.py

@@ -6,6 +6,9 @@ from rapidata.api_client.models.compare_truth import CompareTruth
 from rapidata.api_client.models.transcription_payload import TranscriptionPayload
 from rapidata.api_client.models.transcription_truth import TranscriptionTruth
 from rapidata.api_client.models.transcription_word import TranscriptionWord
+from rapidata.rapidata_client.assets.media_asset import MediaAsset
+from rapidata.rapidata_client.assets.multi_asset import MultiAsset
+from rapidata.rapidata_client.assets.text_asset import TextAsset
 from rapidata.rapidata_client.dataset.rapidata_validation_set import (
     RapidataValidationSet,
 )
@@ -16,21 +19,31 @@ from rapidata.service.openapi_service import OpenAPIService
 
 class ValidationSetBuilder:
     """The ValidationSetBuilder is used to build a validation set.
-    Give the validation set a name and then add classify, compare or transcription rapid parts to it.
+    Give the validation set a name and then add classify, compare, or transcription rapid parts to it.
     Get a `ValidationSetBuilder` by calling [`rapi.new_validation_set()`](../rapidata_client.md/#rapidata.rapidata_client.rapidata_client.RapidataClient.new_validation_set).
     """
 
     def __init__(self, name: str, openapi_service: OpenAPIService):
+        """
+        Initialize the ValidationSetBuilder.
+
+        Args:
+            name (str): The name of the validation set.
+            openapi_service (OpenAPIService): An instance of OpenAPIService to interact with the API.
+        """
         self.name = name
         self.openapi_service = openapi_service
         self.validation_set_id: str | None = None
         self._rapid_parts: list[ValidatioRapidParts] = []
 
     def create(self):
-        """This creates the validation set by executing all http requests. This should be the last method called on the builder.
+        """Create the validation set by executing all HTTP requests. This should be the last method called on the builder.
 
         Returns:
             RapidataValidationSet: A RapidataValidationSet instance.
+
+        Raises:
+            ValueError: If the validation set creation fails.
         """
         result = (
             self.openapi_service.validation_api.validation_create_validation_set_post(
@@ -52,7 +65,7 @@ class ValidationSetBuilder:
                 payload=rapid_part.payload,
                 truths=rapid_part.truths,
                 metadata=rapid_part.metadata,
-                media_paths=rapid_part.media_paths,
+                asset=rapid_part.asset,
                 randomCorrectProbability=rapid_part.randomCorrectProbability,
             )
 
@@ -60,7 +73,7 @@ class ValidationSetBuilder:
 
     def add_classify_rapid(
         self,
-        media_path: str,
+        asset: MediaAsset | TextAsset,
         question: str,
         categories: list[str],
         truths: list[str],
@@ -69,14 +82,17 @@ class ValidationSetBuilder:
         """Add a classify rapid to the validation set.
 
         Args:
-            media_path (str): The path to the media file.
+            asset (MediaAsset | TextAsset): The asset for the rapid.
             question (str): The question for the rapid.
             categories (list[str]): The list of categories for the rapid.
             truths (list[str]): The list of truths for the rapid.
-            metadata (list[Metadata], optional): The metadata for the rapid.
+            metadata (list[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
 
         Returns:
             ValidationSetBuilder: The ValidationSetBuilder instance.
+
+        Raises:
+            ValueError: If the lengths of categories and truths are inconsistent.
         """
         payload = ClassifyPayload(
             _t="ClassifyPayload", possibleCategories=categories, title=question
@@ -88,11 +104,11 @@ class ValidationSetBuilder:
         self._rapid_parts.append(
             ValidatioRapidParts(
                 question=question,
-                media_paths=media_path,
                 payload=payload,
                 truths=model_truth,
                 metadata=metadata,
                 randomCorrectProbability=len(truths) / len(categories),
+                asset=asset,
             )
         )
 
@@ -100,7 +116,7 @@ class ValidationSetBuilder:
 
     def add_compare_rapid(
         self,
-        media_paths: list[str],
+        asset: MultiAsset,
         question: str,
         truth: str,
         metadata: list[Metadata] = [],
@@ -108,35 +124,33 @@ class ValidationSetBuilder:
         """Add a compare rapid to the validation set.
 
         Args:
-            media_paths (list[str]): The list of media paths for the rapid.
+            asset (MultiAsset): The assets for the rapid.
             question (str): The question for the rapid.
-            truth (str): The path to the truth file.
-            metadata (list[Metadata], optional): The metadata for the rapid.
+            truth (str): The truth identifier for the rapid.
+            metadata (list[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
 
         Returns:
             ValidationSetBuilder: The ValidationSetBuilder instance.
+
+        Raises:
+            ValueError: If the number of assets is not exactly two.
         """
         payload = ComparePayload(_t="ComparePayload", criteria=question)
         # take only last part of truth path
         truth = os.path.basename(truth)
         model_truth = CompareTruth(_t="CompareTruth", winnerId=truth)
 
-        if len(media_paths) != 2:
+        if len(asset) != 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=metadata,
-                randomCorrectProbability=1 / len(media_paths),
+                randomCorrectProbability=1 / len(asset),
+                asset=asset,
             )
         )
 
@@ -144,7 +158,7 @@ class ValidationSetBuilder:
 
     def add_transcription_rapid(
         self,
-        media_path: str,
+        asset: MediaAsset | TextAsset,
         question: str,
         transcription: list[str],
         correct_words: list[str],
@@ -154,15 +168,18 @@ class ValidationSetBuilder:
         """Add a transcription rapid to the validation set.
 
         Args:
-            media_path (str): The path to the media file.
+            asset (MediaAsset | TextAsset): The asset for the rapid.
             question (str): The question for the rapid.
             transcription (list[str]): The transcription for the rapid.
             correct_words (list[str]): The list of correct words for the rapid.
-            strict_grading (bool | None, optional): The strict grading for the rapid. Defaults to None.
-            metadata (list[Metadata], optional): The metadata for the rapid.
+            strict_grading (bool | None, optional): The strict grading flag for the rapid. Defaults to None.
+            metadata (list[Metadata], optional): The metadata for the rapid. Defaults to an empty list.
 
         Returns:
             ValidationSetBuilder: The ValidationSetBuilder instance.
+
+        Raises:
+            ValueError: If a correct word is not found in the transcription.
         """
         transcription_words = [
             TranscriptionWord(word=word, wordIndex=i)
@@ -190,7 +207,7 @@ class ValidationSetBuilder:
         self._rapid_parts.append(
             ValidatioRapidParts(
                 question=question,
-                media_paths=media_path,
+                asset=asset,
                 payload=payload,
                 truths=model_truth,
                 metadata=metadata,

rapidata/rapidata_client/order/rapidata_order_builder.py

@@ -1,11 +1,11 @@
 from rapidata.api_client.models.aggregator_type import AggregatorType
+from rapidata.api_client.models.capped_selection_selections_inner import (
+    CappedSelectionSelectionsInner,
+)
 from rapidata.api_client.models.create_order_model import CreateOrderModel
 from rapidata.api_client.models.create_order_model_referee import (
     CreateOrderModelReferee,
 )
-from rapidata.api_client.models.create_order_model_selections_inner import (
-    CreateOrderModelSelectionsInner,
-)
 from rapidata.api_client.models.create_order_model_user_filters_inner import (
     CreateOrderModelUserFiltersInner,
 )
@@ -41,6 +41,13 @@ class RapidataOrderBuilder:
         openapi_service: OpenAPIService,
         name: str,
     ):
+        """
+        Initialize the RapidataOrderBuilder.
+
+        Args:
+            openapi_service (OpenAPIService): The OpenAPIService instance.
+            name (str): The name of the order.
+        """
         self._name = name
         self._openapi_service = openapi_service
         self._workflow: Workflow | None = None
@@ -54,8 +61,19 @@ class RapidataOrderBuilder:
         self._selections: list[Selection] = []
         self._rapids_per_bag: int = 2
         self._priority: int = 50
+        self._texts: list[str] | None = None
+        self._media_paths: list[str | list[str]] = []
 
     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.")
 
@@ -86,27 +104,34 @@ class RapidataOrderBuilder:
                 else None
             ),
             selections=[
-                CreateOrderModelSelectionsInner(selection.to_model())
+                CappedSelectionSelectionsInner(selection.to_model())
                 for selection in self._selections
             ],
             priority=self._priority,
         )
 
-    def create(self, submit=True, max_workers=10) -> RapidataOrder:
-        """Actually makes the API calls to create the order based on how the order builder was configured.
+    def create(self, submit: bool = True, max_workers: int = 10) -> RapidataOrder:
+        """
+        Create the Rapidata order by making the necessary API calls based on the builder's configuration.
 
         Args:
-            submit (bool, optional): Whether to submit the order. Defaults to True.
+            submit (bool, optional): Whether to submit the order upon creation. Defaults to True.
+            max_workers (int, optional): The maximum number of worker threads for processing media paths. Defaults to 10.
+
+        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.
-
-        Raises:
-            ValueError: If no workflow is provided.
         """
         order_model = self._to_model()
-        if isinstance(self._workflow, CompareWorkflow): # temp fix, will be handeled by backend in the future
-            assert all([len(path) == 2 for path in self._media_paths]), "The media paths must come in pairs for comparison tasks."
+        if isinstance(
+            self._workflow, CompareWorkflow
+        ):  # Temporary fix; will be handled by backend in the future
+            assert all(
+                [len(path) == 2 for path in self._media_paths]
+            ), "The media paths must come in pairs for comparison tasks."
 
         result = self._openapi_service.order_api.order_create_post(
             create_order_model=order_model
@@ -120,14 +145,32 @@ class RapidataOrderBuilder:
             openapi_service=self._openapi_service,
         )
 
-        order.dataset.add_media_from_paths(self._media_paths, self._metadata, max_workers)
+        if self._media_paths and self._texts:
+            raise ValueError(
+                "You cannot provide both media paths and texts to the same order."
+            )
+
+        if not self._media_paths and not self._texts:
+            raise ValueError(
+                "You must provide either media paths or texts to the order."
+            )
+
+        if self._texts:
+            order.dataset.add_texts(self._texts)
+
+        if self._media_paths:
+            order.dataset.add_media_from_paths(
+                self._media_paths, self._metadata, max_workers
+            )
+
         if submit:
             order.submit()
 
         return order
 
-    def workflow(self, workflow: Workflow):
-        """Set the workflow for the order.
+    def workflow(self, workflow: Workflow) -> "RapidataOrderBuilder":
+        """
+        Set the workflow for the order.
 
         Args:
             workflow (Workflow): The workflow to be set.
@@ -138,8 +181,9 @@ class RapidataOrderBuilder:
         self._workflow = workflow
         return self
 
-    def referee(self, referee: Referee):
-        """Set the referee for the order.
+    def referee(self, referee: Referee) -> "RapidataOrderBuilder":
+        """
+        Set the referee for the order.
 
         Args:
             referee (Referee): The referee to be set.
@@ -154,8 +198,9 @@ class RapidataOrderBuilder:
         self,
         media_paths: list[str | list[str]],
         metadata: list[Metadata] | None = None,
-    ):
-        """Set the media assets for the order.
+    ) -> "RapidataOrderBuilder":
+        """
+        Set the media assets for the order.
 
         Args:
             media_paths (list[str | list[str]]): The paths of the media assets to be set.
@@ -168,8 +213,22 @@ class RapidataOrderBuilder:
         self._metadata = metadata
         return self
 
-    def feature_flags(self, feature_flags: FeatureFlags):
-        """Set the feature flags for the order.
+    def texts(self, texts: list[str]) -> "RapidataOrderBuilder":
+        """
+        Set the TextAssets for the order.
+
+        Args:
+            texts (list[str]): The texts to be set.
+
+        Returns:
+            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
+        """
+        self._texts = texts
+        return self
+
+    def feature_flags(self, feature_flags: FeatureFlags) -> "RapidataOrderBuilder":
+        """
+        Set the feature flags for the order.
 
         Args:
             feature_flags (FeatureFlags): The feature flags to be set.
@@ -180,8 +239,9 @@ class RapidataOrderBuilder:
         self._feature_flags = feature_flags
         return self
 
-    def country_filter(self, country_codes: list[str]):
-        """Set the target country codes for the order.
+    def country_filter(self, country_codes: list[str]) -> "RapidataOrderBuilder":
+        """
+        Set the target country codes for the order.
 
         Args:
             country_codes (list[str]): The country codes to be set.
@@ -192,8 +252,9 @@ class RapidataOrderBuilder:
         self._country_codes = country_codes
         return self
 
-    def aggregator(self, aggregator: AggregatorType):
-        """Set the aggregator for the order.
+    def aggregator(self, aggregator: AggregatorType) -> "RapidataOrderBuilder":
+        """
+        Set the aggregator for the order.
 
         Args:
             aggregator (AggregatorType): The aggregator to be set.
@@ -204,8 +265,9 @@ class RapidataOrderBuilder:
         self._aggregator = aggregator
         return self
 
-    def validation_set_id(self, validation_set_id: str):
-        """Set the validation set for the order.
+    def validation_set_id(self, validation_set_id: str) -> "RapidataOrderBuilder":
+        """
+        Set the validation set ID for the order.
 
         Args:
             validation_set_id (str): The validation set ID to be set.
@@ -216,8 +278,9 @@ class RapidataOrderBuilder:
         self._validation_set_id = validation_set_id
         return self
 
-    def rapids_per_bag(self, amount: int):
-        """Defines the number of tasks a user sees in a single session.
+    def rapids_per_bag(self, amount: int) -> "RapidataOrderBuilder":
+        """
+        Define the number of tasks a user sees in a single session.
 
         Args:
             amount (int): The number of tasks a user sees in a single session.
@@ -230,8 +293,9 @@ class RapidataOrderBuilder:
         """
         raise NotImplementedError("Not implemented yet.")
 
-    def selections(self, selections: list[Selection]):
-        """Set the selections for the order.
+    def selections(self, selections: list[Selection]) -> "RapidataOrderBuilder":
+        """
+        Set the selections for the order.
 
         Args:
             selections (list[Selection]): The selections to be set.
@@ -242,8 +306,9 @@ class RapidataOrderBuilder:
         self._selections = selections
         return self
 
-    def priority(self, priority: int):
-        """Set the priority for the order.
+    def priority(self, priority: int) -> "RapidataOrderBuilder":
+        """
+        Set the priority for the order.
 
         Args:
             priority (int): The priority to be set.

rapidata/rapidata_client/rapidata_client.py

@@ -8,6 +8,8 @@ from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.dataset.rapidata_dataset import RapidataDataset
 
+from rapidata.rapidata_client.simple_builders.simple_classification_builders import ClassificationQuestionBuilder
+from rapidata.rapidata_client.simple_builders.simple_compare_builders import CompareCriteriaBuilder
 
 
 class RapidataClient:
@@ -81,6 +83,28 @@ class RapidataClient:
             dataset=temp_dataset, 
             order_id=order_id, 
             openapi_service=self.openapi_service)
+    
+    def create_classify_order(self, name: str) -> ClassificationQuestionBuilder:
+        """Create a new classification order where people are asked to classify an image.
+
+        Args:
+            name (str): The name of the order.
+
+        Returns:
+            ClassificationQuestionBuilder: A ClassificationQuestionBuilder instance.
+        """
+        return ClassificationQuestionBuilder(name=name, openapi_service=self.openapi_service)
+    
+    def create_compare_order(self, name: str) -> CompareCriteriaBuilder:
+        """Create a new comparison order where people are asked to compare two images.
+
+        Args:
+            name (str): The name of the order.
+
+        Returns:
+            CompareQuestionBuilder: A CompareQuestionBuilder instance.
+        """
+        return CompareCriteriaBuilder(name=name, openapi_service=self.openapi_service)
 
     @property
     def utils(self) -> Utils:

rapidata/rapidata_client/simple_builders/simple_classification_builders.py

@@ -0,0 +1,122 @@
+from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
+from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
+from rapidata.rapidata_client.referee.classify_early_stopping_referee import ClassifyEarlyStoppingReferee
+from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.workflow.classify_workflow import ClassifyWorkflow
+from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
+from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
+from rapidata.service.openapi_service import OpenAPIService
+
+class ClassificationOrderBuilder:
+    def __init__(self, name: str, question: str, options: list[str], media_paths: list[str], openapi_service: OpenAPIService):
+        self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
+        self._question = question
+        self._options = options
+        self._media_paths = media_paths
+        self._responses_required = 10
+        self._probability_threshold = None
+        self._metadata = None
+        self._validation_set_id = None
+
+    def metadata(self, metadata: list[Metadata]):
+        """Set the metadata for the classification order. Has to be the same lenght as the media paths."""
+        self._metadata = metadata
+        return self
+
+    def responses(self, responses_required: int):
+        """Set the number of responses required for the classification order."""
+        self._responses_required = responses_required
+        return self
+    
+    def probability_threshold(self, probability_threshold: float):
+        """Set the probability threshold for early stopping."""
+        self._probability_threshold = probability_threshold
+        return self
+    
+    def validation_set_id(self, validation_set_id: str):
+        """Set the validation set ID for the classification order."""
+        self._validation_set_id = validation_set_id
+        return self
+    
+    def create(self, submit: bool = True, max_upload_workers: int = 10):
+        if self._probability_threshold and self._responses_required:
+            referee = ClassifyEarlyStoppingReferee(
+                max_vote_count=self._responses_required,
+                threshold=self._probability_threshold
+            )
+            
+        else:
+            referee = NaiveReferee(required_guesses=self._responses_required)
+        
+        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), LabelingSelection(amount=2)] 
+                     if self._validation_set_id 
+                     else [LabelingSelection(amount=3)])
+
+        order = (self._order_builder
+            .workflow(
+                ClassifyWorkflow(
+                    question=self._question,
+                    options=self._options
+                )
+            )
+            .referee(referee)
+            .media(self._media_paths, metadata=self._metadata) # type: ignore
+            .selections(selection)
+            .create(submit=submit, max_workers=max_upload_workers))
+
+        return order 
+    
+
+class ClassificationMediaBuilder:
+    def __init__(self, name: str, question: str, options: list[str], openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._question = question
+        self._options = options
+        self._media_paths = None
+
+    def media(self, media_paths: list[str]) -> ClassificationOrderBuilder:
+        """Set the media assets for the classification order by providing the local paths to the files."""
+        self._media_paths = media_paths
+        return self._build()
+
+    def _build(self) -> ClassificationOrderBuilder:
+        if self._media_paths is None:
+            raise ValueError("Media paths are required")
+        return ClassificationOrderBuilder(self._name, self._question, self._options, self._media_paths, openapi_service=self._openapi_service)
+    
+
+class ClassificationOptionsBuilder:
+    def __init__(self, name: str, question: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._question = question
+        self._options = None
+
+    def options(self, options: list[str]) -> ClassificationMediaBuilder:
+        """Set the answer options for the classification order."""
+        self._options = options
+        return self._build()
+
+    def _build(self) -> ClassificationMediaBuilder:
+        if self._options is None:
+            raise ValueError("Options are required")
+        return ClassificationMediaBuilder(self._name, self._question, self._options, self._openapi_service)
+
+
+class ClassificationQuestionBuilder:
+    def __init__(self, name: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._question = None
+
+    def question(self, question: str) -> ClassificationOptionsBuilder:
+        """Set the question for the classification order."""
+        self._question = question
+        return self._build()
+
+    def _build(self) -> ClassificationOptionsBuilder:
+        if self._question is None:
+            raise ValueError("Question is required")
+        return ClassificationOptionsBuilder(self._name, self._question, self._openapi_service)

rapidata/rapidata_client/simple_builders/simple_compare_builders.py

@@ -0,0 +1,86 @@
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
+from rapidata.rapidata_client.workflow.compare_workflow import CompareWorkflow
+from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
+from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
+from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
+from rapidata.rapidata_client.selection.base_selection import Selection
+
+class CompareOrderBuilder:
+    def __init__(self, name:str, criteria: str, media_paths: list[list[str]], openapi_service: OpenAPIService):
+        self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
+        self._name = name
+        self._criteria = criteria
+        self._media_paths = media_paths
+        self._responses_required = 10
+        self._metadata = None
+        self._validation_set_id = None
+
+    def responses(self, responses_required: int) -> 'CompareOrderBuilder':
+        """Set the number of resoonses required per matchup/pairing for the comparison order."""
+        self._responses_required = responses_required
+        return self
+    
+    def metadata(self, metadata: list[Metadata]) -> 'CompareOrderBuilder':
+        """Set the metadata for the comparison order. Has to be the same shape as the media paths."""
+        self._metadata = metadata
+        return self
+    
+    def validation_set_id(self, validation_set_id: str) -> 'CompareOrderBuilder':
+        """Set the validation set ID for the comparison order."""
+        self._validation_set_id = validation_set_id
+        return self
+    
+    def create(self, submit: bool = True, max_upload_workers: int = 10):
+        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), LabelingSelection(amount=2)] 
+                     if self._validation_set_id 
+                     else [LabelingSelection(amount=3)])
+        
+        order = (self._order_builder
+            .workflow(
+                CompareWorkflow(
+                    criteria=self._criteria
+                )
+            )
+            .referee(NaiveReferee(required_guesses=self._responses_required))
+            .media(self._media_paths, metadata=self._metadata) # type: ignore
+            .selections(selection)
+            .create(submit=submit, max_workers=max_upload_workers))
+        
+        return order
+
+class CompareMediaBuilder:
+    def __init__(self, name: str, criteria: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._criteria = criteria
+        self._media_paths = None
+
+    def media(self, media_paths: list[list[str]]) -> CompareOrderBuilder:
+        """Set the media assets for the comparison order by providing the local paths to the files."""
+        self._media_paths = media_paths
+        return self._build()
+    
+    def _build(self) -> CompareOrderBuilder:
+        if self._media_paths is None:
+            raise ValueError("Media paths are required")
+        assert all([len(path) == 2 for path in self._media_paths]), "The media paths must come in pairs for comparison tasks."
+        return CompareOrderBuilder(self._name, self._criteria, self._media_paths, self._openapi_service)
+
+class CompareCriteriaBuilder:
+    def __init__(self, name: str, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+        self._name = name
+        self._criteria = None
+
+    def criteria(self, criteria: str) -> CompareMediaBuilder:
+        """Set the criteria how the images should be compared."""
+        self._criteria = criteria
+        return self._build()
+    
+    def _build(self) -> CompareMediaBuilder:
+        if self._criteria is None:
+            raise ValueError("Criteria are required")
+        return CompareMediaBuilder(self._name, self._criteria, self._openapi_service)
+