rapidata 2.37.0__py3-none-any.whl → 3.0.0a8__py3-none-any.whl

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -1,50 +1,29 @@
-from typing import Sequence, Optional, Literal
-from itertools import zip_longest
+from __future__ import annotations
 
-from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.rapidata_client.order._rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.datapoints.metadata import (
-    PromptMetadata,
-    SelectWordsMetadata,
-    PrivateTextMetadata,
-    MediaAssetMetadata,
-    Metadata,
-)
-from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
-from rapidata.rapidata_client.referee._early_stopping_referee import (
-    EarlyStoppingReferee,
-)
-from rapidata.rapidata_client.selection._base_selection import RapidataSelection
-from rapidata.rapidata_client.workflow import (
-    Workflow,
-    ClassifyWorkflow,
-    CompareWorkflow,
-    FreeTextWorkflow,
-    SelectWordsWorkflow,
-    LocateWorkflow,
-    DrawWorkflow,
-    TimestampWorkflow,
-    RankingWorkflow,
-)
-from rapidata.rapidata_client.datapoints.assets import MediaAsset, TextAsset, MultiAsset
+from typing import Literal, Optional, Sequence, get_args, TYPE_CHECKING
+
+from rapidata.rapidata_client.config import logger
+from rapidata.rapidata_client.config.tracer import tracer
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
 from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.rapidata_client.datapoints._datapoints_validator import (
+    DatapointsValidator,
+)
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.filter.rapidata_filters import RapidataFilters
-from rapidata.rapidata_client.settings import RapidataSettings, RapidataSetting
+from rapidata.rapidata_client.settings import RapidataSetting, RapidataSettings
 from rapidata.rapidata_client.selection.rapidata_selections import RapidataSelections
-from rapidata.rapidata_client.logging import logger, RapidataOutputManager
-
-from rapidata.api_client.models.query_model import QueryModel
-from rapidata.api_client.models.page_info import PageInfo
-from rapidata.api_client.models.root_filter import RootFilter
-from rapidata.api_client.models.filter import Filter
-from rapidata.api_client.models.filter_operator import FilterOperator
-from rapidata.api_client.models.sort_criterion import SortCriterion
-from rapidata.api_client.models.sort_direction import SortDirection
-
+from rapidata.service.openapi_service import OpenAPIService
 
-from tqdm import tqdm
+if TYPE_CHECKING:
+    from rapidata.rapidata_client.order._rapidata_order_builder import (
+        StickyStateLiteral,
+    )
+    from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+    from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+    from rapidata.rapidata_client.workflow import (
+        Workflow,
+    )
 
 
 class RapidataOrderManager:
@@ -61,53 +40,65 @@ class RapidataOrderManager:
         self.filters = RapidataFilters
         self.settings = RapidataSettings
         self.selections = RapidataSelections
+        from rapidata.rapidata_client.order._rapidata_order_builder import (
+            StickyStateLiteral,
+        )
+
         self.__priority: int | None = None
-        self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
+        self.__sticky_state: StickyStateLiteral | None = None
+        self._asset_uploader = AssetUploader(openapi_service)
         logger.debug("RapidataOrderManager initialized")
 
     def _create_general_order(
         self,
         name: str,
         workflow: Workflow,
-        assets: list[MediaAsset] | list[TextAsset] | list[MultiAsset],
+        datapoints: list[Datapoint],
         responses_per_datapoint: int = 10,
-        contexts: list[str] | None = None,
-        media_contexts: list[str] | None = None,
         validation_set_id: str | None = None,
         confidence_threshold: float | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        sentences: list[str] | None = None,
-        selections: Sequence[RapidataSelection] = [],
-        private_notes: list[str] | None = None,
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
     ) -> RapidataOrder:
-
-        if not assets:
-            raise ValueError("No datapoints provided")
-
-        if contexts and len(contexts) != len(assets):
-            raise ValueError("Number of contexts must match number of datapoints")
-
-        if media_contexts and len(media_contexts) != len(assets):
-            raise ValueError("Number of media contexts must match number of datapoints")
-
-        if sentences and len(sentences) != len(assets):
-            raise ValueError("Number of sentences must match number of datapoints")
-
-        if private_notes and len(private_notes) != len(assets):
-            raise ValueError("Number of private notes must match number of datapoints")
-
-        if sentences and contexts:
-            raise ValueError("You can only use contexts or sentences, not both")
+        if filters is None:
+            filters = []
+        if settings is None:
+            settings = []
+        if selections is None:
+            selections = []
 
         if not confidence_threshold:
+            from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
+
             referee = NaiveReferee(responses=responses_per_datapoint)
         else:
+            from rapidata.rapidata_client.referee._early_stopping_referee import (
+                EarlyStoppingReferee,
+            )
+
             referee = EarlyStoppingReferee(
                 threshold=confidence_threshold,
-                max_vote_count=responses_per_datapoint,
+                max_responses=responses_per_datapoint,
             )
 
+        logger.debug(
+            "Creating order with parameters: name %s, workflow %s, datapoints %s, responses_per_datapoint %s, validation_set_id %s, confidence_threshold %s, filters %s, settings %s, selections %s",
+            name,
+            workflow,
+            datapoints,
+            responses_per_datapoint,
+            validation_set_id,
+            confidence_threshold,
+            filters,
+            settings,
+            selections,
+        )
+
+        from rapidata.rapidata_client.order._rapidata_order_builder import (
+            RapidataOrderBuilder,
+        )
+
         order_builder = RapidataOrderBuilder(
             name=name, openapi_service=self.__openapi_service
         )
@@ -117,74 +108,40 @@ class RapidataOrderManager:
                 "Warning: Both selections and validation_set_id provided. Ignoring validation_set_id."
             )
 
-        prompts_metadata = (
-            [PromptMetadata(prompt=prompt) for prompt in contexts] if contexts else None
-        )
-        sentence_metadata = (
-            [SelectWordsMetadata(select_words=sentence) for sentence in sentences]
-            if sentences
-            else None
-        )
-
-        if prompts_metadata and sentence_metadata:
-            raise ValueError("You can only use contexts or sentences, not both")
-
-        asset_metadata: Sequence[Metadata] = (
-            [MediaAssetMetadata(url=context) for context in media_contexts]
-            if media_contexts
-            else []
-        )
-        prompt_metadata: Sequence[Metadata] = (
-            prompts_metadata or sentence_metadata or []
-        )
-        private_notes_metadata: Sequence[Metadata] = (
-            [PrivateTextMetadata(text=text) for text in private_notes]
-            if private_notes
-            else []
-        )
-
-        multi_metadata = [
-            [item for item in items if item is not None]
-            for items in zip_longest(
-                prompt_metadata, asset_metadata, private_notes_metadata
-            )
-        ]
-
         order = (
-            order_builder._workflow(workflow)
-            ._datapoints(
-                datapoints=[
-                    Datapoint(asset=asset, metadata=metadata)
-                    for asset, metadata in zip_longest(assets, multi_metadata)
-                ]
-            )
-            ._referee(referee)
-            ._filters(filters)
-            ._selections(selections)
-            ._settings(settings)
-            ._validation_set_id(validation_set_id if not selections else None)
-            ._priority(self.__priority)
-            ._sticky_state(self.__sticky_state)
+            order_builder._set_workflow(workflow)
+            ._set_datapoints(datapoints=datapoints)
+            ._set_referee(referee)
+            ._set_filters(filters)
+            ._set_selections(selections)
+            ._set_settings(settings)
+            ._set_validation_set_id(validation_set_id if not selections else None)
+            ._set_priority(self.__priority)
+            ._set_sticky_state(self.__sticky_state)
             ._create()
         )
         logger.debug("Order created: %s", order)
         return order
 
-    def _set_priority(self, priority: int):
-        if not isinstance(priority, int):
-            raise TypeError("Priority must be an integer")
+    def _set_priority(self, priority: int | None):
+        if priority is not None and not isinstance(priority, int):
+            raise TypeError("Priority must be an integer or None")
 
-        if priority < 0:
-            raise ValueError("Priority must be greater than 0")
+        if priority is not None and priority < 0:
+            raise ValueError("Priority must be greater than 0 or None")
 
         self.__priority = priority
 
