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
    self.__priority = 50

create_classification_order

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

Create a classification order.

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 RapidataDataTypes.MEDIA. Other option: RapidataDataTypes.TEXT ("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
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.	[]
settings	Sequence[RapidataSetting]	The list of settings for the classification. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the classification. Defaults to None. Decides in what order the tasks should be shown.	None

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: str = RapidataDataTypes.MEDIA,
        responses_per_datapoint: int = 10,
        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] | None = None,
    ) -> RapidataOrder:
    """Create a classification order.

    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 RapidataDataTypes.MEDIA. \n
            Other option: RapidataDataTypes.TEXT ("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.
        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 None. Decides in what order the tasks should be shown.
    """

    if data_type == RapidataDataTypes.MEDIA:
        assets = [MediaAsset(path=path) for path in datapoints]
    elif data_type == RapidataDataTypes.TEXT:
        assets = [TextAsset(text=text) for text in datapoints]
    else:
        raise ValueError(f"Unsupported data type: {data_type}, must be one of {RapidataDataTypes._possible_values()}")

    return self.__create_general_order(
        name=name,
        workflow=ClassifyWorkflow(
            instruction=instruction,
            answer_options=answer_options
        ),
        assets=assets,
        data_type=data_type,
        responses_per_datapoint=responses_per_datapoint,
        contexts=contexts,
        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: str = MEDIA,
    responses_per_datapoint: int = 10,
    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] | None = None,
) -> RapidataOrder

Create a compare order.

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 RapidataDataTypes.MEDIA. Other option: RapidataDataTypes.TEXT ("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 match 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
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.	[]
settings	Sequence[RapidataSetting]	The list of settings for the comparison. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the comparison. Defaults to None. Decides in what order the tasks should be shown.	None

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: str = RapidataDataTypes.MEDIA,
        responses_per_datapoint: int = 10,
        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] | None = None,
    ) -> RapidataOrder:
    """Create a compare order.

    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 RapidataDataTypes.MEDIA. \n
            Other option: RapidataDataTypes.TEXT ("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 match 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.
        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 None. Decides in what order the tasks should be shown.
    """

    if data_type == RapidataDataTypes.MEDIA:
        assets = [MultiAsset([MediaAsset(path=path) for path in datapoint]) for datapoint in datapoints]
    elif data_type == RapidataDataTypes.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 {RapidataDataTypes._possible_values()}")

    return self.__create_general_order(
        name=name,
        workflow=CompareWorkflow(
            instruction=instruction
        ),
        assets=assets,
        data_type=data_type,
        responses_per_datapoint=responses_per_datapoint,
        contexts=contexts,
        validation_set_id=validation_set_id,
        confidence_threshold=confidence_threshold,
        filters=filters,
        selections=selections,
        settings=settings
    )

create_free_text_order

create_free_text_order(
    name: str,
    instruction: str,
    datapoints: list[str],
    data_type: str = MEDIA,
    responses_per_datapoint: int = 10,
    filters: Sequence[RapidataFilter] = [],
    settings: Sequence[RapidataSetting] = [],
    selections: Sequence[RapidataSelection] | None = None,
) -> RapidataOrder

Create a free text order.

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 RapidataDataTypes.MEDIA. Other option: RapidataDataTypes.TEXT ("text").	MEDIA
responses_per_datapoint	int	The number of responses that will be collected per datapoint. Defaults to 10.	10
filters	Sequence[RapidataFilter]	The list of filters for the free text. Defaults to []. Decides who the tasks should be shown to.	[]
settings	Sequence[RapidataSetting]	The list of settings for the free text. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the free text. Defaults to None. Decides in what order the tasks should be shown.	None

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: str = RapidataDataTypes.MEDIA,
        responses_per_datapoint: int = 10,
        filters: Sequence[RapidataFilter] = [],
        settings: Sequence[RapidataSetting] = [],
        selections: Sequence[RapidataSelection] | None = None,
    ) -> RapidataOrder:
    """Create a free text order.

    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 RapidataDataTypes.MEDIA. \n
            Other option: RapidataDataTypes.TEXT ("text").
        responses_per_datapoint (int, optional): The number of responses that will be collected per datapoint. Defaults to 10.
        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 None. Decides in what order the tasks should be shown.
    """

    if data_type == RapidataDataTypes.MEDIA:
        assets = [MediaAsset(path=path) for path in datapoints]
    elif data_type == RapidataDataTypes.TEXT:
        assets = [TextAsset(text=text) for text in datapoints]
    else:
        raise ValueError(f"Unsupported data type: {data_type}, must be one of {RapidataDataTypes._possible_values()}")

    return self.__create_general_order(
        name=name,
        workflow=FreeTextWorkflow(
            instruction=instruction
        ),
        assets=assets,
        data_type=data_type,
        responses_per_datapoint=responses_per_datapoint,
        filters=filters,
        selections=selections,
        settings=settings,
        default_labeling_amount=1
    )

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] = [],
    settings: Sequence[RapidataSetting] = [],
    selections: Sequence[RapidataSelection] | None = None,
) -> RapidataOrder

