AI Agents: For SDK documentation, see https://docs.rapidata.ai/2.x/llms.txt

Rapidata order manager

RapidataOrderManager

RapidataOrderManager(openapi_service: OpenAPIService)

Handels everything regarding the orders from creation to retrieval.

Attributes:

Name	Type	Description
filters	RapidataFilters	The RapidataFilters instance.
settings	RapidataSettings	The RapidataSettings instance.
selections	RapidataSelections	The RapidataSelections instance.

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def __init__(self, openapi_service: OpenAPIService):
    self.__openapi_service = openapi_service
    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: StickyStateLiteral | None = None
    self._asset_uploader = AssetUploader(openapi_service)
    logger.debug("RapidataOrderManager initialized")

create_classification_order

create_classification_order(
    name: str,
    instruction: str,
    answer_options: list[str],
    datapoints: list[str],
    data_type: Literal["media", "text"] = "media",
    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] | None = None,
    settings: Sequence[RapidataSetting] | None = None,
    selections: Sequence[RapidataSelection] | None = None,
    private_notes: list[str] | None = None,
) -> RapidataOrder

Create a classification order.

With this order you can have a datapoint (image, text, video, audio) be classified into one of the answer options. Each response will be exactly one of the answer options.

Parameters:

Name	Type	Description	Default
name	str	The name of the order. (Will not be shown to the labeler)	required
instruction	str	The instruction for how the data should be classified.	required
answer_options	list[str]	The list of options for the classification.	required
datapoints	list[str]	The list of datapoints for the classification - each datapoint will be labeled.	required
data_type	str	The data type of the datapoints. Defaults to "media" (any form of image, video or audio). Other option: "text".	'media'
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the classification. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction and options. (Therefore will be different for each datapoint) Will be match up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts for the classification i.e links to the images / videos. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction and options. (Therefore will be different for each datapoint)	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
confidence_threshold	float	The probability threshold for the classification. Defaults to None. If provided, the classification datapoint will stop after the threshold is reached or at the number of responses, whatever happens first.	None
filters	Sequence[RapidataFilter]	The list of filters for the classification. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the classification. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the classification. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the classification. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_classification_order(
    self,
    name: str,
    instruction: str,
    answer_options: list[str],
    datapoints: list[str],
    data_type: Literal["media", "text"] = "media",
    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] | None = None,
    settings: Sequence[RapidataSetting] | None = None,
    selections: Sequence[RapidataSelection] | None = None,
    private_notes: list[str] | None = None,
) -> RapidataOrder:
    """Create a classification order.

    With this order you can have a datapoint (image, text, video, audio) be classified into one of the answer options.
    Each response will be exactly one of the answer options.

    Args:
        name (str): The name of the order. (Will not be shown to the labeler)
        instruction (str): The instruction for how the data should be classified.
        answer_options (list[str]): The list of options for the classification.
        datapoints (list[str]): The list of datapoints for the classification - each datapoint will be labeled.
        data_type (str, optional): The data type of the datapoints. Defaults to "media" (any form of image, video or audio). \n
            Other option: "text".
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the classification. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction and options. (Therefore will be different for each datapoint)
            Will be match up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts for the classification i.e links to the images / videos. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction and options. (Therefore will be different for each datapoint)
        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.
        confidence_threshold (float, optional): The probability threshold for the classification. Defaults to None.\n
            If provided, the classification datapoint will stop after the threshold is reached or at the number of responses, whatever happens first.
        filters (Sequence[RapidataFilter], optional): The list of filters for the classification. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the classification. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the classification. Defaults to []. Decides in what order the tasks should be shown.
        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.

    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,
        )

create_compare_order

create_compare_order(
    name: str,
    instruction: str,
    datapoints: list[list[str]],
    data_type: Literal["media", "text"] = "media",
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    a_b_names: list[str] | None = None,
    validation_set_id: str | None = None,
    confidence_threshold: float | None = None,
    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.

With this order you compare two datapoints (image, text, video, audio) and the annotators will choose one of the two based on the instruction.

Parameters:

Name	Type	Description	Default
name	str	The name of the order. (Will not be shown to the labeler)	required
instruction	str	The instruction for the comparison. Will be shown along side each datapoint.	required
datapoints	list[list[str]]	Outher list is the datapoints, inner list is the options for the comparison - each datapoint will be labeled.	required
data_type	str	The data type of the datapoints. Defaults to "media" (any form of image, video or audio). Other option: "text".	'media'
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the comparison. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be matched up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts i.e. links to the images / videos for the comparison. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be matched up with the datapoints using the list index.	None
a_b_names	list[str]	Custom naming for the two opposing models defined by the index in the datapoints list. Defaults to None. If provided has to be a list of exactly two strings. example: datapoints = [["path_to_image_A", "path_to_image_B"], ["path_to_text_A", "path_to_text_B"]] a_b_naming = ["Model A", "Model B"] The results will then correctly show "Model A" and "Model B". If not provided, the results will be shown as "A" and "B".	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
confidence_threshold	float	The probability threshold for the comparison. Defaults to None. If provided, the comparison datapoint will stop after the threshold is reached or at the number of responses, whatever happens first.	None
filters	Sequence[RapidataFilter]	The list of filters for the comparison. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the comparison. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the comparison. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the comparison. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_compare_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[list[str]],
    data_type: Literal["media", "text"] = "media",
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    a_b_names: list[str] | None = None,
    validation_set_id: str | None = None,
    confidence_threshold: float | None = None,
    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.

    With this order you compare two datapoints (image, text, video, audio) and the annotators will choose one of the two based on the instruction.

    Args:
        name (str): The name of the order. (Will not be shown to the labeler)
        instruction (str): The instruction for the comparison. Will be shown along side each datapoint.
        datapoints (list[list[str]]): Outher list is the datapoints, inner list is the options for the comparison - each datapoint will be labeled.
        data_type (str, optional): The data type of the datapoints. Defaults to "media" (any form of image, video or audio). \n
            Other option: "text".
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the comparison. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be matched up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts i.e. links to the images / videos for the comparison. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be matched up with the datapoints using the list index.
        a_b_names (list[str], optional): Custom naming for the two opposing models defined by the index in the datapoints list. Defaults to None.\n
            If provided has to be a list of exactly two strings.
            example:
            ```python
            datapoints = [["path_to_image_A", "path_to_image_B"], ["path_to_text_A", "path_to_text_B"]]
            a_b_naming = ["Model A", "Model B"]
            ```
            The results will then correctly show "Model A" and "Model B".
            If not provided, the results will be shown as "A" and "B".
        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.
        confidence_threshold (float, optional): The probability threshold for the comparison. Defaults to None.\n
            If provided, the comparison datapoint will stop after the threshold is reached or at the number of responses, whatever happens first.
        filters (Sequence[RapidataFilter], optional): The list of filters for the comparison. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the comparison. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the comparison. Defaults to []. Decides in what order the tasks should be shown.
        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(len(set(datapoint)) != 2 for datapoint in datapoints):
            raise ValueError(
                "Each datapoint must contain exactly two unique 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"
            )

        from rapidata.rapidata_client.workflow import CompareWorkflow

        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,
        )

create_ranking_order

create_ranking_order(
    name: str,
    instruction: str,
    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,
    contexts: Optional[list[str]] = None,
    media_contexts: Optional[list[str]] = None,
    validation_set_id: Optional[str] = None,
    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 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.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction for the ranking. Will be shown with each matchup.	required
datapoints	list[list[str]]	The outer list is determines the independent rankings, the inner list is the datapoints for each ranking.	required
comparison_budget_per_ranking	int	The number of comparisons that will be collected per ranking (outer list of datapoints).	required
responses_per_comparison	int	The number of responses that will be collected per comparison. Defaults to 1.	1
data_type	str	The data type of the datapoints. Defaults to "media" (any form of image, video or audio). Other option: "text".	'media'
random_comparisons_ratio	float	The ratio of random comparisons to the total number of comparisons. Defaults to 0.5.	0.5
contexts	list[str]	The list of contexts for the ranking. Defaults to None. 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.	None
media_contexts	list[str]	The list of media contexts for the ranking i.e links to the images / videos. Defaults to None. 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.	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
filters	Sequence[RapidataFilter]	The list of filters for the ranking. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the ranking. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the ranking. Defaults to []. Decides in what order the tasks should be shown.	None

Example

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

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_ranking_order(
    self,
    name: str,
    instruction: str,
    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,
    contexts: Optional[list[str]] = None,
    media_contexts: Optional[list[str]] = None,
    validation_set_id: Optional[str] = None,
    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 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 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 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 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 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,
        )

        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,
        )

create_free_text_order

create_free_text_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    data_type: Literal["media", "text"] = "media",
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    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.

With this order you can have a datapoint (image, text, video, audio) be labeled with free text. The annotators will be shown a datapoint and will be asked to answer a question with free text.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction to answer with free text. Will be shown along side each datapoint.	required
datapoints	list[str]	The list of datapoints for the free text - each datapoint will be labeled.	required
data_type	str	The data type of the datapoints. Defaults to "media" (any form of image, video or audio). Other option: "text".	'media'
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the free text. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be matched up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts for the free text i.e links to the images / videos. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be matched up with the datapoints using the list index.	None
filters	Sequence[RapidataFilter]	The list of filters for the free text. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the free text. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the free text. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the free text. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_free_text_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[str],
    data_type: Literal["media", "text"] = "media",
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    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.

    With this order you can have a datapoint (image, text, video, audio) be labeled with free text.
    The annotators will be shown a datapoint and will be asked to answer a question with free text.

    Args:
        name (str): The name of the order.
        instruction (str): The instruction to answer with free text. Will be shown along side each datapoint.
        datapoints (list[str]): The list of datapoints for the free text - each datapoint will be labeled.
        data_type (str, optional): The data type of the datapoints. Defaults to "media" (any form of image, video or audio). \n
            Other option: "text".
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the free text. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be matched up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts for the free text i.e links to the images / videos. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be matched up with the datapoints using the list index.
        filters (Sequence[RapidataFilter], optional): The list of filters for the free text. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the free text. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the free text. Defaults to []. Decides in what order the tasks should be shown.
        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.

    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,
        )

create_select_words_order

create_select_words_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    sentences: list[str],
    responses_per_datapoint: int = 10,
    validation_set_id: str | None = None,
    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.

With this order you can have a datapoint (image, text, video, audio) be labeled with a list of words. The annotators will be shown a datapoint as well as a list of sentences split up by spaces. They will then select specific words based on the instruction.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction for how the words should be selected. Will be shown along side each datapoint.	required
datapoints	list[str]	The list of datapoints for the select words - each datapoint will be labeled.	required
sentences	list[str]	The list of sentences for the select words - Will be split up by spaces and shown along side each datapoint. Must be the same length as datapoints.	required
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
filters	Sequence[RapidataFilter]	The list of filters for the select words. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the select words. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the select words. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the select words. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_select_words_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[str],
    sentences: list[str],
    responses_per_datapoint: int = 10,
    validation_set_id: str | None = None,
    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.

    With this order you can have a datapoint (image, text, video, audio) be labeled with a list of words.
    The annotators will be shown a datapoint as well as a list of sentences split up by spaces.
    They will then select specific words based on the instruction.

    Args:
        name (str): The name of the order.
        instruction (str): The instruction for how the words should be selected. Will be shown along side each datapoint.
        datapoints (list[str]): The list of datapoints for the select words - each datapoint will be labeled.
        sentences (list[str]): The list of sentences for the select words - Will be split up by spaces and shown along side each datapoint.\n
            Must be the same length as datapoints.
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        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 select words. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the select words. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the select words. Defaults to []. Decides in what order the tasks should be shown.
        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

        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,
        )

create_locate_order

create_locate_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    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.

With this order you can have people locate specific objects in a datapoint (image, text, video, audio). The annotators will be shown a datapoint and will be asked to select locations based on the instruction.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction what should be located. Will be shown along side each datapoint.	required
datapoints	list[str]	The list of datapoints for the locate - each datapoint will be labeled.	required
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the locate. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be match up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts for the locate i.e links to the images / videos. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
filters	Sequence[RapidataFilter]	The list of filters for the locate. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the locate. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the locate. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the locate. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_locate_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    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.

    With this order you can have people locate specific objects in a datapoint (image, text, video, audio).
    The annotators will be shown a datapoint and will be asked to select locations based on the instruction.

    Args:
        name (str): The name of the order.
        instruction (str): The instruction what should be located. Will be shown along side each datapoint.
        datapoints (list[str]): The list of datapoints for the locate - each datapoint will be labeled.
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the locate. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be match up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts for the locate i.e links to the images / videos. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
        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 locate. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the locate. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the locate. Defaults to []. Decides in what order the tasks should be shown.
        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.

    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,
        )

create_draw_order

create_draw_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    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] = [],
    private_notes: list[str] | None = None,
) -> RapidataOrder

Create a draw order.

With this order you can have people draw lines on a datapoint (image, text, video, audio). The annotators will be shown a datapoint and will be asked to draw lines based on the instruction.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction for how the lines should be drawn. Will be shown along side each datapoint.	required
datapoints	list[str]	The list of datapoints for the draw lines - each datapoint will be labeled.	required
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the comparison. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be match up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts for the draw lines i.e links to the images / videos. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
filters	Sequence[RapidataFilter]	The list of filters for the draw lines. Defaults to []. Decides who the tasks should be shown to.	[]
settings	Sequence[RapidataSetting]	The list of settings for the draw lines. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the draw lines. Defaults to []. Decides in what order the tasks should be shown.	[]
private_notes	list[str]	The list of private notes for the draw lines. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Example

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()

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_draw_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    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] = [],
    private_notes: list[str] | None = None,
) -> RapidataOrder:
    """Create a draw order.

    With this order you can have people draw lines on a datapoint (image, text, video, audio).
    The annotators will be shown a datapoint and will be asked to draw lines based on the instruction.

    Args:
        name (str): The name of the order.
        instruction (str): The instruction for how the lines should be drawn. Will be shown along side each datapoint.
        datapoints (list[str]): The list of datapoints for the draw lines - each datapoint will be labeled.
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the comparison. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be match up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts for the draw lines i.e links to the images / videos. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
        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 draw lines. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the draw lines. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the draw lines. Defaults to []. Decides in what order the tasks should be shown.
        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.

    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,
        )

