rapidata 2.27.0__py3-none-any.whl → 2.44.4__py3-none-any.whl

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -1,30 +1,75 @@
-from rapidata.api_client import CompareWorkflowModelPairMakerConfig, OnlinePairMakerConfigModel, EloConfigModel
-from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
+from rapidata.api_client import (
+    CompareWorkflowModelPairMakerConfig,
+    OnlinePairMakerConfigModel,
+    EloConfigModel,
+)
+from rapidata.api_client.models.add_validation_rapid_model import IRapidPayload
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_compare_workflow_model import (
+    IOrderWorkflowModelCompareWorkflowModel,
+)
 from rapidata.rapidata_client.workflow._base_workflow import Workflow
-from rapidata.rapidata_client.metadata import PromptMetadata
-from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
+from rapidata.api_client.models.i_rapid_payload_compare_payload import (
+    IRapidPayloadComparePayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.rapidata_client.datapoints.metadata import (
+    MediaAssetMetadata,
+    PromptMetadata,
+)
+from rapidata.api_client.models.metadata_i_order_metadata_input import (
+    MetadataIOrderMetadataInput,
+)
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+import itertools
+import random
+from typing import cast
 
 
 class RankingWorkflow(Workflow):
-    def __init__(self,
-                 criteria: str,
-                 total_comparison_budget: int,
-                 random_comparisons_ratio,
-                 elo_start: int = 1200,
-                 elo_k_factor: int = 40,
-                 elo_scaling_factor: int = 400,
-                 context: str | None = None,
-                 ):
+    modality = RapidModality.COMPARE
+
+    def __init__(
+        self,
+        instruction: str,
+        total_comparison_budget: int,
+        random_comparisons_ratio,
+        elo_start: int = 1200,
+        elo_k_factor: int = 40,
+        elo_scaling_factor: int = 400,
+        media_context: str | None = None,
+        context: str | None = None,
+        file_uploader: AssetUploader | None = None,
+    ):
         super().__init__(type="CompareWorkflowConfig")
 
-        self.context = [DatasetDatasetIdDatapointsPostRequestMetadataInner(
-            PromptMetadata(context).to_model())
-            ] if context else None
+        self.media_context = media_context
+        self.context = context
+
+        self.metadatas = []
+        if media_context:
+            assert (
+                file_uploader is not None
+            ), "File uploader is required if media_context is provided"
+            self.metadatas.append(
+                MediaAssetMetadata(
+                    internal_file_name=file_uploader.upload_asset(media_context)
+                )
+            )
+        if context:
+            self.metadatas.append(PromptMetadata(prompt=context))
+
+        self.instruction = instruction
+        self.total_comparison_budget = total_comparison_budget
+        self.random_comparisons_ratio = random_comparisons_ratio
+        self.elo_start = elo_start
+        self.elo_k_factor = elo_k_factor
+        self.elo_scaling_factor = elo_scaling_factor
 
-        self.criteria = criteria
         self.pair_maker_config = CompareWorkflowModelPairMakerConfig(
             OnlinePairMakerConfigModel(
-                _t='OnlinePairMaker',
+                _t="OnlinePairMaker",
                 totalComparisonBudget=total_comparison_budget,
                 randomMatchesRatio=random_comparisons_ratio,
             )
@@ -36,12 +81,51 @@ class RankingWorkflow(Workflow):
             scalingFactor=elo_scaling_factor,
         )
 
-    def _to_model(self) -> CompareWorkflowModel:
+    def _get_instruction(self) -> str:
+        return self.instruction
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelCompareWorkflowModel(
+                _t="CompareWorkflow",
+                criteria=self.instruction,
+                eloConfig=self.elo_config,
+                pairMakerConfig=self.pair_maker_config,
+                metadata=[
+                    MetadataIOrderMetadataInput(metadata.to_model())
+                    for metadata in self.metadatas
+                ],
+            )
+        )
 
-        return CompareWorkflowModel(
-            _t="CompareWorkflow",
-            criteria=self.criteria,
-            eloConfig=self.elo_config,
-            pairMakerConfig=self.pair_maker_config,
-            metadata=self.context,
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadComparePayload(
+                _t="ComparePayload",
+                criteria=self.instruction,
+            )
         )
