rapidata 1.8.3__py3-none-any.whl → 1.10.0__py3-none-any.whl

rapidata/rapidata_client/rapidata_client.py

@@ -5,10 +5,12 @@ from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.dataset.rapidata_dataset import RapidataDataset
 
+from rapidata.rapidata_client.order.order_builder import BaseOrderBuilder
+
 from rapidata.rapidata_client.simple_builders.simple_classification_builders import ClassificationQuestionBuilder
 from rapidata.rapidata_client.simple_builders.simple_compare_builders import CompareCriteriaBuilder
 from rapidata.rapidata_client.simple_builders.simple_free_text_builders import FreeTextQuestionBuilder
-from rapidata.rapidata_client.simple_builders.simple_transcription_builders import TranscriptionInstructionBuilder
+from rapidata.rapidata_client.simple_builders.simple_select_words_builders import SelectWordsInstructionBuilder
 
 from rapidata.rapidata_client.dataset.rapid_builders import BaseRapidBuilder
 
@@ -28,8 +30,6 @@ from deprecated import deprecated
 
 class RapidataClient:
     """The Rapidata client is the main entry point for interacting with the Rapidata API. It allows you to create orders and validation sets."""
-
-    rapid_builder = BaseRapidBuilder()
     
     def __init__(
         self,
@@ -53,8 +53,12 @@ class RapidataClient:
             oauth_scope=oauth_scope,
             cert_path=cert_path
         )
+        
+        self.rapid_builder = BaseRapidBuilder()
+
+        self.order_builder = BaseOrderBuilder(openapi_service=self.openapi_service)
     
-    @deprecated("Use the specific builder methods instead.")
+    @deprecated("Use the order_builder instead.")
     def new_order(self, name: str) -> RapidataOrderBuilder:
         """Create a new order using a RapidataOrderBuilder instance.
 
@@ -64,7 +68,22 @@ class RapidataClient:
         Returns:
             RapidataOrderBuilder: A RapidataOrderBuilder instance.
         """
-        return RapidataOrderBuilder(openapi_service=self.openapi_service, name=name)
+        return self.new_advanced_order(name)
+    
+    @deprecated("Use the order_builder instead.")
+    def new_advanced_order(self, name: str) -> RapidataOrderBuilder:
+        """Create a new order using a RapidataOrderBuilder instance.
+        This method is intended for creating orders with complex requirements that can not be fulfilled with the specific builders.
+        For any other order, it is recommended to use the specific builder methods.
+        example: create_classify_order, create_compare_order, create_free_text_order, create_select_words_order
+
+        Args:
+            name (str): The name of the order.
+
+        Returns:
+            RapidataOrderBuilder: A RapidataOrderBuilder instance.
+        """
+        return RapidataOrderBuilder(name=name, openapi_service=self.openapi_service)
 
     def new_validation_set(self, name: str) -> ValidationSetBuilder:
         """Create a new validation set using a ValidationDatasetBuilder instance.
@@ -161,6 +180,7 @@ class RapidataClient:
         orders = [self.get_validation_set(validation_set.id) for validation_set in validation_page_result.items] # type: ignore # will be fixed with the next backend deployment
         return orders
 
+    @deprecated("Use the order_builder instead.")
     def create_classify_order(self, name: str) -> ClassificationQuestionBuilder:
         """Create a new classification order where people are asked to classify an image.
 
@@ -172,6 +192,7 @@ class RapidataClient:
         """
         return ClassificationQuestionBuilder(name=name, openapi_service=self.openapi_service)
 
+    @deprecated("Use the order_builder instead.")
     def create_compare_order(self, name: str) -> CompareCriteriaBuilder:
         """Create a new comparison order where people are asked to compare two images.
 
@@ -183,6 +204,7 @@ class RapidataClient:
         """
         return CompareCriteriaBuilder(name=name, openapi_service=self.openapi_service)
     
+    @deprecated("Use the order_builder instead.")
     def create_free_text_order(self, name: str) -> FreeTextQuestionBuilder:
         """Create a new free text order where people are asked to provide a free text answer.
 
@@ -194,14 +216,15 @@ class RapidataClient:
         """
         return FreeTextQuestionBuilder(name=name, openapi_service=self.openapi_service)
     
-    def create_transcription_order(self, name: str) -> TranscriptionInstructionBuilder:
-        """Create a new transcription order where people are asked to transcribe an audio file.
+    @deprecated("Use the order_builder instead.")
+    def create_select_words_order(self, name: str) -> SelectWordsInstructionBuilder:
+        """Create a new select words order where people are asked to transcribe an audio file.
 
         Args:
             name (str): The name of the order.
 
         Returns:
-            TranscriptionInstructionBuilder: A TranscriptionInstructionBuilder instance.
+            SelectWordsInstructionBuilder: A SelectWordsInstructionBuilder instance.
         """
-        return TranscriptionInstructionBuilder(name=name, openapi_service=self.openapi_service)
+        return SelectWordsInstructionBuilder(name=name, openapi_service=self.openapi_service)
 

rapidata/rapidata_client/selection/capped_selection.py

@@ -21,5 +21,5 @@ class CappedSelection(Selection):
                 CappedSelectionSelectionsInner(selection.to_model())
                 for selection in self.selections
             ],
-            max_rapids=self.max_rapids,
+            maxRapids=self.max_rapids,
         )

rapidata/rapidata_client/simple_builders/simple_classification_builders.py

@@ -28,7 +28,7 @@ class ClassificationOrderBuilder:
         self._options = options
         self._media_assets = media_assets
         self._responses_required = 10
-        self._probability_threshold = None
+        self._confidence_threshold = None
         self._metadata = None
         self._validation_set_id = None
         self._filters: list[Filter] = []
@@ -54,12 +54,16 @@ class ClassificationOrderBuilder:
 
     def responses(self, responses_required: int) -> 'ClassificationOrderBuilder':
         """Set the number of responses required per datapoint for the classification order. Will default to 10."""
+        if responses_required < 1:
+            raise ValueError("Responses required must be at least 1")
+        
         self._responses_required = responses_required
         return self
 
-    def probability_threshold(self, probability_threshold: float) -> 'ClassificationOrderBuilder':
-        """Set the probability threshold for early stopping."""
-        self._probability_threshold = probability_threshold
+    def confidence_threshold(self, confidence_threshold: float) -> 'ClassificationOrderBuilder':
+        """Set the confidence threshold for early stopping.
+        That means that the order will either stop at the number of responses or when the confidence threshold is reached, whatever comes first."""
+        self._confidence_threshold = confidence_threshold
         return self
 
     def validation_set(self, validation_set_id: str) -> 'ClassificationOrderBuilder':
@@ -104,14 +108,27 @@ class ClassificationOrderBuilder:
 
         return self
 
-    @deprecated("Use .run instead.")
+    @deprecated("Use .submit instead.")
     def create(self, submit: bool = True, max_upload_workers: int = 10) -> 'RapidataOrder':
         """Create the classification order."""
