rapidata 2.22.0__tar.gz → 2.23.0__tar.gz

{rapidata-2.22.0 → rapidata-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.22.0
+Version: 2.23.0
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG

{rapidata-2.22.0 → rapidata-2.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.22.0"
+version = "2.23.0"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.22.0 → rapidata-2.23.0}/src/rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -37,6 +37,7 @@ class RapidataDataset:
     def _add_texts(
         self,
         text_assets: list[TextAsset] | list[MultiAsset],
+        metadata_list: Sequence[Sequence[Metadata]] | None = None,
         max_workers: int = 10,
     ):
         for text_asset in text_assets:
@@ -45,17 +46,25 @@ class RapidataDataset:
                     isinstance(asset, TextAsset) for asset in text_asset.assets
                 ), "All assets in a MultiAsset must be of type TextAsset."
 
-        def upload_text_datapoint(text_asset: TextAsset | MultiAsset, index: int) -> None:
+        def upload_text_datapoint(text_asset: TextAsset | MultiAsset, metadata_per_datapoint: Sequence[Metadata] | None, index: int) -> None:
             if isinstance(text_asset, TextAsset):
                 texts = [text_asset.text]
             elif isinstance(text_asset, MultiAsset):
                 texts = [asset.text for asset in text_asset.assets if isinstance(asset, TextAsset)]
             else:
                 raise ValueError(f"Unsupported asset type: {type(text_asset)}")
+            
+            metadata = []
+            if metadata_per_datapoint:
+                for meta in metadata_per_datapoint:
+                    meta_model = meta.to_model() if meta else None
+                    if meta_model:
+                        metadata.append(CreateDatapointFromFilesModelMetadataInner(meta_model))
 
             model = CreateDatapointFromTextSourcesModel(
                 textSources=texts,
                 sortIndex=index,
+                metadata=metadata,
             )
 
             upload_response = self.openapi_service.dataset_api.dataset_dataset_id_datapoints_texts_post(dataset_id=self.dataset_id, create_datapoint_from_text_sources_model=model)
@@ -66,8 +75,8 @@ class RapidataDataset:
         total_uploads = len(text_assets)
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = [
-                executor.submit(upload_text_datapoint, text_asset, index=i)
-                for i, text_asset in enumerate(text_assets)
+                executor.submit(upload_text_datapoint, text_asset, metadata, index=i)
+                for i, (text_asset, metadata) in enumerate(zip_longest(text_assets, metadata_list or []))
             ]
 
             with tqdm(total=total_uploads, desc="Uploading text datapoints") as pbar:
@@ -78,7 +87,7 @@ class RapidataDataset:
     def _process_single_upload(
         self,
         media_asset: MediaAsset | MultiAsset, 
-        meta: Metadata | None, 
+        meta_list: Sequence[Metadata] | None, 
         index: int,
     ) -> tuple[list[str], list[str]]:
         """
@@ -86,7 +95,7 @@ class RapidataDataset:
         
         Args:
             media_asset: MediaAsset or MultiAsset to upload
-            meta: Optional metadata for the asset
+            meta_list: Optional sequence of metadata for the asset
             index: Sort index for the upload
             
         Returns:
@@ -104,16 +113,20 @@ class RapidataDataset:
                 identifiers_to_track = [identifier] if identifier else []
             elif isinstance(media_asset, MultiAsset):
                 assets = cast(list[MediaAsset], media_asset.assets)
-                identifiers_to_track: list[str] = [
+                identifiers_to_track = [
                     (asset._url if asset._url else cast(str, asset.path)) 
                     for asset in assets
                 ]
             else:
                 raise ValueError(f"Unsupported asset type: {type(media_asset)}")
 
-            meta_model = meta.to_model() if meta else None
-
-            metadata = [CreateDatapointFromFilesModelMetadataInner(meta_model)] if meta_model else []
+            # Convert multiple metadata to models
+            metadata = []
+            if meta_list:
+                for meta in meta_list:
+                    meta_model = meta.to_model() if meta else None
+                    if meta_model:
+                        metadata.append(CreateDatapointFromFilesModelMetadataInner(meta_model))
 
             local_paths: bool = assets[0].is_local()
             files: list[StrictStr] = []
@@ -258,7 +271,7 @@ class RapidataDataset:
     def _process_uploads_in_chunks(
         self,
         media_paths: list[MediaAsset] | list[MultiAsset],
-        metadata: Sequence[Metadata] | None,
+        multi_metadata: Sequence[Sequence[Metadata]] | None,
         max_workers: int,
         chunk_size: int,
         stop_progress_tracking: threading.Event,
@@ -269,7 +282,7 @@ class RapidataDataset:
         
         Args:
             media_paths: List of assets to upload
-            metadata: Optional sequence of metadata
+            multi_metadata: Optional sequence of sequences of metadata
             max_workers: Maximum number of concurrent workers
             chunk_size: Number of items to process in each batch
             stop_progress_tracking: Event to signal progress tracking to stop
@@ -285,16 +298,16 @@ class RapidataDataset:
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
                 # Process uploads in chunks to avoid overwhelming the system
                 for chunk_idx, chunk in enumerate(chunk_list(media_paths, chunk_size)):
-                    chunk_metadata = metadata[chunk_idx * chunk_size:(chunk_idx + 1) * chunk_size] if metadata else None
+                    chunk_multi_metadata = multi_metadata[chunk_idx * chunk_size:(chunk_idx + 1) * chunk_size] if multi_metadata else None
                     
                     futures = [
                         executor.submit(
                             self._process_single_upload, 
                             media_asset, 
-                            meta, 
+                            meta_list, 
                             index=(chunk_idx * chunk_size + i)
                         )
-                        for i, (media_asset, meta) in enumerate(zip_longest(chunk, chunk_metadata or []))
+                        for i, (media_asset, meta_list) in enumerate(zip_longest(chunk, chunk_multi_metadata or []))
                     ]
                     
                     # Wait for this chunk to complete before starting the next one
@@ -359,7 +372,7 @@ class RapidataDataset:
     def _add_media_from_paths(
         self,
         media_paths: list[MediaAsset] | list[MultiAsset],
-        metadata: Sequence[Metadata] | None = None,
+        multi_metadata: Sequence[Sequence[Metadata]] | None = None,
         max_workers: int = 5,
         chunk_size: int = 50,
         progress_poll_interval: float = 0.5,
@@ -369,7 +382,7 @@ class RapidataDataset:
         
         Args:
             media_paths: List of MediaAsset or MultiAsset objects to upload
-            metadata: Optional sequence of metadata matching media_paths length
+            multi_metadata: Optional sequence of sequences of metadata matching media_paths length
             max_workers: Maximum number of concurrent upload workers
             chunk_size: Number of items to process in each batch
             progress_poll_interval: Time in seconds between progress checks
@@ -378,10 +391,14 @@ class RapidataDataset:
             tuple[list[str], list[str]]: Lists of successful and failed URLs
             
         Raises:
-            ValueError: If metadata length doesn't match media_paths length
+            ValueError: If multi_metadata lengths don't match media_paths length
         """
-        if metadata is not None and len(metadata) != len(media_paths):
-            raise ValueError("metadata must be None or have the same length as media_paths")
+
+        if multi_metadata and not len(multi_metadata) == len(media_paths):
+            raise ValueError("The number of assets must match the number of metadatas.")
+        
+        if multi_metadata and not all(len(data) == len(multi_metadata[0]) for data in multi_metadata):
+            raise ValueError("All metadatas must have the same length.")
         
         # Setup tracking variables
         total_uploads = len(media_paths)