+
+    def _format_datapoints(self, datapoints: list[Datapoint]) -> list[Datapoint]:
+        if len(datapoints) < 3:
+            raise ValueError("RankingWorkflow requires at least three datapoints")
+        desired_length = len(datapoints)
+        assets = [datapoint.asset for datapoint in datapoints]
+        pairs = list(map(list, itertools.combinations(assets, 2)))
+        sampled_pairs = random.sample(pairs, desired_length)
+        formatted_datapoints = [
+            Datapoint(
+                asset=cast(list[str], pair),
+                data_type=datapoints[0].data_type,
+                context=self.context,
+                media_context=self.media_context,
+            )
+            for pair in sampled_pairs
+        ]
+        return formatted_datapoints
+
+    def __str__(self) -> str:
+        return f"RankingWorkflow(instruction='{self.instruction}', metadatas={self.metadatas})"
+
+    def __repr__(self) -> str:
+        return f"RankingWorkflow(instruction={self.instruction!r}, total_comparison_budget={self.total_comparison_budget!r}, random_comparisons_ratio={self.random_comparisons_ratio!r}, elo_start={self.elo_start!r}, elo_k_factor={self.elo_k_factor!r}, elo_scaling_factor={self.elo_scaling_factor!r}, metadatas={self.metadatas!r})"

rapidata/rapidata_client/workflow/_select_words_workflow.py

@@ -1,14 +1,26 @@
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.api_client.models.transcription_rapid_blueprint import TranscriptionRapidBlueprint
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_rapid_blueprint_transcription_rapid_blueprint import (
+    IRapidBlueprintTranscriptionRapidBlueprint,
+)
 from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_transcription_payload import (
+    IRapidPayloadTranscriptionPayload,
+)
+from rapidata.api_client.models.transcription_word import TranscriptionWord
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
 
 
 class SelectWordsWorkflow(Workflow):
     """
     A workflow for select words tasks.
 
-    This class represents a select words workflow 
+    This class represents a select words workflow
     where datapoints have a sentence attached to them where words can be selected.
 
     Attributes:
@@ -18,17 +30,45 @@ class SelectWordsWorkflow(Workflow):
         instruction (str): The instruction to be provided for the select words task.
     """
 
+    modality = RapidModality.TRANSCRIPTION
+
     def __init__(self, instruction: str):
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction
 
-    def _to_model(self) -> SimpleWorkflowModel:
-        blueprint = TranscriptionRapidBlueprint(
-            _t="TranscriptionBlueprint",
-            title=self._instruction
+    def _get_instruction(self) -> str:
+        return self._instruction
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintTranscriptionRapidBlueprint(
+            _t="TranscriptionBlueprint", title=self._instruction
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint)
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
         )
+
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        assert (
+            datapoint.sentence is not None
+        ), "SelectWordsWorkflow requires a sentence datapoint"
+
+        return IRapidPayload(
+            actual_instance=IRapidPayloadTranscriptionPayload(
+                _t="TranscriptionPayload",
+                title=self._instruction,
+                transcription=[
+                    TranscriptionWord(word=word, wordIndex=i)
+                    for i, word in enumerate(datapoint.sentence.split())
+                ],
+            )
+        )
+
+    def __str__(self) -> str:
+        return f"SelectWordsWorkflow(instruction='{self._instruction}')"
+
+    def __repr__(self) -> str:
+        return f"SelectWordsWorkflow(instruction={self._instruction!r})"

rapidata/rapidata_client/workflow/_timestamp_workflow.py

@@ -1,14 +1,25 @@
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.api_client.models.scrub_rapid_blueprint import ScrubRapidBlueprint
+from rapidata.api_client.models.i_order_workflow_model import IOrderWorkflowModel
+from rapidata.api_client.models.i_order_workflow_model_simple_workflow_model import (
+    IOrderWorkflowModelSimpleWorkflowModel,
+)
+from rapidata.api_client.models.i_rapid_blueprint import IRapidBlueprint
+from rapidata.api_client.models.i_rapid_blueprint_scrub_rapid_blueprint import (
+    IRapidBlueprintScrubRapidBlueprint,
+)
 from rapidata.rapidata_client.workflow._base_workflow import Workflow
+from rapidata.api_client.models.i_rapid_payload_scrub_payload import (
+    IRapidPayloadScrubPayload,
+)
+from rapidata.rapidata_client.datapoints._datapoint import Datapoint
+from rapidata.api_client.models.rapid_modality import RapidModality
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
 
 
 class TimestampWorkflow(Workflow):
     """
     A workflow for timestamp tasks.
 
-    This class represents a timestamp workflow 
+    This class represents a timestamp workflow
     where audio or video content receives timestamps based on the instruction.
 
     Attributes:
@@ -18,17 +29,37 @@ class TimestampWorkflow(Workflow):
         instruction (str): The instruction to be provided for the timestamp task.
     """
 