-        return self.run(submit=submit, disable_link=False)
-
+        return self.submit(submit=submit, disable_link=False)
+    
+    @deprecated("Use .submit instead.")
     def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
         """Run the classification order.
         
+        Args:
+            submit (bool): Whether to submit the order. Defaults to True. \
+                Set this to False if you first want to see the order on your dashboard before running it.
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
+            
+        Returns:
+            RapidataOrder: The created classification order."""
+        return self.submit(submit=submit, disable_link=disable_link)
+
+    def submit(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
+        """Submit the classification order to be labeled.
+        
         Args:
             submit (bool): Whether to submit the order. Defaults to True. \
                 Set this to False if you first want to see the order on your dashboard before running it.
@@ -120,10 +137,10 @@ class ClassificationOrderBuilder:
         Returns:
             RapidataOrder: The created classification order."""
                 
-        if self._probability_threshold and self._responses_required:
+        if self._confidence_threshold:
             referee = EarlyStoppingReferee(
                 max_vote_count=self._responses_required,
-                threshold=self._probability_threshold
+                threshold=self._confidence_threshold
             )
 
         else:
@@ -219,6 +236,15 @@ class ClassificationOptionsBuilder:
 
     def options(self, options: list[str]) -> ClassificationMediaBuilder:
         """Set the answer options for the classification order."""
+        if not isinstance(options, list) or not all(isinstance(option, str) for option in options):
+            raise ValueError("Options must be a list of strings")
+        
+        if len(options) < 2:
+            raise ValueError("At least two options are required")
+        
+        if len(options) > 8:
+            raise ValueError("Maximum of 8 options allowed")
+
         self._options = options
         return self._build()
 

rapidata/rapidata_client/simple_builders/simple_compare_builders.py

@@ -23,13 +23,16 @@ class CompareOrderBuilder:
         self._responses_required = 10
         self._metadata = None
         self._validation_set_id = None
-        self._probability_threshold = None
+        self._confidence_threshold = None
         self._filters: list[Filter] = []
         self._settings = Settings()
         self._time_effort = time_effort
 
     def responses(self, responses_required: int) -> 'CompareOrderBuilder':
-        """Set the number of resoonses required per matchup/pairing for the comparison order. Will default to 10."""
+        """Set the number of resoonses required per matchup/pairing for the comparison order. Will default to 10 if not set."""
+        if responses_required < 1:
+            raise ValueError("Responses required must be at least 1.")
+        
         self._responses_required = responses_required
         return self
     
@@ -61,9 +64,10 @@ class CompareOrderBuilder:
         self._validation_set_id = validation_set_id
         return self
     
-    def probability_threshold(self, probability_threshold: float) -> 'CompareOrderBuilder':
-        """Set the probability threshold for early stopping."""
-        self._probability_threshold = probability_threshold
+    def confidence_threshold(self, confidence_threshold: float) -> 'CompareOrderBuilder':
+        """Set the confidence threshold for early stopping.
+        That means that the order will either stop at the number of responses or when the confidence threshold is reached, whatever comes first."""
+        self._confidence_threshold = confidence_threshold
         return self
     
     def countries(self, country_codes: list[str]) -> 'CompareOrderBuilder':
@@ -103,14 +107,27 @@ class CompareOrderBuilder:
 
         return self
     
-    @deprecated("Use .run instead.")
+    @deprecated("Use .submit instead.")
     def create(self, submit: bool = True, max_upload_workers: int = 10) -> 'RapidataOrder':
         """Create the classification order."""
-        return self.run(submit=submit, disable_link=False)
+        return self.submit(submit=submit, disable_link=False)
     
     def run(self, submit: bool = True, disable_link: bool = False) -> RapidataOrder:
         """Run the compare order.
         
+        Args:
+            submit (bool): Whether to submit the order. Defaults to True. \
+                Set this to False if you first want to see the order on your dashboard before running it.
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
+            
+        Returns:
+            RapidataOrder: The created compare order."""
+            
+        return self.submit(submit=submit, disable_link=disable_link)
+    
+    def submit(self, submit: bool = True, disable_link: bool = False) -> RapidataOrder:
+        """Submit the compare order to be labeled.
+        
         Args:
             submit (bool): Whether to submit the order. Defaults to True. \
                 Set this to False if you first want to see the order on your dashboard before running it.
@@ -119,10 +136,10 @@ class CompareOrderBuilder:
         Returns:
             RapidataOrder: The created compare order."""
         
-        if self._probability_threshold and self._responses_required:
+        if self._confidence_threshold:
             referee = EarlyStoppingReferee(
                 max_vote_count=self._responses_required,
-                threshold=self._probability_threshold
+                threshold=self._confidence_threshold
             )
 
         else:

rapidata/rapidata_client/simple_builders/simple_free_text_builders.py

@@ -72,10 +72,22 @@ class FreeTextOrderBuilder:
             self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
 
         return self
-
+    
     def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
         """Run the free text order.
         
+        Args:
+            submit (bool): Whether to submit the order. Defaults to True. \
+                Set this to False if you first want to see the order on your dashboard before running it.
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
+            
+        Returns:
+            RapidataOrder: The created free text order."""
+        return self.submit(submit=submit, disable_link=disable_link)
+
+    def submit(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
+        """Submit the free text order to be labeled.
+        
         Args:
             submit (bool): Whether to submit the order. Defaults to True. \
                 Set this to False if you first want to see the order on your dashboard before running it.

rapidata/rapidata_client/simple_builders/{simple_transcription_builders.py → simple_select_words_builders.py}

@@ -3,60 +3,60 @@ from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection.base_selection import Selection
-from rapidata.rapidata_client.workflow import TranscriptionWorkflow
+from rapidata.rapidata_client.workflow import SelectWordsWorkflow
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.assets import MediaAsset, BaseAsset
 from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
-from rapidata.rapidata_client.metadata import TranscriptionMetadata
+from rapidata.rapidata_client.metadata import SelectWordsMetadata
 from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
 
-class TranscriptionOrderBuilder:
+class SelectWordsOrderBuilder:
     def __init__(self, 
                  name: str, 
                  instruction: str, 
                  media_assets: list[BaseAsset], 
-                 transcription_texts: list[TranscriptionMetadata],
+                 texts: list[SelectWordsMetadata],
                  openapi_service: OpenAPIService, 
                  time_effort: int):
         self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
         self._instruction = instruction
         self._media_assets = media_assets
-        self._transcription_texts = transcription_texts
+        self._texts = texts
         self._validation_set_id = None
         self._referee = NaiveReferee()
         self._settings = Settings()
         self._filters: list[Filter] = []
         self._time_effort = time_effort
 
-    def responses(self, responses_required: int) -> 'TranscriptionOrderBuilder':
-        """Set the number of responses required per datapoint for the transcription order. Will default to 10."""
+    def responses(self, responses_required: int) -> 'SelectWordsOrderBuilder':
+        """Set the number of responses required per datapoint for the order. Will default to 10."""
         self._referee = NaiveReferee(responses=responses_required)
         return self
 
-    def validation_set(self, validation_set_id: str) -> 'TranscriptionOrderBuilder':
-        """Set the validation set for the transcription order."""
+    def validation_set(self, validation_set_id: str) -> 'SelectWordsOrderBuilder':
+        """Set the validation set for the order."""
         self._validation_set_id = validation_set_id
         return self
     
-    def countries(self, country_codes: list[str]) -> 'TranscriptionOrderBuilder':
+    def countries(self, country_codes: list[str]) -> 'SelectWordsOrderBuilder':
         """Set the countries where order will be shown as country codes."""
         self._filters.append(CountryFilter(country_codes))
         return self
     
-    def languages(self, language_codes: list[str]) -> 'TranscriptionOrderBuilder':
+    def languages(self, language_codes: list[str]) -> 'SelectWordsOrderBuilder':
         """Set the languages where order will be shown as language codes."""
         self._filters.append(LanguageFilter(language_codes))
         return self
     
-    def wait_for_video_to_finish(self, offset: int = 0) -> 'TranscriptionOrderBuilder':
+    def wait_for_video_to_finish(self, offset: int = 0) -> 'SelectWordsOrderBuilder':
         """Allows labeler to only answer once the video has finished playing.
         The offset gets added on top. Can be negative to allow answers before the video ends."""
         self._settings.play_video_until_the_end(offset)
         return self
     
-    def translation(self, disable: bool = False, show_both: bool = False) -> 'TranscriptionOrderBuilder':
+    def translation(self, disable: bool = False, show_both: bool = False) -> 'SelectWordsOrderBuilder':
         """Disable the translation of the order.
         Only the instruction will be translated.
         
@@ -82,17 +82,24 @@ class TranscriptionOrderBuilder:
             self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
 
         return self
-
+    
     def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
-        """Run the transcription order.
+        """Run the order.
         
         Args:
             submit (bool): Whether to submit the order. Defaults to True. \
                 Set this to False if you first want to see the order on your dashboard before running it.
-            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
-            
-        Returns:
-            RapidataOrder: The created transcription order."""
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False."""
+        
+        return self.submit(submit=submit, disable_link=disable_link)
+
+    def submit(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
+        """Submit the order to be labeled.
+        
+        Args:
+            submit (bool): Whether to submit the order. Defaults to True. \
+                Set this to False if you first want to see the order on your dashboard before running it.
+            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False."""
         
         if (self._validation_set_id and MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1 < 1) or (MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort < 1):
             raise ValueError(f"The Labelers only have {MAX_TIME_IN_SECONDS_FOR_ONE_SESSION} seconds to do the task. \
@@ -106,12 +113,12 @@ class TranscriptionOrderBuilder:
 
         order = (self._order_builder
             .workflow(
-                TranscriptionWorkflow(
+                SelectWordsWorkflow(
                     instruction=self._instruction
                 )
             )
             .referee(self._referee)
-            .media(self._media_assets, metadata=self._transcription_texts)
+            .media(self._media_assets, metadata=self._texts)
             .selections(selection)
             .settings(self._settings)
             .filters(self._filters)
@@ -120,36 +127,31 @@ class TranscriptionOrderBuilder:
         return order 
 
 
-class TranscriptionMediaBuilder:
+class SelectWordsMediaBuilder:
     def __init__(self, name: str, instruction: str, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         self._name = name
         self._instruction = instruction
         self._media_assets: list[BaseAsset] = []
-        self._transcription_texts: list[TranscriptionMetadata] = []
-        self._time_effort = 20
+        self._texts: list[SelectWordsMetadata] = []
+        self._time_effort = 10
 
-    def media(self, media_paths: list[str], transcription_texts: list[str], time_effort: int = 20) -> TranscriptionOrderBuilder:
-        """Set the media assets for the transcription order by providing the local paths to the audio / video files.
+    def media(self, media_paths: list[str], texts: list[str], time_effort: int = 10) -> SelectWordsOrderBuilder:
+        """Set the media assets for the order by providing the local paths to the audio / video files.
 
         Args:
             media_paths (list[str]): A local file path.
-            time_effort (int): Estimated time in seconds to solve one transcription task for the first time. Defaults to 20.
-            
-        Returns:
-            TranscriptionOrderBuilder: The transcription order builder instance.
-        
-        Raises:
-            ValueError: If the media paths are not a list of strings."""
+            texts (list[str]): The text will be split up by spaces and the labeler will be able to select the words.
+            time_effort (int): Estimated time in seconds to solve one task for the first time. Defaults to 10."""
         
         if not isinstance(media_paths, list) or not all(isinstance(path, str) for path in media_paths):
             raise ValueError("Media paths must be a list of strings, the strings being file paths.")
         
-        if not isinstance(transcription_texts, list) or not all(isinstance(text, str) for text in transcription_texts):
-            raise ValueError("Transcription texts must be a list of strings.")
+        if not isinstance(texts, list) or not all(isinstance(text, str) for text in texts):
+            raise ValueError("texts must be a list of strings.")
         
-        if not len(media_paths) == len(transcription_texts):
-            raise ValueError("The number of media paths and transcription texts must be the same.")
+        if not len(media_paths) == len(texts):
+            raise ValueError("The number of media paths and texts must be the same.")
 
         invalid_paths: list[str] = []
         for path in media_paths:
@@ -161,34 +163,34 @@ class TranscriptionMediaBuilder:
         if invalid_paths:
             raise FileNotFoundError(f"Could not find the following files: {invalid_paths}")
         
-        self._transcription_texts = [TranscriptionMetadata(text) for text in transcription_texts]
+        self._texts = [SelectWordsMetadata(text) for text in texts]
 
         self._time_effort = time_effort
         return self._build()
 
-    def _build(self) -> TranscriptionOrderBuilder:
+    def _build(self) -> SelectWordsOrderBuilder:
         if not self._media_assets:
             raise ValueError("Please provide either a text or an media to be shown with the question")
-        return TranscriptionOrderBuilder(self._name, 
+        return SelectWordsOrderBuilder(self._name, 
                                          self._instruction, 
                                          self._media_assets, 
-                                         self._transcription_texts, 
+                                         self._texts, 
                                          openapi_service=self._openapi_service, 
                                          time_effort=self._time_effort)
 
 
-class TranscriptionInstructionBuilder:
+class SelectWordsInstructionBuilder:
     def __init__(self, name: str, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         self._name = name
         self._instruction = None
 
-    def instruction(self, instruction: str) -> TranscriptionMediaBuilder:
-        """Set the instruction for the transcription order."""
+    def instruction(self, instruction: str) -> SelectWordsMediaBuilder:
+        """Set the instruction for the order."""
         self._instruction = instruction
         return self._build()
 
-    def _build(self) -> TranscriptionMediaBuilder:
+    def _build(self) -> SelectWordsMediaBuilder:
         if self._instruction is None:
             raise ValueError("Instruction is required")
-        return TranscriptionMediaBuilder(self._name, self._instruction, self._openapi_service)
+        return SelectWordsMediaBuilder(self._name, self._instruction, self._openapi_service)

rapidata/rapidata_client/workflow/__init__.py

@@ -2,5 +2,5 @@ from .base_workflow import Workflow
 from .classify_workflow import ClassifyWorkflow
 from .compare_workflow import CompareWorkflow
 from .free_text_workflow import FreeTextWorkflow
-from .transcription_workflow import TranscriptionWorkflow
+from .select_words_workflow import SelectWordsWorkflow
 from .evaluation_workflow import EvaluationWorkflow

rapidata/rapidata_client/workflow/{transcription_workflow.py → select_words_workflow.py}

@@ -4,26 +4,26 @@ from rapidata.api_client.models.transcription_rapid_blueprint import Transcripti
 from rapidata.rapidata_client.workflow.base_workflow import Workflow
 
 
-class TranscriptionWorkflow(Workflow):
+class SelectWordsWorkflow(Workflow):
     """
-    A workflow for transcription tasks.
+    A workflow for select words tasks.
 
-    This class represents a transcription workflow where audio or video content
+    This class represents a select words workflow where audio or video content
     is transcribed based on given instructions.
 
     Attributes:
-        _instruction (str): The instruction for the transcription task.
+        _instruction (str): The instruction for the select words task.
 
     Args:
-        instruction (str): The instruction to be provided for the transcription task.
+        instruction (str): The instruction to be provided for the select words task.
     """
 
     def __init__(self, instruction: str):
         """
-        Initialize a TranscriptionWorkflow instance.
+        Initialize a SelectWordsWorkflow instance.
 
         Args:
-            instruction (str): The instruction to be provided for the transcription task.
+            instruction (str): The instruction to be provided for the select words task.
         """
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction

{rapidata-1.8.3.dist-info → rapidata-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapidata
-Version: 1.8.3
+Version: 1.10.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