-    def _set_sticky_state(
-        self, sticky_state: Literal["None", "Temporary", "Permanent"]
-    ):
-        if sticky_state not in ["None", "Temporary", "Permanent"]:
+    def _set_sticky_state(self, sticky_state: StickyStateLiteral | None):
+        from rapidata.rapidata_client.order._rapidata_order_builder import (
+            StickyStateLiteral,
+        )
+
+        sticky_state_valid_values = get_args(StickyStateLiteral)
+
+        if sticky_state is not None and sticky_state not in sticky_state_valid_values:
             raise ValueError(
-                "Sticky state must be one of 'None', 'Temporary', 'Permanent'"
+                f"Sticky state must be one of {sticky_state_valid_values} or None"
             )
 
         self.__sticky_state = sticky_state
@@ -201,9 +158,9 @@ class RapidataOrderManager:
         media_contexts: list[str] | None = None,
         validation_set_id: str | None = None,
         confidence_threshold: float | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a classification order.
@@ -234,33 +191,54 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the classification. Defaults to None.
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
-        """
 
-        if data_type == "media":
-            assets = [MediaAsset(path=path) for path in datapoints]
-        elif data_type == "text":
-            assets = [TextAsset(text=text) for text in datapoints]
-        else:
-            raise ValueError(
-                f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+        Example:
+            ```python
+            from rapidata import RapidataClient, NoShuffle
+
+            rapi = RapidataClient()
+            order = rapi.order.create_classification_order(
+                name="Image Quality Rating",
+                instruction="How would you rate the quality of this image?",
+                answer_options=["1: Poor", "2: Fair", "3: Good", "4: Excellent"],
+                datapoints=["https://example.com/image1.jpg", "https://example.com/image2.jpg"],
+                responses_per_datapoint=15,
+                settings=[NoShuffle()],  # Keep options in order for Likert scale
+            ).run()
+
+            results = order.get_results()
+            ```
+        """
+        with tracer.start_as_current_span(
+            "RapidataOrderManager.create_classification_order"
+        ):
+            if not isinstance(datapoints, list) or not all(
+                isinstance(datapoint, str) for datapoint in datapoints
+            ):
+                raise ValueError("Datapoints must be a list of strings")
+
+            from rapidata.rapidata_client.workflow import ClassifyWorkflow
+
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+                data_type=data_type,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=ClassifyWorkflow(
+                    instruction=instruction, answer_options=answer_options
+                ),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                confidence_threshold=confidence_threshold,
+                filters=filters,
+                selections=selections,
+                settings=settings,
             )
-
-        return self._create_general_order(
-            name=name,
-            workflow=ClassifyWorkflow(
-                instruction=instruction, answer_options=answer_options
-            ),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            validation_set_id=validation_set_id,
-            confidence_threshold=confidence_threshold,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
 
     def create_compare_order(
         self,
@@ -274,9 +252,9 @@ class RapidataOrderManager:
         a_b_names: list[str] | None = None,
         validation_set_id: str | None = None,
         confidence_threshold: float | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a compare order.
@@ -315,111 +293,202 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the comparison. Defaults to None.\n
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
+
+        Example:
+            ```python
+            from rapidata import RapidataClient
+
+            rapi = RapidataClient()
+            order = rapi.order.create_compare_order(
+                name="Image Prompt Alignment",
+                instruction="Which image follows the prompt more accurately?",
+                datapoints=[
+                    ["https://example.com/model_a_img1.jpg", "https://example.com/model_b_img1.jpg"],
+                    ["https://example.com/model_a_img2.jpg", "https://example.com/model_b_img2.jpg"],
+                ],
+                contexts=["A cat sitting on a red couch", "A blue car in the rain"],
+                responses_per_datapoint=25,
+                a_b_names=["Flux", "Midjourney"],  # Optional: label the models in results
+            ).run()
+
+            results = order.get_results()
+            ```
         """
+        with tracer.start_as_current_span("RapidataOrderManager.create_compare_order"):
+            if any(not isinstance(datapoint, list) for datapoint in datapoints):
+                raise ValueError("Each datapoint must be a list of 2 paths/texts")
 
-        if any(type(datapoint) != list for datapoint in datapoints):
-            raise ValueError("Each datapoint must be a list of 2 paths/texts")
+            if any(len(set(datapoint)) != 2 for datapoint in datapoints):
+                raise ValueError(
+                    "Each datapoint must contain exactly two unique options"
+                )
 
-        if any(len(datapoint) != 2 for datapoint in datapoints):
-            raise ValueError("Each datapoint must contain exactly two options")
+            if a_b_names is not None and len(a_b_names) != 2:
+                raise ValueError(
+                    "A_B_naming must be a list of exactly two strings or None"
+                )
 
-        if a_b_names is not None and len(a_b_names) != 2:
-            raise ValueError("A_B_naming must be a list of exactly two strings or None")
+            from rapidata.rapidata_client.workflow import CompareWorkflow
 
-        if data_type == "media":
-            assets = [
-                MultiAsset([MediaAsset(path=path) for path in datapoint])
-                for datapoint in datapoints
-            ]
-        elif data_type == "text":
-            assets = [
-                MultiAsset([TextAsset(text=text) for text in datapoint])
-                for datapoint in datapoints
-            ]
-        else:
-            raise ValueError(
-                f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+                data_type=data_type,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=CompareWorkflow(instruction=instruction, a_b_names=a_b_names),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                confidence_threshold=confidence_threshold,
+                filters=filters,
+                selections=selections,
+                settings=settings,
             )
-
-        return self._create_general_order(
-            name=name,
-            workflow=CompareWorkflow(instruction=instruction, a_b_names=a_b_names),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            validation_set_id=validation_set_id,
-            confidence_threshold=confidence_threshold,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
 
     def create_ranking_order(
         self,
         name: str,
         instruction: str,
-        datapoints: list[str],
-        total_comparison_budget: int,
+        datapoints: list[list[str]],
+        comparison_budget_per_ranking: int,
         responses_per_comparison: int = 1,
         data_type: Literal["media", "text"] = "media",
         random_comparisons_ratio: float = 0.5,
-        context: Optional[str] = None,
+        contexts: Optional[list[str]] = None,
+        media_contexts: Optional[list[str]] = None,
         validation_set_id: Optional[str] = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
     ) -> RapidataOrder:
         """
         Create a ranking order.
 
-        With this order you can rank a list of datapoints (image, text, video, audio) based on the instruction.
-        The annotators will be shown two datapoints at a time. The ranking happens in terms of an elo system based on the matchup results.
+        With this order you can have a multiple lists of datapoints (image, text, video, audio) be ranked based on the instruction.
+        Each list will be ranked independently, based on comparison matchups.
 
         Args:
             name (str): The name of the order.
-            instruction (str): The question asked from People when They see two datapoints.
-            datapoints (list[str]): A list of datapoints that will participate in the ranking.
-            total_comparison_budget (int): The total number of (pairwise-)comparisons that can be made.
-            responses_per_comparison (int, optional): The number of responses collected per comparison. Defaults to 1.
+            instruction (str): The instruction for the ranking. Will be shown with each matchup.
+            datapoints (list[list[str]]): The outer list is determines the independent rankings, the inner list is the datapoints for each ranking.
+            comparison_budget_per_ranking (int): The number of comparisons that will be collected per ranking (outer list of datapoints).
+            responses_per_comparison (int, optional): The number of responses that will be collected per comparison. Defaults to 1.
             data_type (str, optional): The data type of the datapoints. Defaults to "media" (any form of image, video or audio). \n
                 Other option: "text".
-            random_comparisons_ratio (float, optional): The fraction of random comparisons in the ranking process.
-                The rest will focus on pairing similarly ranked datapoints. Defaults to 0.5 and can be left untouched.
-            context (str, optional): The context for all the comparison. Defaults to None.\n
-                If provided will be shown in addition to the instruction for all the matchups.
+            random_comparisons_ratio (float, optional): The ratio of random comparisons to the total number of comparisons. Defaults to 0.5.
+            contexts (list[str], optional): The list of contexts for the ranking. Defaults to None.\n
+                If provided has to be the same length as the outer list of datapoints and will be shown in addition to the instruction. (Therefore will be different for each ranking)
+                Will be matched up with the datapoints using the list index.
+            media_contexts (list[str], optional): The list of media contexts for the ranking i.e links to the images / videos. Defaults to None.\n
+                If provided has to be the same length as the outer list of datapoints and will be shown in addition to the instruction. (Therefore will be different for each ranking)
+                Will be matched up with the datapoints using the list index.
             validation_set_id (str, optional): The ID of the validation set. Defaults to None.\n
                 If provided, one validation task will be shown infront of the datapoints that will be labeled.
-            filters (Sequence[RapidataFilter], optional): The list of filters for the order. Defaults to []. Decides who the tasks should be shown to.
-            settings (Sequence[RapidataSetting], optional): The list of settings for the order. Defaults to []. Decides how the tasks should be shown.
-            selections (Sequence[RapidataSelection], optional): The list of selections for the order. Defaults to []. Decides in what order the tasks should be shown.
+            filters (Sequence[RapidataFilter], optional): The list of filters for the ranking. Defaults to []. Decides who the tasks should be shown to.
+            settings (Sequence[RapidataSetting], optional): The list of settings for the ranking. Defaults to []. Decides how the tasks should be shown.
+            selections (Sequence[RapidataSelection], optional): The list of selections for the ranking. Defaults to []. Decides in what order the tasks should be shown.
+
+        Example:
+            ```python
+            from rapidata import RapidataClient
+
+            rapi = RapidataClient()
+            # Rank 12 images by preference using 50 pairwise comparisons
+            order = rapi.order.create_ranking_order(
+                name="Image Quality Ranking",
+                instruction="Which image looks better?",
+                datapoints=[["img1.jpg", "img2.jpg", "img3.jpg", "img4.jpg", "img5.jpg",
+                            "img6.jpg", "img7.jpg", "img8.jpg", "img9.jpg", "img10.jpg",
+                            "img11.jpg", "img12.jpg"]],
+                comparison_budget_per_ranking=50,
+                random_comparisons_ratio=0.5,  # 50% random, 50% close matchups
+            ).run()
+
+            results = order.get_results()  # Returns ranked list with scores
+            ```
         """
+        with tracer.start_as_current_span("RapidataOrderManager.create_ranking_order"):
+            if contexts and len(contexts) != len(datapoints):
+                raise ValueError(
+                    "Number of contexts must match the number of sets that will be ranked"
+                )
+            if media_contexts and len(media_contexts) != len(datapoints):
+                raise ValueError(
+                    "Number of media contexts must match the number of sets that will be ranked"
+                )
+            if not isinstance(datapoints, list) or not all(
+                isinstance(dp, list) for dp in datapoints
+            ):
+                raise ValueError(
+                    "Datapoints must be a list of lists. Outer list is the independent rankings, inner list is the datapoints for each ranking."
+                )
+            if not all(len(set(dp)) == len(dp) for dp in datapoints):
+                raise ValueError("Each inner list must contain unique datapoints.")
 
-        if data_type == "media":
-            assets = [MediaAsset(path=path) for path in datapoints]
-        elif data_type == "text":
-            assets = [TextAsset(text=text) for text in datapoints]
-        else:
-            raise ValueError(
-                f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+            if not all(len(inner_list) >= 2 for inner_list in datapoints):
+                raise ValueError(
+                    "Each ranking must contain at least two unique datapoints."
+                )
+
+            from rapidata.rapidata_client.workflow import MultiRankingWorkflow
+            from rapidata.api_client.models.i_asset_input import IAssetInput
+            from rapidata.api_client.models.i_asset_input_existing_asset_input import (
+                IAssetInputExistingAssetInput,
             )
 
-        return self._create_general_order(
-            name=name,
-            workflow=RankingWorkflow(
-                criteria=instruction,
-                total_comparison_budget=total_comparison_budget,
-                random_comparisons_ratio=random_comparisons_ratio,
-                context=context,
-            ),
-            assets=assets,
-            responses_per_datapoint=responses_per_comparison,
-            validation_set_id=validation_set_id,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-        )
+            datapoints_instances = []
+            for i, datapoint in enumerate(datapoints):
+                for d in datapoint:
+                    datapoints_instances.append(
+                        Datapoint(
+                            asset=d,
+                            data_type=data_type,
+                            context=contexts[i] if contexts else None,
+                            media_context=media_contexts[i] if media_contexts else None,
+                            group=str(i),
+                        )
+                    )
+
+            contexts_dict = (
+                {str(i): context for i, context in enumerate(contexts)}
+                if contexts
+                else None
+            )
+
+            media_contexts_dict = (
+                {
+                    str(i): IAssetInput(
+                        actual_instance=IAssetInputExistingAssetInput(
+                            _t="ExistingAssetInput",
+                            name=self._asset_uploader.upload_asset(media_context),
+                        )
+                    )
+                    for i, media_context in enumerate(media_contexts)
+                }
+                if media_contexts
+                else None
+            )
+
+            return self._create_general_order(
+                name=name,
+                workflow=MultiRankingWorkflow(
+                    instruction=instruction,
+                    comparison_budget_per_ranking=comparison_budget_per_ranking,
+                    random_comparisons_ratio=random_comparisons_ratio,
+                    contexts=contexts_dict,
+                    media_contexts=media_contexts_dict,
+                ),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_comparison,
+                validation_set_id=validation_set_id,
+                filters=filters,
+                selections=selections,
+                settings=settings,
+            )
 
     def create_free_text_order(
         self,
@@ -430,9 +499,9 @@ class RapidataOrderManager:
         responses_per_datapoint: int = 10,
         contexts: list[str] | None = None,
         media_contexts: list[str] | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a free text order.
@@ -459,29 +528,44 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the free text. Defaults to None.\n
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
-        """
 
-        if data_type == "media":
-            assets = [MediaAsset(path=path) for path in datapoints]
-        elif data_type == "text":
-            assets = [TextAsset(text=text) for text in datapoints]
-        else:
-            raise ValueError(
-                f"Unsupported data type: {data_type}, must be one of 'media' or 'text'"
+        Example:
+            ```python
+            from rapidata import RapidataClient, FreeTextMinimumCharacters
+
+            rapi = RapidataClient()
+            order = rapi.order.create_free_text_order(
+                name="Image Captioning",
+                instruction="Describe what you see in this image in detail",
+                datapoints=["https://example.com/image1.jpg", "https://example.com/image2.jpg"],
+                responses_per_datapoint=5,
+                settings=[FreeTextMinimumCharacters(20)],  # Require at least 20 characters
+            ).run()
+
+            results = order.get_results()
+            ```
+        """
+        with tracer.start_as_current_span(
+            "RapidataOrderManager.create_free_text_order"
+        ):
+            from rapidata.rapidata_client.workflow import FreeTextWorkflow
+
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+                data_type=data_type,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=FreeTextWorkflow(instruction=instruction),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                filters=filters,
+                selections=selections,
+                settings=settings,
             )
-
-        return self._create_general_order(
-            name=name,
-            workflow=FreeTextWorkflow(instruction=instruction),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
 
     def create_select_words_order(
         self,
@@ -491,9 +575,9 @@ class RapidataOrderManager:
         sentences: list[str],
         responses_per_datapoint: int = 10,
         validation_set_id: str | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a select words order.
@@ -517,24 +601,45 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the select words. Defaults to None.\n
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
+
+        Example:
+            ```python
+            from rapidata import RapidataClient
+
+            rapi = RapidataClient()
+            order = rapi.order.create_select_words_order(
+                name="Find Text-Image Mismatches",
+                instruction="Select words that don't match what's shown in the image",
+                datapoints=["https://example.com/image1.jpg", "https://example.com/image2.jpg"],
+                sentences=["A red car on a blue road", "Two cats playing with yarn"],
+                responses_per_datapoint=15,
+            ).run()
+
+            results = order.get_results()
+            ```
         """
+        with tracer.start_as_current_span(
+            "RapidataOrderManager.create_select_words_order"
+        ):
+            from rapidata.rapidata_client.workflow import SelectWordsWorkflow
 
-        assets = [MediaAsset(path=path) for path in datapoints]
-
-        return self._create_general_order(
-            name=name,
-            workflow=SelectWordsWorkflow(
-                instruction=instruction,
-            ),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            validation_set_id=validation_set_id,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            sentences=sentences,
-            private_notes=private_notes,
-        )
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                sentences=sentences,
+                private_notes=private_notes,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=SelectWordsWorkflow(
+                    instruction=instruction,
+                ),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                filters=filters,
+                selections=selections,
+                settings=settings,
+            )
 
     def create_locate_order(
         self,
@@ -545,9 +650,9 @@ class RapidataOrderManager:
         contexts: list[str] | None = None,
         media_contexts: list[str] | None = None,
         validation_set_id: str | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a locate order.
@@ -573,23 +678,41 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the locate. Defaults to None.\n
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
-        """
 
-        assets = [MediaAsset(path=path) for path in datapoints]
-
-        return self._create_general_order(
-            name=name,
-            workflow=LocateWorkflow(target=instruction),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            validation_set_id=validation_set_id,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
+        Example:
+            ```python
+            from rapidata import RapidataClient
+
+            rapi = RapidataClient()
+            order = rapi.order.create_locate_order(
+                name="Find Artifacts",
+                instruction="Tap on any visual glitches or errors in the image",
+                datapoints=["https://example.com/ai_generated1.jpg", "https://example.com/ai_generated2.jpg"],
+                responses_per_datapoint=35,
+            ).run()
+
+            results = order.get_results()
+            ```
+        """
+        with tracer.start_as_current_span("RapidataOrderManager.create_locate_order"):
+            from rapidata.rapidata_client.workflow import LocateWorkflow
+
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=LocateWorkflow(target=instruction),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                filters=filters,
+                selections=selections,
+                settings=settings,
+            )
 
     def create_draw_order(
         self,
@@ -600,9 +723,9 @@ class RapidataOrderManager:
         contexts: list[str] | None = None,
         media_contexts: list[str] | None = None,
         validation_set_id: str | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a draw order.
@@ -628,23 +751,41 @@ class RapidataOrderManager:
             private_notes (list[str], optional): The list of private notes for the draw lines. Defaults to None.\n
                 If provided has to be the same length as datapoints.\n
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
-        """
 
-        assets = [MediaAsset(path=path) for path in datapoints]
-
-        return self._create_general_order(
-            name=name,
-            workflow=DrawWorkflow(target=instruction),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            validation_set_id=validation_set_id,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
+        Example:
+            ```python
+            from rapidata import RapidataClient
+
+            rapi = RapidataClient()
+            order = rapi.order.create_draw_order(
+                name="Segment Objects",
+                instruction="Color in all the cars in the image",
+                datapoints=["https://example.com/street1.jpg", "https://example.com/street2.jpg"],
+                responses_per_datapoint=35,
+            ).run()
+
+            results = order.get_results()
+            ```
+        """
+        with tracer.start_as_current_span("RapidataOrderManager.create_draw_order"):
+            from rapidata.rapidata_client.workflow import DrawWorkflow
+
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=DrawWorkflow(target=instruction),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                filters=filters,
+                selections=selections,
+                settings=settings,
+            )
 
     def create_timestamp_order(
         self,
@@ -655,9 +796,9 @@ class RapidataOrderManager:
         contexts: list[str] | None = None,
         media_contexts: list[str] | None = None,
         validation_set_id: str | None = None,
-        filters: Sequence[RapidataFilter] = [],
-        settings: Sequence[RapidataSetting] = [],
-        selections: Sequence[RapidataSelection] = [],
+        filters: Sequence[RapidataFilter] | None = None,
+        settings: Sequence[RapidataSetting] | None = None,
+        selections: Sequence[RapidataSelection] | None = None,
         private_notes: list[str] | None = None,
     ) -> RapidataOrder:
         """Create a timestamp order.
@@ -688,31 +829,27 @@ class RapidataOrderManager:
                 This will NOT be shown to the labelers but will be included in the result purely for your own reference.
         """
 
-        assets = [MediaAsset(path=path) for path in datapoints]
-
-        for asset in tqdm(
-            assets,
-            desc="Downloading assets and checking duration",
-            disable=RapidataOutputManager.silent_mode,
+        with tracer.start_as_current_span(
+            "RapidataOrderManager.create_timestamp_order"
         ):
-            if not asset.get_duration():
-                raise ValueError(
-                    "The datapoints for this order must have a duration. (e.g. video or audio)"
-                )
+            from rapidata.rapidata_client.workflow import TimestampWorkflow
 
-        return self._create_general_order(
-            name=name,
-            workflow=TimestampWorkflow(instruction=instruction),
-            assets=assets,
-            responses_per_datapoint=responses_per_datapoint,
-            contexts=contexts,
-            media_contexts=media_contexts,
-            validation_set_id=validation_set_id,
-            filters=filters,
-            selections=selections,
-            settings=settings,
-            private_notes=private_notes,
-        )
+            datapoints_instances = DatapointsValidator.map_datapoints(
+                datapoints=datapoints,
+                contexts=contexts,
+                media_contexts=media_contexts,
+                private_notes=private_notes,
+            )
+            return self._create_general_order(
+                name=name,
+                workflow=TimestampWorkflow(instruction=instruction),
+                datapoints=datapoints_instances,
+                responses_per_datapoint=responses_per_datapoint,
+                validation_set_id=validation_set_id,
+                filters=filters,
+                selections=selections,
+                settings=settings,
+            )
 
     def get_order_by_id(self, order_id: str) -> RapidataOrder:
         """Get an order by ID.
@@ -723,14 +860,16 @@ class RapidataOrderManager:
         Returns:
             RapidataOrder: The Order instance.
         """
+        with tracer.start_as_current_span("RapidataOrderManager.get_order_by_id"):
+            from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 
-        order = self.__openapi_service.order_api.order_order_id_get(order_id)
+            order = self.__openapi_service.order_api.order_order_id_get(order_id)
 
-        return RapidataOrder(
-            order_id=order_id,
-            name=order.order_name,
-            openapi_service=self.__openapi_service,
-        )
+            return RapidataOrder(
+                order_id=order_id,
+                name=order.order_name,
+                openapi_service=self.__openapi_service,
+            )
 
     def find_orders(self, name: str = "", amount: int = 10) -> list[RapidataOrder]:
         """Find your recent orders given criteria. If nothing is provided, it will return the most recent order.
@@ -742,25 +881,42 @@ class RapidataOrderManager:
         Returns:
             list[RapidataOrder]: A list of RapidataOrder instances.
         """
-        order_page_result = self.__openapi_service.order_api.orders_get(
-            QueryModel(
-                page=PageInfo(index=1, size=amount),
-                filter=RootFilter(
-                    filters=[
-                        Filter(
-                            field="OrderName",
-                            operator=FilterOperator.CONTAINS,
-                            value=name,
+        with tracer.start_as_current_span("RapidataOrderManager.find_orders"):
+            from rapidata.api_client.models.page_info import PageInfo
+            from rapidata.api_client.models.query_model import QueryModel
+            from rapidata.api_client.models.root_filter import RootFilter
+            from rapidata.api_client.models.filter import Filter
+            from rapidata.api_client.models.filter_operator import FilterOperator
+            from rapidata.api_client.models.sort_criterion import SortCriterion
+            from rapidata.api_client.models.sort_direction import SortDirection
+
+            order_page_result = self.__openapi_service.order_api.orders_get(
+                QueryModel(
+                    page=PageInfo(index=1, size=amount),
+                    filter=RootFilter(
+                        filters=[
+                            Filter(
+                                field="OrderName",
+                                operator=FilterOperator.CONTAINS,
+                                value=name,
+                            )
+                        ]
+                    ),
+                    sortCriteria=[
+                        SortCriterion(
+                            direction=SortDirection.DESC, propertyName="OrderDate"
                         )
-                    ]
-                ),
-                sortCriteria=[
-                    SortCriterion(
-                        direction=SortDirection.DESC, propertyName="OrderDate"
-                    )
-                ],
+                    ],
+                )
             )
-        )
 
-        orders = [self.get_order_by_id(order.id) for order in order_page_result.items]
-        return orders
+            orders = [
+                self.get_order_by_id(order.id) for order in order_page_result.items
+            ]
+            return orders
+
+    def __str__(self) -> str:
+        return "RapidataOrderManager"
+
+    def __repr__(self) -> str:
+        return self.__str__()