+    modality = RapidModality.SCRUB
+
     def __init__(self, instruction: str):
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction
 
-    def _to_model(self) -> SimpleWorkflowModel:
-        blueprint = ScrubRapidBlueprint(
-            _t="ScrubBlueprint",
-            target=self._instruction
+    def _get_instruction(self) -> str:
+        return self._instruction
+
+    def _to_model(self) -> IOrderWorkflowModel:
+        blueprint = IRapidBlueprintScrubRapidBlueprint(
+            _t="ScrubBlueprint", target=self._instruction
+        )
+
+        return IOrderWorkflowModel(
+            actual_instance=IOrderWorkflowModelSimpleWorkflowModel(
+                _t="SimpleWorkflow",
+                blueprint=IRapidBlueprint(actual_instance=blueprint),
+            )
         )
 
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint)
+    def _to_payload(self, datapoint: Datapoint) -> IRapidPayload:
+        return IRapidPayload(
+            actual_instance=IRapidPayloadScrubPayload(
+                _t="ScrubPayload",
+                target=self._instruction,
+            )
         )
+
+    def __str__(self) -> str:
+        return f"TimestampWorkflow(instruction='{self._instruction}')"
+
+    def __repr__(self) -> str:
+        return f"TimestampWorkflow(instruction={self._instruction!r})"

rapidata/service/__init__.py

@@ -1 +0,0 @@
-from .local_file_service import LocalFileService as LocalFileService

rapidata/service/credential_manager.py

@@ -11,7 +11,7 @@ from typing import Dict, List, Optional, Tuple
 import requests
 from colorama import Fore
 from pydantic import BaseModel
-from rapidata.rapidata_client.logging import logger, managed_print
+from rapidata.rapidata_client.config import logger, managed_print
 
 
 class ClientCredential(BaseModel):
@@ -52,7 +52,7 @@ class CredentialManager:
 
     def _read_credentials(self) -> Dict[str, List[ClientCredential]]:
         """Read all stored credentials from the config file."""
-        logger.debug(f"Reading credentials from {self.config_path}")
+        logger.debug("Reading credentials from %s", self.config_path)
         if not self.config_path.exists():
             return {}
 
@@ -77,11 +77,13 @@ class CredentialManager:
         with open(self.config_path, "w") as f:
             json.dump(data, f, indent=2)
 
-        logger.debug(f"Credentials written to {self.config_path} with data: {data}")
+        logger.debug("Credentials written to %s with data: %s", self.config_path, data)
 
         # Ensure file is only readable by the user
         os.chmod(self.config_path, 0o600)
-        logger.debug(f"Set permissions for {self.config_path} to read/write for user only.")
+        logger.debug(
+            "Set permissions for %s to read/write for user only.", self.config_path
+        )
 
     def _store_credential(self, credential: ClientCredential) -> None:
         credentials = self._read_credentials()
@@ -107,19 +109,19 @@ class CredentialManager:
     def get_client_credentials(self) -> Optional[ClientCredential]:
         """Gets stored client credentials or create new ones via browser auth."""
         credentials = self._read_credentials()
-        logger.debug(f"Stored credentials: {credentials}")
+        logger.debug("Stored credentials: %s", credentials)
         env_credentials = credentials.get(self.endpoint, [])
 
         if env_credentials:
-            logger.debug(f"Found credentials for {self.endpoint}: {env_credentials}")
+            logger.debug("Found credentials for %s: %s", self.endpoint, env_credentials)
             credential = self._select_credential(env_credentials)
-            logger.debug(f"Selected credential: {credential}")
+            logger.debug("Selected credential: %s", credential)
             if credential:
                 credential.last_used = datetime.now(timezone.utc)
                 self._write_credentials(credentials)
                 return credential
 
-        logger.debug(f"No credentials found for {self.endpoint}. Creating new ones.")
+        logger.debug("No credentials found for %s. Creating new ones.", self.endpoint)
         return self._create_new_credentials()
 
     def reset_credentials(self) -> None:
@@ -128,31 +130,29 @@ class CredentialManager:
         if self.endpoint in credentials:
             del credentials[self.endpoint]
             self._write_credentials(credentials)
-            logger.info(
-                f"Credentials for {self.endpoint} have been reset."
-            )
+            logger.info("Credentials for %s have been reset.", self.endpoint)
 
     def _get_bridge_tokens(self) -> Optional[BridgeToken]:
         """Get bridge tokens from the identity endpoint."""
         logger.debug("Getting bridge tokens")
         try:
             bridge_endpoint = (
-                f"{self.endpoint}/Identity/CreateBridgeToken?clientId=rapidata-cli"
+                f"{self.endpoint}/identity/bridge-token?clientId=rapidata-cli"
             )
             response = requests.post(bridge_endpoint, verify=self.cert_path)
             if not response.ok:
-                logger.error(f"Failed to get bridge tokens: {response.status_code}")
+                logger.error("Failed to get bridge tokens: %s", response.status_code)
                 return None
 
             data = response.json()
             return BridgeToken(read_key=data["readKey"], write_key=data["writeKey"])
         except requests.RequestException as e:
-            logger.error(f"Failed to get bridge tokens: {e}")
+            logger.error("Failed to get bridge tokens: %s", e)
             return None
 
     def _poll_read_key(self, read_key: str) -> Optional[str]:
         """Poll the read key endpoint until we get an access token."""
-        read_endpoint = f"{self.endpoint}/Identity/ReadBridgeToken"
+        read_endpoint = f"{self.endpoint}/identity/bridge-token"
         start_time = time.time()
 
         while time.time() - start_time < self.poll_timeout:
@@ -169,11 +169,11 @@ class CredentialManager:
                     continue
                 else:
                     # Error occurred
-                    logger.error(f"Error polling read key: {response.status_code}")
+                    logger.error("Error polling read key: %s", response.status_code)
                     return None
 
             except requests.RequestException as e:
-                logger.error(f"Error polling read key: {e}")
+                logger.error("Error polling read key: %s", e)
                 return None
 
         logger.error("Polling timed out")
@@ -198,7 +198,7 @@ class CredentialManager:
             data = response.json()
             return data.get("clientId"), data.get("clientSecret"), display_name
         except requests.RequestException as e:
-            logger.error(f"Failed to create client: {e}")
+            logger.error("Failed to create client: %s", e)
             return None
 
     def _create_new_credentials(self) -> Optional[ClientCredential]:

rapidata/service/openapi_service.py

@@ -1,29 +1,38 @@
+from __future__ import annotations
+
 import subprocess
 from importlib.metadata import version, PackageNotFoundError
+from typing import TYPE_CHECKING
 
-from rapidata.api_client.api.campaign_api import CampaignApi
-from rapidata.api_client.api.dataset_api import DatasetApi
-from rapidata.api_client.api.order_api import OrderApi
-from rapidata.api_client.api.pipeline_api import PipelineApi
-from rapidata.api_client.api.rapid_api import RapidApi
-from rapidata.api_client.api.validation_set_api import ValidationSetApi
-from rapidata.api_client.api.workflow_api import WorkflowApi
 from rapidata.api_client.configuration import Configuration
 from rapidata.service.credential_manager import CredentialManager
-from rapidata.rapidata_client.api.rapidata_exception import RapidataApiClient
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.api.rapidata_api_client import RapidataApiClient
+from rapidata.rapidata_client.config import logger
+
+if TYPE_CHECKING:
+    from rapidata.api_client import CustomerRapidApi
+    from rapidata.api_client.api.campaign_api import CampaignApi
+    from rapidata.api_client.api.asset_api import AssetApi
+    from rapidata.api_client.api.dataset_api import DatasetApi
+    from rapidata.api_client.api.benchmark_api import BenchmarkApi
+    from rapidata.api_client.api.order_api import OrderApi
+    from rapidata.api_client.api.pipeline_api import PipelineApi
+    from rapidata.api_client.api.leaderboard_api import LeaderboardApi
+    from rapidata.api_client.api.validation_set_api import ValidationSetApi
+    from rapidata.api_client.api.workflow_api import WorkflowApi
+    from rapidata.api_client.api.participant_api import ParticipantApi
 
 
 class OpenAPIService:
     def __init__(
-            self,
-            client_id: str | None,
-            client_secret: str | None,
-            environment: str,
-            oauth_scope: str,
-            cert_path: str | None = None,
-            token: dict | None = None,
-            leeway: int = 60,
+        self,
+        client_id: str | None,
+        client_secret: str | None,
+        environment: str,
+        oauth_scope: str,
+        cert_path: str | None = None,
+        token: dict | None = None,
+        leeway: int = 60,
     ):
         self.environment = environment
         endpoint = f"https://api.{environment}"
@@ -32,7 +41,12 @@ class OpenAPIService:
         if environment == "rapidata.dev" and not cert_path:
             cert_path = _get_local_certificate()
 
-        logger.debug(f"Using cert_path: {cert_path} environment: {environment} token: {token} client_id: {client_id} client_secret: {client_secret}")
+        logger.debug(
+            "Using cert_path: %s environment: %s client_id: %s",
+            cert_path,
+            environment,
+            client_id,
+        )
         logger.debug("Initializing OpenAPIService")
         self.credential_manager = CredentialManager(
             endpoint=auth_endpoint, cert_path=cert_path
@@ -41,7 +55,7 @@ class OpenAPIService:
 
         logger.debug("Initializing RapidataApiClient")
         client_configuration = Configuration(host=endpoint, ssl_ca_cert=cert_path)
-        logger.debug(f"Client configuration: {client_configuration}")
+        logger.debug("Client configuration: %s", client_configuration)
         self.api_client = RapidataApiClient(
             configuration=client_configuration,
             header_name="X-Client",
@@ -62,7 +76,9 @@ class OpenAPIService:
             return
 
         if not client_id or not client_secret:
-            logger.debug("Client ID and secret not provided, fetching from credential manager")
+            logger.debug(
+                "Client ID and secret not provided, fetching from credential manager"
+            )
             credentials = self.credential_manager.get_client_credentials()
             if not credentials:
                 raise ValueError("Failed to fetch client credentials")
@@ -82,32 +98,70 @@ class OpenAPIService:
 
     @property
     def order_api(self) -> OrderApi:
+        from rapidata.api_client.api.order_api import OrderApi
+
         return OrderApi(self.api_client)
 
+    @property
+    def asset_api(self) -> AssetApi:
+        from rapidata.api_client.api.asset_api import AssetApi
+
+        return AssetApi(self.api_client)
+
     @property
     def dataset_api(self) -> DatasetApi:
+        from rapidata.api_client.api.dataset_api import DatasetApi
+
         return DatasetApi(self.api_client)
 
     @property
     def validation_api(self) -> ValidationSetApi:
+        from rapidata.api_client.api.validation_set_api import ValidationSetApi
+
         return ValidationSetApi(self.api_client)
 
     @property
-    def rapid_api(self) -> RapidApi:
-        return RapidApi(self.api_client)
+    def rapid_api(self) -> CustomerRapidApi:
+        from rapidata.api_client.api.customer_rapid_api import CustomerRapidApi
+
+        return CustomerRapidApi(self.api_client)
 
     @property
     def campaign_api(self) -> CampaignApi:
+        from rapidata.api_client.api.campaign_api import CampaignApi
+
         return CampaignApi(self.api_client)
 
     @property
     def pipeline_api(self) -> PipelineApi:
+        from rapidata.api_client.api.pipeline_api import PipelineApi
+
         return PipelineApi(self.api_client)
 
     @property
     def workflow_api(self) -> WorkflowApi:
+        from rapidata.api_client.api.workflow_api import WorkflowApi
+
         return WorkflowApi(self.api_client)
 
+    @property
+    def leaderboard_api(self) -> LeaderboardApi:
+        from rapidata.api_client.api.leaderboard_api import LeaderboardApi
+
+        return LeaderboardApi(self.api_client)
+
+    @property
+    def benchmark_api(self) -> BenchmarkApi:
+        from rapidata.api_client.api.benchmark_api import BenchmarkApi
+
+        return BenchmarkApi(self.api_client)
+
+    @property
+    def participant_api(self) -> ParticipantApi:
+        from rapidata.api_client.api.participant_api import ParticipantApi
+
+        return ParticipantApi(self.api_client)
+
     def _get_rapidata_package_version(self):
         """
         Returns the version of the currently installed rapidata package.
@@ -121,6 +175,12 @@ class OpenAPIService:
         except PackageNotFoundError:
             return None
 
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __str__(self) -> str:
+        return f"OpenAPIService(environment={self.environment})"
+
 
 def _get_local_certificate() -> str | None:
     result = subprocess.run(["mkcert", "-CAROOT"], capture_output=True)