create_timestamp_order

create_timestamp_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    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.

Warning

This order is currently not fully supported and may give unexpected results.

With this order you can have people mark specific timestamps in a datapoint (video, audio). The annotators will be shown a datapoint and will be asked to select a timestamp based on the instruction.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
instruction	str	The instruction for the timestamp task. Will be shown along side each datapoint.	required
datapoints	list[str]	The list of datapoints for the timestamp - each datapoint will be labeled.	required
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
contexts	list[str]	The list of contexts for the comparison. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint) Will be match up with the datapoints using the list index.	None
media_contexts	list[str]	The list of media contexts for the timestamp i.e links to the images / videos. Defaults to None. If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)	None
validation_set_id	str	The ID of the validation set. Defaults to None. If provided, one validation task will be shown infront of the datapoints that will be labeled.	None
filters	Sequence[RapidataFilter]	The list of filters for the timestamp. Defaults to []. Decides who the tasks should be shown to.	None
settings	Sequence[RapidataSetting]	The list of settings for the timestamp. Defaults to []. Decides how the tasks should be shown.	None
selections	Sequence[RapidataSelection]	The list of selections for the timestamp. Defaults to []. Decides in what order the tasks should be shown.	None
private_notes	list[str]	The list of private notes for the timestamp. Defaults to None. If provided has to be the same length as datapoints. This will NOT be shown to the labelers but will be included in the result purely for your own reference.	None

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def create_timestamp_order(
    self,
    name: str,
    instruction: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    media_contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    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.

    Warning:
        This order is currently not fully supported and may give unexpected results.

    With this order you can have people mark specific timestamps in a datapoint (video, audio).
    The annotators will be shown a datapoint and will be asked to select a timestamp based on the instruction.

    Args:
        name (str): The name of the order.
        instruction (str): The instruction for the timestamp task. Will be shown along side each datapoint.
        datapoints (list[str]): The list of datapoints for the timestamp - each datapoint will be labeled.
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        contexts (list[str], optional): The list of contexts for the comparison. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
            Will be match up with the datapoints using the list index.
        media_contexts (list[str], optional): The list of media contexts for the timestamp i.e links to the images / videos. Defaults to None.\n
            If provided has to be the same length as datapoints and will be shown in addition to the instruction. (Therefore will be different for each datapoint)
        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 timestamp. Defaults to []. Decides who the tasks should be shown to.
        settings (Sequence[RapidataSetting], optional): The list of settings for the timestamp. Defaults to []. Decides how the tasks should be shown.
        selections (Sequence[RapidataSelection], optional): The list of selections for the timestamp. Defaults to []. Decides in what order the tasks should be shown.
        private_notes (list[str], optional): The list of private notes for the timestamp. 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.
    """

    with tracer.start_as_current_span(
        "RapidataOrderManager.create_timestamp_order"
    ):
        from rapidata.rapidata_client.workflow import TimestampWorkflow

        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,
        )

get_order_by_id

get_order_by_id(order_id: str) -> RapidataOrder

Get an order by ID.

Parameters:

Name	Type	Description	Default
order_id	str	The ID of the order.	required

Returns:

Name	Type	Description
RapidataOrder	RapidataOrder	The Order instance.

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

def get_order_by_id(self, order_id: str) -> RapidataOrder:
    """Get an order by ID.

    Args:
        order_id (str): The ID of the order.

    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)

        return RapidataOrder(
            order_id=order_id,
            name=order.order_name,
            openapi_service=self.__openapi_service,
        )

find_orders

find_orders(
    name: str = "", amount: int = 10
) -> list[RapidataOrder]

Find your recent orders given criteria. If nothing is provided, it will return the most recent order.

Parameters:

Name	Type	Description	Default
name	str	The name of the order - matching order will contain the name. Defaults to "" for any order.	''
amount	int	The amount of orders to return. Defaults to 10.	10

Returns:

Type	Description
list[RapidataOrder]	list[RapidataOrder]: A list of RapidataOrder instances.

Source code in src/rapidata/rapidata_client/order/rapidata_order_manager.py

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.

    Args:
        name (str, optional): The name of the order - matching order will contain the name. Defaults to "" for any order.
        amount (int, optional): The amount of orders to return. Defaults to 10.

    Returns:
        list[RapidataOrder]: A list of RapidataOrder instances.
    """
    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"
                    )
                ],
            )
        )

        orders = [
            self.get_order_by_id(order.id) for order in order_page_result.items
        ]
        return orders