@@ -403,7 +420,7 @@ class RapidataDataset:
         try:
             successful_uploads, failed_uploads = self._process_uploads_in_chunks(
                 media_paths,
-                metadata,
+                multi_metadata,
                 max_workers,
                 chunk_size,
                 stop_progress_tracking,

{rapidata-2.22.0 → rapidata-2.23.0}/src/rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -53,7 +53,7 @@ class RapidataOrderBuilder:
         self.__dataset: Optional[RapidataDataset]
         self.__workflow: Workflow | None = None
         self.__referee: Referee | None = None
-        self.__metadata: Sequence[Metadata] | None = None
+        self.__multi_metadata: Sequence[Sequence[Metadata]] | None = None
         self.__validation_set_id: str | None = None
         self.__settings: Sequence[RapidataSetting] | None = None
         self.__user_filters: list[RapidataFilter] = []
@@ -151,13 +151,13 @@ class RapidataOrderBuilder:
 
         if all(isinstance(item, MediaAsset) for item in self.__assets) and self.__dataset:
             assets = cast(list[MediaAsset], self.__assets)
-            self.__dataset._add_media_from_paths(assets, self.__metadata, max_upload_workers)
+            self.__dataset._add_media_from_paths(assets, self.__multi_metadata, max_upload_workers)
 
         elif (
             all(isinstance(item, TextAsset) for item in self.__assets) and self.__dataset
         ):
             assets = cast(list[TextAsset], self.__assets)
-            self.__dataset._add_texts(assets)
+            self.__dataset._add_texts(assets, self.__multi_metadata)
 
         elif (
             all(isinstance(item, MultiAsset) for item in self.__assets) and self.__dataset
@@ -178,11 +178,11 @@ class RapidataOrderBuilder:
             # Process based on the asset type
             if issubclass(first_asset_type, MediaAsset):
                 self.__dataset._add_media_from_paths(
-                    multi_assets, self.__metadata, max_upload_workers
+                    multi_assets, self.__multi_metadata, max_upload_workers
                 )
 
             elif issubclass(first_asset_type, TextAsset):
-                self.__dataset._add_texts(multi_assets)
+                self.__dataset._add_texts(multi_assets, self.__multi_metadata)
 
             else:
                 raise ValueError(
@@ -234,35 +234,44 @@ class RapidataOrderBuilder:
 
     def _media(
         self,
-        asset: Sequence[BaseAsset],
-        metadata: Sequence[Metadata] | None = None,
+        assets: Sequence[BaseAsset],
+        multi_metadata: Sequence[Sequence[Metadata]] | None = None,
     ) -> "RapidataOrderBuilder":
         """
         Set the media assets for the order.
 
         Args:
-            asset: (list[MediaAsset] | list[TextAsset] | list[MultiAsset]): The paths of the media assets to be set.
-            metadata: (list[Metadata] | None, optional): Metadata for the media assets. Defaults to None.
+            assets: (list[MediaAsset] | list[TextAsset] | list[MultiAsset]): The paths of the media assets to be set.
+            multi_metadata: (list[list[Metadata]] | None, optional): Metadatas for the media assets. Defaults to None.
 
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        if not isinstance(asset, list):
+        if not isinstance(assets, list):
             raise TypeError("Media paths must be provided as a list of paths.")
 
-        for a in asset:
+        for a in assets:
             if not isinstance(a, (MediaAsset, TextAsset, MultiAsset)):
                 raise TypeError(
                     "Media paths must be of type MediaAsset, TextAsset, or MultiAsset."
                 )
 
-        if metadata:
-            for data in metadata:
-                if not isinstance(data, Metadata):
-                    raise TypeError("Metadata must be of type Metadata.")
+        if multi_metadata:
+            for data in multi_metadata:
+                if not isinstance(data, list):
+                    raise TypeError("Metadata must be provided as a list of Metadata objects.")
+                for d in data:
+                    if not isinstance(d, Metadata):
+                        raise TypeError("Metadata must be of type Metadata.")
 
-        self.__assets = asset
-        self.__metadata = metadata
+        if multi_metadata and not len(multi_metadata) == len(assets):
+            raise ValueError("The number of assets must match the number of metadatas.")
+        
+        if multi_metadata and not all(len(data) == len(multi_metadata[0]) for data in multi_metadata):
+            raise ValueError("All metadatas must have the same length.")
+
+        self.__assets = assets
+        self.__multi_metadata = multi_metadata
         return self
 
     def _settings(self, settings: Sequence[RapidataSetting]) -> "RapidataOrderBuilder":

{rapidata-2.22.0 → rapidata-2.23.0}/src/rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -5,7 +5,7 @@ from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.assets.data_type_enum import RapidataDataTypes
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order._rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.metadata import PromptMetadata, SelectWordsMetadata
+from rapidata.rapidata_client.metadata import PromptMetadata, SelectWordsMetadata, PrivateTextMetadata, Metadata
 from rapidata.rapidata_client.referee._naive_referee import NaiveReferee
 from rapidata.rapidata_client.referee._early_stopping_referee import EarlyStoppingReferee
 from rapidata.rapidata_client.selection._base_selection import RapidataSelection
@@ -73,7 +73,8 @@ class RapidataOrderManager:
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
             sentences: list[str] | None = None,
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
             default_labeling_amount: int = 3
         ) -> RapidataOrder:
         
@@ -82,12 +83,12 @@ class RapidataOrderManager:
         
         if sentences and len(sentences) != len(assets):
             raise ValueError("Number of sentences must match number of datapoints")
+
+        if private_notes and len(private_notes) != len(assets):
+            raise ValueError("Number of private notes must match number of datapoints")
         
         if sentences and contexts:
             raise ValueError("You can only use contexts or sentences, not both")
-        
-        if contexts and data_type == RapidataDataTypes.TEXT:
-            logger.warning("Warning: Contexts are not supported for text data type. Ignoring contexts.")
 
         if not confidence_threshold:
             referee = NaiveReferee(responses=responses_per_datapoint)
@@ -102,19 +103,30 @@ class RapidataOrderManager:
         if selections and validation_set_id:
             logger.warning("Warning: Both selections and validation_set_id provided. Ignoring validation_set_id.")
         
-        if selections is None:
+        if not selections:
             selections = self.__get_selections(validation_set_id, labeling_amount=default_labeling_amount)
 
         prompts_metadata = [PromptMetadata(prompt=prompt) for prompt in contexts] if contexts else None
         sentence_metadata = [SelectWordsMetadata(select_words=sentence) for sentence in sentences] if sentences else None
 
-        metadata = prompts_metadata or sentence_metadata or None
+        if prompts_metadata and sentence_metadata:
+            raise ValueError("You can only use contexts or sentences, not both")
+
+        metadata_list: Sequence[Metadata] = prompts_metadata or sentence_metadata or []
+        private_notes_metadata_list: Sequence[Metadata] = [PrivateTextMetadata(text=text) for text in private_notes] if private_notes else []
+
+        multi_metadata: Sequence[Sequence[Metadata]] = (
+            [[metadata, private_notes_metadata] for metadata, private_notes_metadata in zip(metadata_list, private_notes_metadata_list, strict=True)] if metadata_list and private_notes
+            else [[private_notes_metadata] for private_notes_metadata in private_notes_metadata_list] if private_notes
+            else [[metadata] for metadata in metadata_list] if metadata_list
+            else []
+        )
 
         order = (order_builder
                  ._workflow(workflow)
                  ._media(
-                     asset=assets,
-                     metadata=metadata
+                     assets=assets,
+                     multi_metadata=multi_metadata
                      )
                  ._referee(referee)
                  ._filters(filters)
@@ -140,7 +152,8 @@ class RapidataOrderManager:
             confidence_threshold: float | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a classification order.
         
@@ -161,7 +174,10 @@ class RapidataOrderManager:
                 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.
+            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.
         """
         
         if data_type == RapidataDataTypes.MEDIA:
@@ -185,7 +201,8 @@ class RapidataOrderManager:
             confidence_threshold=confidence_threshold,
             filters=filters,
             selections=selections,
-            settings=settings
+            settings=settings,
+            private_notes=private_notes
         )
     
     def create_compare_order(self,
@@ -199,7 +216,8 @@ class RapidataOrderManager:
             confidence_threshold: float | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a compare order.
 
@@ -219,7 +237,10 @@ class RapidataOrderManager:
                 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.
+            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.
         """
 
         if data_type == RapidataDataTypes.MEDIA:
@@ -242,7 +263,8 @@ class RapidataOrderManager:
             confidence_threshold=confidence_threshold,
             filters=filters,
             selections=selections,
-            settings=settings
+            settings=settings,
+            private_notes=private_notes
         )
 
     def create_ranking_order(self,
@@ -257,7 +279,7 @@ class RapidataOrderManager:
                              validation_set_id: Optional[str] = None,
                              filters: Sequence[RapidataFilter] = [],
                              settings: Sequence[RapidataSetting] = [],
-                             selections: Optional[Sequence[RapidataSelection]] = None
+                             selections: Sequence[RapidataSelection] = []
                              ) -> RapidataOrder:
         """
         Create a ranking order.
@@ -278,7 +300,7 @@ class RapidataOrderManager:
                 If provided, one validation task will be shown infront of the datapoints that will be labeled.
             filters (Sequence[RapidataFilter], optional): The list of filters for the order. Defaults to []. Decides who the tasks should be shown to.
             settings (Sequence[RapidataSetting], optional): The list of settings for the order. Defaults to []. Decides how the tasks should be shown.
-            selections (Sequence[RapidataSelection], optional): The list of selections for the order. Defaults to None. Decides in what order the tasks should be shown.
+            selections (Sequence[RapidataSelection], optional): The list of selections for the order. Defaults to []. Decides in what order the tasks should be shown.
         """
 
         if data_type == RapidataDataTypes.MEDIA:
@@ -301,7 +323,7 @@ class RapidataOrderManager:
             validation_set_id=validation_set_id,
             filters=filters,
             selections=selections,
-            settings=settings
+            settings=settings,
         )
 
     def create_free_text_order(self,
@@ -312,7 +334,8 @@ class RapidataOrderManager:
             responses_per_datapoint: int = 10,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a free text order.
 
@@ -325,7 +348,10 @@ class RapidataOrderManager:
             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.
+            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.
         """
 
         if data_type == RapidataDataTypes.MEDIA:
@@ -346,7 +372,8 @@ class RapidataOrderManager:
             filters=filters,
             selections=selections,
             settings=settings,
-            default_labeling_amount=1
+            default_labeling_amount=1,
+            private_notes=private_notes
         )
     
     def create_select_words_order(self,
@@ -358,7 +385,8 @@ class RapidataOrderManager:
             validation_set_id: str | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a select words order.
 
@@ -373,7 +401,10 @@ class RapidataOrderManager:
                 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.
+            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.
         """
 
         assets = [MediaAsset(path=path) for path in datapoints]
@@ -390,7 +421,8 @@ class RapidataOrderManager:
             selections=selections,
             settings=settings,
             sentences=sentences,
-            default_labeling_amount=2
+            default_labeling_amount=2,
+            private_notes=private_notes
         )
     
     def create_locate_order(self,
@@ -402,7 +434,8 @@ class RapidataOrderManager:
             validation_set_id: str | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a locate order.
 
@@ -418,7 +451,10 @@ class RapidataOrderManager:
                 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.
+            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.
         """
 
         assets = [MediaAsset(path=path) for path in datapoints]
@@ -432,7 +468,8 @@ class RapidataOrderManager:
             validation_set_id=validation_set_id,
             filters=filters,
             selections=selections,
-            settings=settings
+            settings=settings,
+            private_notes=private_notes
         )
 
     def create_draw_order(self,
@@ -444,7 +481,8 @@ class RapidataOrderManager:
             validation_set_id: str | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a draw order.
 
@@ -460,7 +498,10 @@ class RapidataOrderManager:
                 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.
+            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.
         """
 
         assets = [MediaAsset(path=path) for path in datapoints]
@@ -474,7 +515,8 @@ class RapidataOrderManager:
             validation_set_id=validation_set_id,
             filters=filters,
             selections=selections,
-            settings=settings
+            settings=settings,
+            private_notes=private_notes
         )
     
     def create_timestamp_order(self,
@@ -486,7 +528,8 @@ class RapidataOrderManager:
             validation_set_id: str | None = None,
             filters: Sequence[RapidataFilter] = [],
             settings: Sequence[RapidataSetting] = [],
-            selections: Sequence[RapidataSelection] | None = None,
+            selections: Sequence[RapidataSelection] = [],
+            private_notes: list[str] | None = None,
         ) -> RapidataOrder:
         """Create a timestamp order.
 
@@ -499,9 +542,13 @@ class RapidataOrderManager:
                 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 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 None. Decides in what order 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.
         """
 
         assets = [MediaAsset(path=path) for path in datapoints]
@@ -522,7 +569,8 @@ class RapidataOrderManager:
             filters=filters,
             selections=selections,
             settings=settings,
-            default_labeling_amount=2
+            default_labeling_amount=2,
+            private_notes=private_notes
         )
 
     def get_order_by_id(self, order_id: str) -> RapidataOrder: