rapidata 2.41.2__py3-none-any.whl → 2.42.0__py3-none-any.whl

rapidata/rapidata_client/benchmark/rapidata_benchmark.py

@@ -16,10 +16,10 @@ from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.page_info import PageInfo
 from rapidata.api_client.models.source_url_metadata_model import SourceUrlMetadataModel
 from rapidata.api_client.models.submit_prompt_model import SubmitPromptModel
-from rapidata.api_client.models.submit_prompt_model_prompt_asset import (
-    SubmitPromptModelPromptAsset,
+from rapidata.api_client.models.create_demographic_rapid_model_asset import (
+    CreateDemographicRapidModelAsset,
 )
-from rapidata.api_client.models.url_asset_input import UrlAssetInput
+from rapidata.api_client.models.existing_asset_input import ExistingAssetInput
 
 from rapidata.rapidata_client.benchmark._detail_mapper import DetailMapper
 from rapidata.rapidata_client.benchmark.leaderboard.rapidata_leaderboard import (
@@ -28,7 +28,7 @@ from rapidata.rapidata_client.benchmark.leaderboard.rapidata_leaderboard import
 from rapidata.rapidata_client.benchmark.participant._participant import (
     BenchmarkParticipant,
 )
-from rapidata.rapidata_client.datapoints.assets import MediaAsset
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
 from rapidata.rapidata_client.filter import RapidataFilter
 from rapidata.rapidata_client.config import logger, managed_print, tracer
 from rapidata.rapidata_client.settings import RapidataSetting
@@ -50,96 +50,92 @@ class RapidataBenchmark:
     def __init__(self, name: str, id: str, openapi_service: OpenAPIService):
         self.name = name
         self.id = id
-        self.__openapi_service = openapi_service
+        self._openapi_service = openapi_service
         self.__prompts: list[str | None] = []
         self.__prompt_assets: list[str | None] = []
         self.__leaderboards: list[RapidataLeaderboard] = []
         self.__identifiers: list[str] = []
         self.__tags: list[list[str]] = []
         self.__benchmark_page: str = (
-            f"https://app.{self.__openapi_service.environment}/mri/benchmarks/{self.id}"
+            f"https://app.{self._openapi_service.environment}/mri/benchmarks/{self.id}"
         )
+        self._asset_uploader = AssetUploader(openapi_service)
 
     def __instantiate_prompts(self) -> None:
-        current_page = 1
-        total_pages = None
+        with tracer.start_as_current_span("RapidataBenchmark.__instantiate_prompts"):
+            current_page = 1
+            total_pages = None
 
-        while True:
-            prompts_result = (
-                self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompts_get(
+            while True:
+                prompts_result = self._openapi_service.benchmark_api.benchmark_benchmark_id_prompts_get(
                     benchmark_id=self.id,
                     request=QueryModel(page=PageInfo(index=current_page, size=100)),
                 )
-            )
 
-            if prompts_result.total_pages is None:
-                raise ValueError(
-                    "An error occurred while fetching prompts: total_pages is None"
-                )
+                if prompts_result.total_pages is None:
+                    raise ValueError(
+                        "An error occurred while fetching prompts: total_pages is None"
+                    )
 
-            total_pages = prompts_result.total_pages
+                total_pages = prompts_result.total_pages
 
-            for prompt in prompts_result.items:
-                self.__prompts.append(prompt.prompt)
-                self.__identifiers.append(prompt.identifier)
-                if prompt.prompt_asset is None:
-                    self.__prompt_assets.append(None)
-                else:
-                    assert isinstance(
-                        prompt.prompt_asset.actual_instance, FileAssetModel
-                    )
-                    source_url = prompt.prompt_asset.actual_instance.metadata[
-                        "sourceUrl"
-                    ].actual_instance
-                    assert isinstance(source_url, SourceUrlMetadataModel)
-                    self.__prompt_assets.append(source_url.url)
+                for prompt in prompts_result.items:
+                    self.__prompts.append(prompt.prompt)
+                    self.__identifiers.append(prompt.identifier)
+                    if prompt.prompt_asset is None:
+                        self.__prompt_assets.append(None)
+                    else:
+                        assert isinstance(
+                            prompt.prompt_asset.actual_instance, FileAssetModel
+                        )
+                        source_url = prompt.prompt_asset.actual_instance.metadata[
+                            "sourceUrl"
+                        ].actual_instance
+                        assert isinstance(source_url, SourceUrlMetadataModel)
+                        self.__prompt_assets.append(source_url.url)
 
-                self.__tags.append(prompt.tags)
-            if current_page >= total_pages:
-                break
+                    self.__tags.append(prompt.tags)
+                if current_page >= total_pages:
+                    break
 
-            current_page += 1
+                current_page += 1
 
     @property
     def identifiers(self) -> list[str]:
-        with tracer.start_as_current_span("RapidataBenchmark.identifiers"):
-            if not self.__identifiers:
-                self.__instantiate_prompts()
+        if not self.__identifiers:
+            self.__instantiate_prompts()
 
-            return self.__identifiers
+        return self.__identifiers
 
     @property
     def prompts(self) -> list[str | None]:
         """
         Returns the prompts that are registered for the leaderboard.
         """
-        with tracer.start_as_current_span("RapidataBenchmark.prompts"):
-            if not self.__prompts:
-                self.__instantiate_prompts()
+        if not self.__prompts:
+            self.__instantiate_prompts()
 
-            return self.__prompts
+        return self.__prompts
 
     @property
     def prompt_assets(self) -> list[str | None]:
         """
         Returns the prompt assets that are registered for the benchmark.
         """
-        with tracer.start_as_current_span("RapidataBenchmark.prompt_assets"):
-            if not self.__prompt_assets:
-                self.__instantiate_prompts()
+        if not self.__prompt_assets:
+            self.__instantiate_prompts()
 
-            return self.__prompt_assets
+        return self.__prompt_assets
 
     @property
     def tags(self) -> list[list[str]]:
         """
         Returns the tags that are registered for the benchmark.
         """
-        with tracer.start_as_current_span("RapidataBenchmark.tags"):
-            if not self.__tags:
-                self.__instantiate_prompts()
+        if not self.__tags:
+            self.__instantiate_prompts()
 
-            return self.__tags
+        return self.__tags
 
     @property
     def leaderboards(self) -> list[RapidataLeaderboard]:
@@ -152,7 +148,7 @@ class RapidataBenchmark:
                 total_pages = None
 
                 while True:
-                    leaderboards_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_leaderboards_get(
+                    leaderboards_result = self._openapi_service.benchmark_api.benchmark_benchmark_id_leaderboards_get(
                         benchmark_id=self.id,
                         request=QueryModel(
                             page=PageInfo(index=current_page, size=100),
@@ -178,7 +174,7 @@ class RapidataBenchmark:
                                 leaderboard.min_responses,
                                 self.id,
                                 leaderboard.id,
-                                self.__openapi_service,
+                                self._openapi_service,
                             )
                             for leaderboard in leaderboards_result.items
                         ]
@@ -239,9 +235,6 @@ class RapidataBenchmark:
             if identifier in self.identifiers:
                 raise ValueError("Identifier already exists in the benchmark.")
 
-            if prompt_asset is not None and not re.match(r"^https?://", prompt_asset):
-                raise ValueError("Prompt asset must be a link to the asset.")
-
             if tags is not None and (
                 not isinstance(tags, list)
                 or not all(isinstance(tag, str) for tag in tags)
@@ -263,14 +256,17 @@ class RapidataBenchmark:
             self.__prompts.append(prompt)
             self.__prompt_assets.append(prompt_asset)
 
-            self.__openapi_service.benchmark_api.benchmark_benchmark_id_prompt_post(
+            self._openapi_service.benchmark_api.benchmark_benchmark_id_prompt_post(
                 benchmark_id=self.id,
                 submit_prompt_model=SubmitPromptModel(
                     identifier=identifier,
                     prompt=prompt,
                     promptAsset=(
-                        SubmitPromptModelPromptAsset(
-                            UrlAssetInput(_t="UrlAssetInput", url=prompt_asset)
+                        CreateDemographicRapidModelAsset(
+                            actual_instance=ExistingAssetInput(
+                                _t="ExistingAssetInput",
+                                name=self._asset_uploader.upload_asset(prompt_asset),
+                            )
                         )
                         if prompt_asset is not None
                         else None
@@ -328,32 +324,30 @@ class RapidataBenchmark:
                 settings,
             )
 
-            leaderboard_result = (
-                self.__openapi_service.leaderboard_api.leaderboard_post(
-                    create_leaderboard_model=CreateLeaderboardModel(
-                        benchmarkId=self.id,
-                        name=name,
-                        instruction=instruction,
-                        showPrompt=show_prompt,
-                        showPromptAsset=show_prompt_asset,
-                        isInversed=inverse_ranking,
-                        minResponses=min_responses_per_matchup,
-                        responseBudget=DetailMapper.get_budget(level_of_detail),
-                        validationSetId=validation_set_id,
-                        filters=(
-                            [
-                                AndUserFilterModelFiltersInner(filter._to_model())
-                                for filter in filters
-                            ]
-                            if filters
-                            else None
-                        ),
-                        featureFlags=(
-                            [setting._to_feature_flag() for setting in settings]
-                            if settings
-                            else None
-                        ),
-                    )
+            leaderboard_result = self._openapi_service.leaderboard_api.leaderboard_post(
+                create_leaderboard_model=CreateLeaderboardModel(
+                    benchmarkId=self.id,
+                    name=name,
+                    instruction=instruction,
+                    showPrompt=show_prompt,
+                    showPromptAsset=show_prompt_asset,
+                    isInversed=inverse_ranking,
+                    minResponses=min_responses_per_matchup,
+                    responseBudget=DetailMapper.get_budget(level_of_detail),
+                    validationSetId=validation_set_id,
+                    filters=(
+                        [
+                            AndUserFilterModelFiltersInner(filter._to_model())
+                            for filter in filters
+                        ]
+                        if filters
+                        else None
+                    ),
+                    featureFlags=(
+                        [setting._to_feature_flag() for setting in settings]
+                        if settings
+                        else None
+                    ),
                 )
             )
 
@@ -373,7 +367,7 @@ class RapidataBenchmark:
                 min_responses_per_matchup,
                 self.id,
                 leaderboard_result.id,
-                self.__openapi_service,
+                self._openapi_service,
             )
 
     def evaluate_model(
@@ -421,12 +415,7 @@ class RapidataBenchmark:
                     "All identifiers/prompts must be in the registered identifiers/prompts list. To see the registered identifiers/prompts, use the identifiers/prompts property."
                 )
 
-            # happens before the creation of the participant to ensure all media paths are valid
-            assets: list[MediaAsset] = []
-            for media_path in media:
-                assets.append(MediaAsset(media_path))
-
-            participant_result = self.__openapi_service.benchmark_api.benchmark_benchmark_id_participants_post(
+            participant_result = self._openapi_service.benchmark_api.benchmark_benchmark_id_participants_post(
                 benchmark_id=self.id,
                 create_benchmark_participant_model=CreateBenchmarkParticipantModel(
                     name=name,
@@ -436,20 +425,20 @@ class RapidataBenchmark:
             logger.info(f"Participant created: {participant_result.participant_id}")
 
             participant = BenchmarkParticipant(
-                name, participant_result.participant_id, self.__openapi_service
+                name, participant_result.participant_id, self._openapi_service
             )
 
             with tracer.start_as_current_span("upload_media_for_participant"):
                 logger.info(
-                    f"Uploading {len(assets)} media assets to participant {participant.id}"
+                    f"Uploading {len(media)} media assets to participant {participant.id}"
                 )
 
                 successful_uploads, failed_uploads = participant.upload_media(
-                    assets,
+                    media,
                     identifiers,
                 )
 
-                total_uploads = len(assets)
+                total_uploads = len(media)
                 success_rate = (
                     (len(successful_uploads) / total_uploads * 100)
                     if total_uploads > 0
@@ -460,9 +449,7 @@ class RapidataBenchmark:
                 )
 
                 if failed_uploads:
-                    logger.error(
-                        f"Failed uploads for media: {[asset.path for asset in failed_uploads]}"
-                    )
+                    logger.error(f"Failed uploads for media: {failed_uploads}")
                     logger.warning(
                         "Some uploads failed. The model evaluation may be incomplete."
                     )
@@ -472,9 +459,9 @@ class RapidataBenchmark:
                         "No uploads were successful. The model evaluation will not be completed."
                     )
 
-            self.__openapi_service.participant_api.participants_participant_id_submit_post(
-                participant_id=participant_result.participant_id
-            )
+                self._openapi_service.participant_api.participants_participant_id_submit_post(
+                    participant_id=participant_result.participant_id
+                )
 
     def view(self) -> None:
         """

rapidata/rapidata_client/datapoints/__init__.py

@@ -1,5 +1,4 @@
 from ._datapoint import Datapoint
-from .assets import MediaAsset, MultiAsset, TextAsset
 from .metadata import (
     Metadata,
     PromptMetadata,

rapidata/rapidata_client/datapoints/_asset_uploader.py

@@ -0,0 +1,71 @@
+import re
+import os
+from rapidata.api_client.models.existing_asset_input import ExistingAssetInput
+from rapidata.api_client.models.multi_asset_input import (
+    MultiAssetInput,
+    MultiAssetInputAssetsInner,
+)
+from rapidata.api_client.models.text_asset_input import TextAssetInput
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.config import logger
+from rapidata.rapidata_client.config import tracer
+
+
+class AssetUploader:
+    def __init__(self, openapi_service: OpenAPIService):
+        self.openapi_service = openapi_service
+
+    def upload_asset(self, asset: str) -> str:
+        with tracer.start_as_current_span("AssetUploader.upload_asset"):
+            logger.debug("Uploading asset: %s", asset)
+            assert isinstance(asset, str), "Asset must be a string"
+
+            if re.match(r"^https?://", asset):
+                response = self.openapi_service.asset_api.asset_url_post(
+                    url=asset,
+                )
+            else:
+                if not os.path.exists(asset):
+                    raise FileNotFoundError(f"File not found: {asset}")
+                response = self.openapi_service.asset_api.asset_file_post(
+                    file=asset,
+                )
+            return response.file_name
+
+    def get_uploaded_text_input(
+        self, assets: list[str] | str
+    ) -> MultiAssetInput | TextAssetInput:
+        if isinstance(assets, list):
+            return MultiAssetInput(
+                _t="MultiAssetInput",
+                assets=[
+                    MultiAssetInputAssetsInner(
+                        actual_instance=TextAssetInput(_t="TextAssetInput", text=asset)
+                    )
+                    for asset in assets
+                ],
+            )
+        else:
+            return TextAssetInput(_t="TextAssetInput", text=assets)
+
+    def get_uploaded_asset_input(
+        self, assets: list[str] | str
+    ) -> MultiAssetInput | ExistingAssetInput:
+        if isinstance(assets, list):
+            return MultiAssetInput(
+                _t="MultiAssetInput",
+                assets=[
+                    MultiAssetInputAssetsInner(
+                        actual_instance=ExistingAssetInput(
+                            _t="ExistingAssetInput",
+                            name=self.upload_asset(asset),
+                        ),
+                    )
+                    for asset in assets
+                ],
+            )
+        else:
+            return ExistingAssetInput(
+                _t="ExistingAssetInput",
+                name=self.upload_asset(assets),
+            )

rapidata/rapidata_client/datapoints/_datapoint.py

@@ -1,196 +1,83 @@
-from typing import Sequence, cast
-from rapidata.rapidata_client.datapoints.assets import (
-    MediaAsset,
-    TextAsset,
-    MultiAsset,
-    BaseAsset,
-)
+from typing import Literal
+
+from pydantic import BaseModel, model_validator, field_validator
+from typing_extensions import Self
 from rapidata.rapidata_client.datapoints.assets.constants import (
     ALLOWED_VIDEO_EXTENSIONS,
     ALLOWED_IMAGE_EXTENSIONS,
     ALLOWED_AUDIO_EXTENSIONS,
 )
-from rapidata.rapidata_client.datapoints.metadata import Metadata
-from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import (
-    DatasetDatasetIdDatapointsPostRequestMetadataInner,
-)
-from rapidata.api_client.models.create_datapoint_from_text_sources_model import (
-    CreateDatapointFromTextSourcesModel,
-)
-from pydantic import StrictStr, StrictBytes
 from rapidata.api_client.models.asset_type import AssetType
 from rapidata.api_client.models.prompt_type import PromptType
-from rapidata.rapidata_client.datapoints.metadata._media_asset_metadata import (
-    MediaAssetMetadata,
-)
-from rapidata.rapidata_client.datapoints.metadata._prompt_metadata import PromptMetadata
 from rapidata.rapidata_client.config import logger
 
 
-class Datapoint:
-    def __init__(
-        self,
-        asset: MediaAsset | TextAsset | MultiAsset,
-        metadata: Sequence[Metadata] | None = None,
-    ):
-        if not isinstance(asset, (MediaAsset, TextAsset, MultiAsset)):
-            raise TypeError(
-                "Asset must be of type MediaAsset, TextAsset, or MultiAsset."
-            )
-
-        if metadata and not isinstance(metadata, Sequence):
-            raise TypeError("Metadata must be a list of Metadata objects.")
-
-        if metadata and not all(isinstance(m, Metadata) for m in metadata):
-            raise TypeError("All metadata objects must be of type Metadata.")
-
-        self.asset = asset
-        self.metadata = metadata
-
-    def _get_effective_asset_type(self) -> type:
-        """Get the effective asset type, handling MultiAsset by looking at its first asset."""
-        if isinstance(self.asset, MultiAsset):
-            return type(self.asset.assets[0])
-        return type(self.asset)
+class Datapoint(BaseModel):
+    asset: str | list[str]
+    data_type: Literal["text", "media"]
+    context: str | None = None
+    media_context: str | None = None
+    sentence: str | None = None
+    private_note: str | None = None
 
-    def is_media_asset(self) -> bool:
-        """Check if this datapoint contains media assets."""
-        effective_type = self._get_effective_asset_type()
-        return issubclass(effective_type, MediaAsset)
+    @field_validator("context")
+    @classmethod
+    def context_not_empty(cls, v: str | None) -> str | None:
+        if v is not None and v == "":
+            raise ValueError(
+                "context cannot be an empty string. If not needed, set to None."
+            )
+        return v
 
-    def is_text_asset(self) -> bool:
-        """Check if this datapoint contains text assets."""
-        effective_type = self._get_effective_asset_type()
-        return issubclass(effective_type, TextAsset)
+    @field_validator("media_context")
+    @classmethod
+    def media_context_not_empty(cls, v: str | None) -> str | None:
+        if v is not None and v == "":
+            raise ValueError(
+                "media_context cannot be an empty string. If not needed, set to None."
+            )
+        return v
+
+    @field_validator("sentence")
+    @classmethod
+    def sentence_has_space(cls, v: str | None) -> str | None:
+        if v is not None and len(v.split()) <= 1:
+            raise ValueError("sentence must contain at least two words.")
+        return v
+
+    @model_validator(mode="after")
+    def check_sentence_and_context(self) -> Self:
+        if isinstance(self.sentence, str) and isinstance(self.context, str):
+            raise ValueError(
+                "Both 'sentence' and 'context' cannot be strings at the same time."
+            )
+        return self
 
     def get_asset_type(self) -> AssetType:
-        """Get the asset type of the datapoint."""
-        if self.is_text_asset():
+        if self.data_type == "text":
             return AssetType.TEXT
-        elif self.is_media_asset():
-            if isinstance(self.asset, MultiAsset):
-                asset = self.asset.assets[0]
-            else:
-                asset = self.asset
-            assert isinstance(asset, MediaAsset)
-            if any(asset.path.endswith(ext) for ext in ALLOWED_IMAGE_EXTENSIONS):
-                return AssetType.IMAGE
-            elif any(asset.path.endswith(ext) for ext in ALLOWED_VIDEO_EXTENSIONS):
-                return AssetType.VIDEO
-            elif any(asset.path.endswith(ext) for ext in ALLOWED_AUDIO_EXTENSIONS):
-                return AssetType.AUDIO
-            else:
-                logger.debug(
-                    f"Cannot get asset type for asset type: {type(self.asset)}"
-                )
-                return AssetType.NONE
+
+        evaluation_asset = self.asset[0] if isinstance(self.asset, list) else self.asset
+        if any(evaluation_asset.endswith(ext) for ext in ALLOWED_IMAGE_EXTENSIONS):
+            return AssetType.IMAGE
+        elif any(evaluation_asset.endswith(ext) for ext in ALLOWED_VIDEO_EXTENSIONS):
+            return AssetType.VIDEO
+        elif any(evaluation_asset.endswith(ext) for ext in ALLOWED_AUDIO_EXTENSIONS):
+            return AssetType.AUDIO
         else:
-            logger.debug(f"Cannot get asset type for asset type: {type(self.asset)}")
+            logger.debug(
+                f"Cannot get asset type for asset type: {type(evaluation_asset)}"
+            )
             return AssetType.NONE
 
     def get_prompt_type(self) -> list[PromptType]:
-        """Get the prompt type of the datapoint."""
         prompt_types = []
-        for metadata in self.metadata or []:
-            if isinstance(metadata, MediaAssetMetadata):
-                prompt_types.append(PromptType.ASSET)
-            elif isinstance(metadata, PromptMetadata):
-                prompt_types.append(PromptType.TEXT)
+        if self.context:
+            prompt_types.append(PromptType.TEXT)
+        if self.media_context:
+            prompt_types.append(PromptType.ASSET)
 
         if len(prompt_types) == 0:
             return [PromptType.NONE]
 
         return prompt_types
-
-    def get_texts(self) -> list[str]:
-        """Extract text content from the asset(s)."""
-        if isinstance(self.asset, TextAsset):
-            return [self.asset.text]
-        elif isinstance(self.asset, MultiAsset):
-            texts = []
-            for asset in self.asset.assets:
-                if isinstance(asset, TextAsset):
-                    texts.append(asset.text)
-            return texts
-        else:
-            raise ValueError(f"Cannot extract text from asset type: {type(self.asset)}")
-
-    def get_media_assets(self) -> list[MediaAsset]:
-        """Extract media assets from the datapoint."""
-        if isinstance(self.asset, MediaAsset):
-            return [self.asset]
-        elif isinstance(self.asset, MultiAsset):
-            media_assets = []
-            for asset in self.asset.assets:
-                if isinstance(asset, MediaAsset):
-                    media_assets.append(asset)
-            return media_assets
-        else:
-            raise ValueError(
-                f"Cannot extract media assets from asset type: {type(self.asset)}"
-            )
-
-    def get_local_file_paths(
-        self,
-    ) -> list[StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes]:
-        """Get local file paths for media assets that are stored locally."""
-        if not self.is_media_asset():
-            return []
-
-        media_assets = self.get_media_assets()
-        return [asset.to_file() for asset in media_assets if asset.is_local()]
-
-    def get_urls(self) -> list[str]:
-        """Get URLs for media assets that are remote."""
-        if not self.is_media_asset():
-            return []
-
-        media_assets = self.get_media_assets()
-        return [asset.path for asset in media_assets if not asset.is_local()]
-
-    def get_prepared_metadata(
-        self,
-    ) -> list[DatasetDatasetIdDatapointsPostRequestMetadataInner]:
-        """Prepare metadata for API upload."""
-        metadata: list[DatasetDatasetIdDatapointsPostRequestMetadataInner] = []
-        if self.metadata:
-            for meta in self.metadata:
-                meta_model = meta.to_model() if meta else None
-                if meta_model:
-                    metadata.append(
-                        DatasetDatasetIdDatapointsPostRequestMetadataInner(meta_model)
-                    )
-        return metadata
-
-    def create_text_upload_model(
-        self, index: int
-    ) -> CreateDatapointFromTextSourcesModel:
-        """Create the model for uploading text datapoints."""
-        if not self.is_text_asset():
-            raise ValueError("Cannot create text upload model for non-text asset")
-
-        texts = self.get_texts()
-        metadata = self.get_prepared_metadata()
-
-        return CreateDatapointFromTextSourcesModel(
-            textSources=texts,
-            sortIndex=index,
-            metadata=metadata,
-        )
-
-    def get_datapoint_string(self) -> str:
-        """Get the datapoint string for the datapoint."""
-        if isinstance(self.asset, MediaAsset):
-            return self.asset.path
-        elif isinstance(self.asset, TextAsset):
-            return self.asset.text
-        else:
-            raise ValueError(
-                f"Cannot get datapoint string for asset type: {type(self.asset)}"
-            )
-
-    def __str__(self):
-        return f"Datapoint(asset={self.asset})"
-
-    def __repr__(self):
-        return self.__str__()