Create a select words order.

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.	[]
settings	Sequence[RapidataSetting]	The list of settings for the select words. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the select words. Defaults to None. Decides in what order the tasks should be shown.	None

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] = [],
        settings: Sequence[RapidataSetting] = [],
        selections: Sequence[RapidataSelection] | None = None,
    ) -> RapidataOrder:
    """Create a select words order.

    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 None. Decides in what order the tasks should be shown.
    """

    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,
        default_labeling_amount=2
    )

create_locate_order

create_locate_order(
    name: str,
    target: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    filters: Sequence[RapidataFilter] = [],
    settings: Sequence[RapidataSetting] = [],
    selections: Sequence[RapidataSelection] | None = None,
) -> RapidataOrder

Create a locate order.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
target	str	The target 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 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
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.	[]
settings	Sequence[RapidataSetting]	The list of settings for the locate. Defaults to []. Decides how the tasks should be shown.	[]
selections	Sequence[RapidataSelection]	The list of selections for the locate. Defaults to None. Decides in what order the tasks should be shown.	None

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

def create_locate_order(self,
        name: str,
        target: str,
        datapoints: list[str],
        responses_per_datapoint: int = 10,
        contexts: list[str] | None = None,
        validation_set_id: str | None = None,
        filters: Sequence[RapidataFilter] = [],
        settings: Sequence[RapidataSetting] = [],
        selections: Sequence[RapidataSelection] | None = None,
    ) -> RapidataOrder:
    """Create a locate order.

    Args:
        name (str): The name of the order.
        target (str): The target 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 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.
        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 None. Decides in what order the tasks should be shown.
    """

    assets = [MediaAsset(path=path) for path in datapoints]

    return self.__create_general_order(
        name=name,
        workflow=LocateWorkflow(target=target),
        assets=assets,
        responses_per_datapoint=responses_per_datapoint,
        contexts=contexts,
        validation_set_id=validation_set_id,
        filters=filters,
        selections=selections,
        settings=settings
    )

create_draw_order

create_draw_order(
    name: str,
    target: str,
    datapoints: list[str],
    responses_per_datapoint: int = 10,
    contexts: list[str] | None = None,
    validation_set_id: str | None = None,
    filters: Sequence[RapidataFilter] = [],
    settings: Sequence[RapidataSetting] = [],
    selections: Sequence[RapidataSelection] | None = None,
) -> RapidataOrder

Create a draw order.

Parameters:

Name	Type	Description	Default
name	str	The name of the order.	required
target	str	The target 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
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 None. Decides in what order the tasks should be shown.	None

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

def create_draw_order(self,
        name: str,
        target: str,
        datapoints: list[str],
        responses_per_datapoint: int = 10,
        contexts: list[str] | None = None,
        validation_set_id: str | None = None,
        filters: Sequence[RapidataFilter] = [],
        settings: Sequence[RapidataSetting] = [],
        selections: Sequence[RapidataSelection] | None = None,
    ) -> RapidataOrder:
    """Create a draw order.

    Args:
        name (str): The name of the order.
        target (str): The target 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.
        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 None. Decides in what order the tasks should be shown.
    """

    assets = [MediaAsset(path=path) for path in datapoints]

    return self.__create_general_order(
        name=name,
        workflow=DrawWorkflow(target=target),
        assets=assets,
        responses_per_datapoint=responses_per_datapoint,
        contexts=contexts,
        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.
    """

    try:
        order = self._openapi_service.order_api.order_get_by_id_get(order_id)
    except Exception:
        raise ValueError(f"Order with ID {order_id} not found.")

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

find_orders

find_orders(
    name: str = "", amount: int = 1
) -> 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 1.	1

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 = 1) -> 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 1.

    Returns:
        list[RapidataOrder]: A list of RapidataOrder instances.
    """
    try:
        order_page_result = self._openapi_service.order_api.order_query_get(QueryModel(
            page=PageInfo(index=1, size=amount),
            filter=RootFilter(filters=[Filter(field="OrderName", operator="Contains", value=name)]),
            sortCriteria=[SortCriterion(direction="Desc", propertyName="OrderDate")]
            ))

    except BadRequestException as e:
        raise ValueError(f"Error occured during request. \nError: {e.body} \nTraceid: {e.headers.get('X-Trace-Id') if isinstance(e.headers, HTTPHeaderDict) else 'Unknown'}")

    except Exception as e:
        raise ValueError(f"Unknown error occured: {e}")

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