rapidata 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

rapidata/api_client_README.md

@@ -75,6 +75,9 @@ Class | Method | HTTP request | Description
 *CampaignApi* | [**campaign_pause_post**](rapidata/api_client/docs/CampaignApi.md#campaign_pause_post) | **POST** /Campaign/Pause | Pauses a campaign.
 *CampaignApi* | [**campaign_query_get**](rapidata/api_client/docs/CampaignApi.md#campaign_query_get) | **GET** /Campaign/Query | Queries orders based on a filter, page, and sort criteria.
 *CampaignApi* | [**campaign_resume_post**](rapidata/api_client/docs/CampaignApi.md#campaign_resume_post) | **POST** /Campaign/Resume | Resumes a campaign.
+*ClientApi* | [**client_client_id_delete**](rapidata/api_client/docs/ClientApi.md#client_client_id_delete) | **DELETE** /Client/{clientId} | Deletes a customers client.
+*ClientApi* | [**client_post**](rapidata/api_client/docs/ClientApi.md#client_post) | **POST** /Client | Creates a new client for the current customer.
+*ClientApi* | [**client_query_get**](rapidata/api_client/docs/ClientApi.md#client_query_get) | **GET** /Client/Query | Gets the clients for the current customer.
 *CocoApi* | [**coco_submit_post**](rapidata/api_client/docs/CocoApi.md#coco_submit_post) | **POST** /Coco/Submit | Creates a new validation set based on a previously uploaded CoCo set.
 *CocoApi* | [**coco_upload_post**](rapidata/api_client/docs/CocoApi.md#coco_upload_post) | **POST** /Coco/Upload | Uploads a CoCo set to the system.
 *CompareWorkflowApi* | [**compare_workflow_get_result_overview_get**](rapidata/api_client/docs/CompareWorkflowApi.md#compare_workflow_get_result_overview_get) | **GET** /CompareWorkflow/GetResultOverview | Get the result overview for a compare workflow.
@@ -89,7 +92,8 @@ Class | Method | HTTP request | Description
 *DatasetApi* | [**dataset_upload_datapoint_post**](rapidata/api_client/docs/DatasetApi.md#dataset_upload_datapoint_post) | **POST** /Dataset/UploadDatapoint | Creates a new multi asset datapoint.
 *DatasetApi* | [**dataset_upload_files_from_s3_post**](rapidata/api_client/docs/DatasetApi.md#dataset_upload_files_from_s3_post) | **POST** /Dataset/UploadFilesFromS3 | Uploads files from an S3 bucket to a dataset.
 *DatasetApi* | [**dataset_upload_images_to_dataset_post**](rapidata/api_client/docs/DatasetApi.md#dataset_upload_images_to_dataset_post) | **POST** /Dataset/UploadImagesToDataset | Uploads images to a dataset.
-*IdentityApi* | [**identity_create_client_post**](rapidata/api_client/docs/IdentityApi.md#identity_create_client_post) | **POST** /Identity/CreateClient | Creates a new client for the current customer.
+*IdentityApi* | [**identity_create_bridge_token_post**](rapidata/api_client/docs/IdentityApi.md#identity_create_bridge_token_post) | **POST** /Identity/CreateBridgeToken | Creates a pair of read and write keys for a client.  The write key is used to store the authentication result.  The read key is used to retrieve the authentication result.
+*IdentityApi* | [**identity_read_bridge_token_get**](rapidata/api_client/docs/IdentityApi.md#identity_read_bridge_token_get) | **GET** /Identity/ReadBridgeToken | Tries to read the bridge token keys for a given read key.  The read key is used to retrieve the authentication result written by the write key.
 *IdentityApi* | [**identity_register_temporary_post**](rapidata/api_client/docs/IdentityApi.md#identity_register_temporary_post) | **POST** /Identity/RegisterTemporary | Registers and logs in a temporary customer.
 *NewsletterApi* | [**newsletter_post**](rapidata/api_client/docs/NewsletterApi.md#newsletter_post) | **POST** /Newsletter | Signs a user up to the newsletter.
 *NewsletterApi* | [**newsletter_unsubscribe_post**](rapidata/api_client/docs/NewsletterApi.md#newsletter_unsubscribe_post) | **POST** /Newsletter/Unsubscribe | Unsubscribes a user from the newsletter.
@@ -171,6 +175,8 @@ Class | Method | HTTP request | Description
  - [ClassificationMetadataFilterConfig](rapidata/api_client/docs/ClassificationMetadataFilterConfig.md)
  - [ClassificationMetadataModel](rapidata/api_client/docs/ClassificationMetadataModel.md)
  - [ClassifyPayload](rapidata/api_client/docs/ClassifyPayload.md)
+ - [ClientsQueryResult](rapidata/api_client/docs/ClientsQueryResult.md)
+ - [ClientsQueryResultPagedResult](rapidata/api_client/docs/ClientsQueryResultPagedResult.md)
  - [CloneDatasetModel](rapidata/api_client/docs/CloneDatasetModel.md)
  - [CloneOrderModel](rapidata/api_client/docs/CloneOrderModel.md)
  - [CloneOrderResult](rapidata/api_client/docs/CloneOrderResult.md)
@@ -192,6 +198,7 @@ Class | Method | HTTP request | Description
  - [CountMetadata](rapidata/api_client/docs/CountMetadata.md)
  - [CountMetadataModel](rapidata/api_client/docs/CountMetadataModel.md)
  - [CountryUserFilterModel](rapidata/api_client/docs/CountryUserFilterModel.md)
+ - [CreateBridgeTokenResult](rapidata/api_client/docs/CreateBridgeTokenResult.md)
  - [CreateClientModel](rapidata/api_client/docs/CreateClientModel.md)
  - [CreateClientResult](rapidata/api_client/docs/CreateClientResult.md)
  - [CreateComplexOrderModel](rapidata/api_client/docs/CreateComplexOrderModel.md)
@@ -316,6 +323,7 @@ Class | Method | HTTP request | Description
  - [PolygonTruth](rapidata/api_client/docs/PolygonTruth.md)
  - [PrivateTextMetadataInput](rapidata/api_client/docs/PrivateTextMetadataInput.md)
  - [ProbabilisticAttachCategoryRefereeConfig](rapidata/api_client/docs/ProbabilisticAttachCategoryRefereeConfig.md)
+ - [ProblemDetails](rapidata/api_client/docs/ProblemDetails.md)
  - [PromptMetadata](rapidata/api_client/docs/PromptMetadata.md)
  - [PromptMetadataInput](rapidata/api_client/docs/PromptMetadataInput.md)
  - [PromptMetadataModel](rapidata/api_client/docs/PromptMetadataModel.md)
@@ -323,7 +331,6 @@ Class | Method | HTTP request | Description
  - [PublicTextMetadataInput](rapidata/api_client/docs/PublicTextMetadataInput.md)
  - [QueryCampaignsModel](rapidata/api_client/docs/QueryCampaignsModel.md)
  - [QueryModel](rapidata/api_client/docs/QueryModel.md)
- - [QueryOrdersModel](rapidata/api_client/docs/QueryOrdersModel.md)
  - [QueryValidationRapidsResult](rapidata/api_client/docs/QueryValidationRapidsResult.md)
  - [QueryValidationRapidsResultAsset](rapidata/api_client/docs/QueryValidationRapidsResultAsset.md)
  - [QueryValidationRapidsResultPagedResult](rapidata/api_client/docs/QueryValidationRapidsResultPagedResult.md)
@@ -335,6 +342,7 @@ Class | Method | HTTP request | Description
  - [RapidResultModel](rapidata/api_client/docs/RapidResultModel.md)
  - [RapidResultModelResult](rapidata/api_client/docs/RapidResultModelResult.md)
  - [RapidSkippedModel](rapidata/api_client/docs/RapidSkippedModel.md)
+ - [ReadBridgeTokenKeysResult](rapidata/api_client/docs/ReadBridgeTokenKeysResult.md)
  - [RegisterTemporaryCustomerModel](rapidata/api_client/docs/RegisterTemporaryCustomerModel.md)
  - [RootFilter](rapidata/api_client/docs/RootFilter.md)
  - [SendCompletionMailStepModel](rapidata/api_client/docs/SendCompletionMailStepModel.md)

rapidata/rapidata_client/assets/__init__.py

@@ -2,7 +2,7 @@
 
 This package provides classes for different types of assets, including MediaAsset, TextAsset, and MultiAsset.
 """
-
+from .base_asset import BaseAsset
 from .media_asset import MediaAsset
 from .text_asset import TextAsset
 from .multi_asset import MultiAsset

rapidata/rapidata_client/assets/media_asset.py

@@ -31,14 +31,36 @@ class MediaAsset(BaseAsset):
         Raises:
             FileNotFoundError: If the provided file path does not exist.
         """
+        if not isinstance(path, str):
+            raise ValueError("Media must be a string, either a local file path or an image URL")
+
         if re.match(r'^https?://', path):
             self.path = MediaAsset.get_image_bytes(path)
+            self.name = path.split('/')[-1]
+            if not self.name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
+                self.name += '.jpg'
             return
         
         if not os.path.exists(path):
             raise FileNotFoundError(f"File not found: {path}, please provide a valid local file path.")
         
         self.path: str | bytes = path
+        self.name = path
+    
+    def set_custom_name(self, name: str) -> 'MediaAsset':
+        """
+        Set a custom name for the media asset, will only work with links.
+
+        Args:
+            name (str): The custom name to be set.
+        """
+        if isinstance(self.path, bytes):
+            if not name.endswith(('.jpg', '.jpeg', '.png', '.gif')):
+                name += '.jpg'
+            self.name = name
+        else:
+            raise ValueError("Custom name can only be set for links.")
+        return self
 
     @staticmethod
     def get_image_bytes(image_url: str) -> bytes:

rapidata/rapidata_client/assets/text_asset.py

@@ -22,4 +22,7 @@ class TextAsset(BaseAsset):
         Args:
             text (str): The textual content of the asset.
         """
+        if not isinstance(text, str):
+            raise ValueError("Text must be a string")
+        
         self.text = text

rapidata/rapidata_client/country_codes/country_codes.py

@@ -16,4 +16,4 @@ class CountryCodes:
         "GB",
         "US",
     ]
-    GERMAN_SPEAKING = (["AT", "DE"],)
+    GERMAN_SPEAKING = ["AT", "DE"]

rapidata/rapidata_client/dataset/rapid_builders/__init__.py

@@ -0,0 +1,4 @@
+from .classify_rapid_builders import ClassifyRapidQuestionBuilder
+from .compare_rapid_builders import CompareRapidCriteriaBuilder
+from .transcription_rapid_builders import TranscriptionRapidInstructionBuilder
+from .base_rapid_builder import BaseRapidBuilder

rapidata/rapidata_client/dataset/rapid_builders/base_rapid_builder.py

@@ -0,0 +1,33 @@
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.dataset.rapid_builders import ClassifyRapidQuestionBuilder, CompareRapidCriteriaBuilder, TranscriptionRapidInstructionBuilder
+
+class BaseRapidBuilder:
+    """Base class for creating different types of rapids.
+    
+    This class provides factory methods to create specific rapids
+    """
+
+    def classify_rapid(self):
+        """Creates a classification rapid.
+        
+        Returns:
+            ClassifyRapidQuestionBuilder: A builder for creating the classification question.
+        """
+        return ClassifyRapidQuestionBuilder()
+    
+    def compare_rapid(self):    
+        """Creates a compare rapid.
+        
+        Returns:
+            CompareRapidCriteriaBuilder: A builder for creating a comparison criteria.
+        """
+        return CompareRapidCriteriaBuilder()
+    
+    def transcription_rapid(self):
+        """Creates a transcription rapid.
+        
+        Returns:
+            TranscriptionRapidInstructionBuilder: A builder for creating the transcription instruction.
+        """
+        return TranscriptionRapidInstructionBuilder()
+        

rapidata/rapidata_client/dataset/rapid_builders/classify_rapid_builders.py

@@ -0,0 +1,166 @@
+from rapidata.rapidata_client.assets import MediaAsset, TextAsset
+from rapidata.rapidata_client.metadata import PromptMetadata
+from rapidata.rapidata_client.dataset.rapid_builders.rapids import ClassificationRapid
+
+class ClassifyRapidBuilder:
+    """Final builder class for classification rapid.
+    
+    This class handles the final construction of a classification rapid with all required parameters.
+    """
+    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset):
+        self._question = question
+        self._options = options
+        self._truths = truths
+        self._asset = asset
+        self._metadata = []
+
+    def prompt(self, prompt: str):
+        """Add a prompt to provide additional context for the classification task.
+        
+        Args:
+            prompt (str): Additional instructions or context
+            
+        Returns:
+            ClassifyRapidBuilder: The builder instance for method chaining
+        """
+        self._metadata.append(PromptMetadata(prompt))
+        return self
+    
+    def build(self):
+        """Constructs and returns the final classification rapid.
+        
+        Returns:
+            ClassificationRapid: The constructed classification rapid 
+        """
+        return ClassificationRapid(
+            question=self._question,
+            options=self._options,
+            truths=self._truths,
+            asset=self._asset,
+            metadata=self._metadata
+        )
+    
+class ClassifyRapidTruthBuilder:
+    """Builder class for the truths of the classification rapid.
+
+    This adds the truths to the classification rapid.
+    """
+    def __init__(self, question: str, options: list[str], asset: MediaAsset | TextAsset):
+        self._question = question
+        self._options = options
+        self._asset = asset
+        self._truths = None
+
+    def truths(self, truths: list[str]):
+        """Set the truths for the classification rapid.
+
+        Args:
+            truths (list[str]): The correct answers for the classification task"""
+        
+        if not isinstance(truths, list) or not all(isinstance(truth, str) for truth in truths):
+            raise ValueError("Truths must be a list of strings")
+        
+        if not all(truth in self._options for truth in truths):
+            raise ValueError("Truths must be one of the selectable options")
+        
+        self._truths = truths
+        return self._build()
+    
+    def _build(self):
+        if self._truths is None:
+            raise ValueError("Truths are required")
+        return ClassifyRapidBuilder(
+            question=self._question,
+            options=self._options,
+            asset=self._asset,
+            truths=self._truths,
+        )
+    
+class ClassifyRapidMediaBuilder:
+    """Builder class for the media asset of the classification rapid.
+
+    This class adds the media asset to the classification rapid.
+    """
+    def __init__(self, question: str, options: list[str]):
+        self._question = question
+        self._options = options
+        self._asset: MediaAsset | TextAsset | None = None
+
+    def media(self, media: str):
+        """Set the media asset for the classification rapid.
+
+        Args:
+            media (str): A local file path or an image URL. The image will be displayed with the classification task"""        
+        self._asset = MediaAsset(media)
+
+        return self._build()
+
+    def text(self, text: str):
+        """Set the text asset for the classification rapid.
+
+        Args:
+            text (str): The text to be displayed with the classification task"""
+        self._asset = TextAsset(text)
+
+        return self._build()
+
+    def _build(self):
+        if self._asset is None:
+            raise ValueError("Assets are required")
+        
+        return ClassifyRapidTruthBuilder(
+            question=self._question,
+            options=self._options,
+            asset=self._asset,
+        )
+
+class ClassifyRapidOptionsBuilder:
+    def __init__(self, question: str):
+        self._question = question
+        self._options = None
+
+    def options(self, options: list[str]):
+        """Set the options for the classification rapid.
+
+        Args:
+            options (list[str]): The selectable options for the classification task"""
+
+        if not isinstance(options, list) or not all(isinstance(option, str) for option in options):
+            raise ValueError("Options must be a list of strings")
+        
+        self._options = options
+        return self._build()
+    
+    def _build(self):
+        if self._options is None:
+            raise ValueError("Options are required")
+        
+        return ClassifyRapidMediaBuilder(
+            question=self._question,
+            options=self._options,
+        )
+
+
+class ClassifyRapidQuestionBuilder:
+    def __init__(self):
+        self._question = None
+
+    def question(self, question: str):
+        """Set the question for the classification rapid.
+
+        Args:
+            question (str): The question to be answered by the classification task"""
+        
+        if not isinstance(question, str):
+            raise ValueError("Question must be a string")
+        
+        self._question = question
+        return self._build()
+    
+    def _build(self):
+        if self._question is None:
+            raise ValueError("Question is required")
+        
+        return ClassifyRapidOptionsBuilder(
+            question=self._question,
+        )

rapidata/rapidata_client/dataset/rapid_builders/compare_rapid_builders.py

@@ -0,0 +1,145 @@
+from rapidata.rapidata_client.assets import MultiAsset, TextAsset, MediaAsset
+from rapidata.rapidata_client.metadata import PromptMetadata
+from rapidata.rapidata_client.dataset.rapid_builders.rapids import CompareRapid
+import re
+
+class CompareRapidBuilder:
+    """Final builder class for comparison rapid.
+    
+    This class handles the final construction of a comparison rapid with all required parameters.
+    """
+    def __init__(self, criteria: str, truth: str, asset: MultiAsset):
+        """Initialize the comparison rapid builder.
+        
+        Args:
+            criteria (str): The criteria for comparison
+            truth (str): The correct answer
+            asset (MultiAsset): Collection of assets to be compared
+        """
+        self._criteria = criteria
+        self._truth = truth
+        self._asset = asset
+        self._metadata = []
+
+    def prompt(self, prompt: str):
+        """Add a prompt to provide additional context for the comparison.
+        
+        Args:
+            prompt (str): Additional instructions or context
+            
+        Returns:
+            CompareRapidBuilder: The builder instance for method chaining
+        """
+        self._metadata.append(PromptMetadata(prompt))
+        return self
+
+    def build(self):
+        """Constructs and returns the final comparison rapid.
+        
+        Returns:
+            CompareRapid: The constructed comparison rapid
+        """
+        return CompareRapid(
+            criteria=self._criteria,
+            asset=self._asset,
+            truth=self._truth,
+            metadata=self._metadata
+        )
+
+class CompareRapidTruthBuilder:
+    """Builder class for the truth of the comparison rapid.
+
+    This adds the truth to the comparison rapid.    
+    """
+    def __init__(self, criteria: str, asset: MultiAsset):
+        self._criteria = criteria
+        self._asset = asset
+        self._truth = None
+    
+    def truth(self, truth: str):
+        """Set the truth for the comparison rapid.
+
+        Args:
+            truth (str): The correct answer for the comparison task. Is the string of the correct media/text asset"""
+        
+        if not isinstance(truth, str):
+            raise ValueError("Truth must be a string.")
+        
+        self._truth = MediaAsset(truth).name
+        
+        return self._build()
+    
+    def _build(self):
+        if self._truth is None:
+            raise ValueError("Truth is required")
+        
+        return CompareRapidBuilder(
+            criteria=self._criteria,
+            asset=self._asset,
+            truth=self._truth,
+        )
+
+class CompareRapidAssetBuilder:
+    """Builder class for the asset of the comparison rapid.
+
+    This adds the asset to the comparison rapid.
+    """
+    def __init__(self, criteria: str):
+        self._criteria = criteria
+        self._asset: MultiAsset | None = None
+
+    def media(self, medias: list[str]):
+        """Set the media assets for the comparison rapid.
+
+        Args:
+            medias (list[str]): The local file paths or links of the media assets to be compared"""
+        
+        media_assets = [MediaAsset(media) for media in medias]
+        self._asset = MultiAsset(media_assets)
+        return self._build()
+    
+    def text(self, texts: list[str]):
+        """Set the text assets for the comparison rapid.
+
+        Args:
+            texts (list[str]): The texts to be compared"""
+        
+        text_assets = [TextAsset(text) for text in texts]
+        self._asset = MultiAsset(text_assets)
+        return self._build()
+    
+    def _build(self):
+        if self._asset is None:
+            raise ValueError("Asset is required")
+
+        return CompareRapidTruthBuilder(
+            criteria=self._criteria,
+            asset=self._asset,
+        )
+
+class CompareRapidCriteriaBuilder:
+    """Builder class for the criteria of the comparison rapid.
+
+    This adds the criteria to the comparison rapid."""
+    def __init__(self):
+        self._criteria = None
+
+    def criteria(self, criteria: str):
+        """Set the criteria for the comparison rapid.
+
+        Args:
+            criteria (str): The criteria for comparison"""
+        
+        if not isinstance(criteria, str):
+            raise ValueError("Criteria must be a string")
+        
+        self._criteria = criteria
+        return self._build()
+
+    def _build(self):
+        if self._criteria is None:
+            raise ValueError("Criteria is required")
+
+        return CompareRapidAssetBuilder(
+            criteria=self._criteria,
+        )

rapidata/rapidata_client/dataset/rapid_builders/rapids.py

@@ -0,0 +1,32 @@
+from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
+from rapidata.rapidata_client.metadata import Metadata
+
+class Rapid:
+    pass
+
+class ClassificationRapid(Rapid):
+    """A classification rapid. This represents the question, options, truths, asset and metadata that will be given to the user."""
+    def __init__(self, question: str, options: list[str], truths: list[str], asset: MediaAsset | TextAsset, metadata: list[Metadata]):
+        self.question = question
+        self.options = options
+        self.truths = truths
+        self.asset = asset
+        self.metadata = metadata
+
+class CompareRapid(Rapid):
+    """A comparison rapid. This represents the criteria, asset, truth and metadata that will be given to the user."""
+    def __init__(self, criteria: str, truth: str, asset: MultiAsset, metadata: list[Metadata]):
+        self.criteria = criteria
+        self.asset = asset
+        self.truth = truth
+        self.metadata = metadata
+
+class TranscriptionRapid(Rapid):
+    """A transcription rapid. This represents the instruction, truths, asset, transcription and strict grading that will be given to the user."""
+    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, transcription: str, strict_grading: bool):
+        self.instruction = instruction
+        self.truths = truths
+        self.asset = asset
+        self.transcription = transcription
+        self.strict_grading = strict_grading
+

rapidata/rapidata_client/dataset/rapid_builders/transcription_rapid_builders.py

@@ -0,0 +1,132 @@
+from rapidata.rapidata_client.assets import MediaAsset
+from rapidata.rapidata_client.dataset.rapid_builders.rapids import TranscriptionRapid
+
+class TranscriptionRapidBuilder:
+    """Final builder class for transcription rapid.
+    
+    This class handles the final construction of a transcription rapid with all required parameters.
+    """
+    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, transcription_text: str):
+        self._instruction = instruction
+        self._truths = truths
+        self._asset = asset
+        self._transcription_text = transcription_text
+        self._strict_grading = True
+
+    def strict_grading(self, strict_grading: bool = True):
+        """Set whether to use strict grading for the transcription.
+        Strict grading true: In order to be correct, you must select all of the right words
+        Strict grading false: In order to be correct, you must select at least one right word
+        In both cases it will be incorrect if you select any wrong words
+        
+        Args:
+            strict_grading (bool): Whether to use strict grading. Defaults to True.
+            
+        Returns:
+            TranscriptionRapidBuilder: The builder instance for method chaining
+        """
+        self._strict_grading = strict_grading
+        return self
+
+    def build(self):
+        """Constructs and returns the final transcription rapid.
+        
+        Returns:
+            TranscriptionRapid: The constructed transcription rapid
+        """
+        return TranscriptionRapid(
+            instruction=self._instruction,
+            truths=self._truths,
+            asset=self._asset,
+            transcription=self._transcription_text,
+            strict_grading=self._strict_grading
+        )
+
+class TranscriptionRapidTruthsBuilder:
+    """Builder class for the truths of the transcription rapid.
+
+    This adds the truths to the transcription rapid.
+    """
+    def __init__(self, instruction: str, media: MediaAsset, transcription_text: str):
+        self._instruction = instruction
+        self._media = media
+        self._transcription_text = transcription_text
+        self._truths = None
+
+    def truths(self, truths: list[int]):
+        """Set the truths for the transcription rapid.
+
+        Args:
+            truths (list[int]): The correct answers for the transcription task. \
+                Each integer represents the index of the correct word in the transcription text."""
+        
+        if not isinstance(truths, list) or not all(isinstance(truth, int) for truth in truths):
+            raise ValueError("Truths must be a list of integers")
+        
+        self._truths = truths
+        return self._build()
+    
+    def _build(self):
+        if self._truths is None:
+            raise ValueError("Truths are required")
+        
+        return TranscriptionRapidBuilder(
+            instruction=self._instruction,
+            truths=self._truths,
+            asset=self._media,
+            transcription_text=self._transcription_text
+        )
+
+class TranscriptionRapidAssetBuilder:
+    """Builder class for the asset of the transcription rapid.
+
+    This adds the asset to the transcription rapid.
+    """
+    def __init__(self, instruction: str):
+        self._instruction = instruction
+
+    def media(self, media: str, transcription_text: str):
+        """Set the media asset for the transcription rapid.
+
+        Args:
+            media (str): The local file path of the audio or video file to be transcribed 
+            transcription_text (str): The text to be transcribed from the media asset""" # is video file okay?
+        
+        self._asset = MediaAsset(media)
+        self._transcription_text = transcription_text
+
+        return self._build()
+
+    def _build(self):
+        if not self._asset:
+            raise ValueError("Media is required")
+        
+        return TranscriptionRapidTruthsBuilder(
+            instruction=self._instruction,
+            media=self._asset,
+            transcription_text=self._transcription_text
+        )
+
+class TranscriptionRapidInstructionBuilder:
+    def __init__(self):
+        self._instruction = None
+
+    def instruction(self, instruction: str):
+        """Set the instruction for the transcription rapid.
+
+        Args:
+            instruction (str): The instruction for the transcription task"""
+        
+        if not isinstance(instruction, str):
+            raise ValueError("Instruction must be a string")
+        
+        self._instruction = instruction
+        return self._build()
+    
+    def _build(self):
+        if self._instruction is None:
+            raise ValueError("Instruction is required")
+        
+        return TranscriptionRapidAssetBuilder(
+            instruction=self._instruction,
+        )