rapidata 2.35.1__py3-none-any.whl → 3.0.0a8__py3-none-any.whl

rapidata/rapidata_client/__init__.py

@@ -1,4 +1,12 @@
 from .rapidata_client import RapidataClient
+from .audience import (
+    RapidataAudience,
+    RapidataAudienceManager,
+)
+from .order import RapidataOrderManager, RapidataOrder
+from .job import RapidataJob, JobDefinition, JobManager
+from .validation import ValidationSetManager, RapidataValidationSet, Box
+from .results import RapidataResults
 from .selection import (
     DemographicSelection,
     LabelingSelection,
@@ -6,24 +14,17 @@ from .selection import (
     ConditionalValidationSelection,
     CappedSelection,
     ShufflingSelection,
-    RetrievalMode,
+    RapidataRetrievalMode,
     EffortSelection,
 )
 from .datapoints import Datapoint
 from .datapoints.metadata import (
     PrivateTextMetadata,
     PublicTextMetadata,
-    PromptMetadata,
     SelectWordsMetadata,
 )
-from .datapoints.assets import (
-    MediaAsset, 
-    TextAsset, 
-    MultiAsset, 
-    RapidataDataTypes
-)
 from .settings import (
-    RapidataSettings, 
+    RapidataSettings,
     TranslationBehaviourOptions,
     AlertOnFastResponse,
     TranslationBehaviour,
@@ -32,11 +33,15 @@ from .settings import (
     PlayVideoUntilTheEnd,
     CustomSetting,
     AllowNeitherBoth,
-    )
-from .country_codes import CountryCodes
+    SwapContextInstruction,
+    MuteVideo,
+)
 from .filter import (
     CountryFilter,
     LanguageFilter,
+    NotFilter,
+    OrFilter,
+    AndFilter,
     UserScoreFilter,
     CampaignFilter,
     AgeFilter,
@@ -44,16 +49,6 @@ from .filter import (
     CustomFilter,
     AgeGroup,
     Gender,
-    NotFilter,
-    OrFilter,
-    ResponseCountFilter,
-)
-
-from .logging import (
-    configure_logger, 
-    logger,
-    RapidataOutputManager
 )
-
-from .validation import Box
 from .exceptions import FailedUploadException
+from .config import rapidata_config, logger, managed_print

rapidata/rapidata_client/api/rapidata_api_client.py

@@ -0,0 +1,253 @@
+from typing import Optional, Any
+from rapidata.api_client.api_client import (
+    ApiClient,
+    rest,
+    ApiResponse,
+    ApiResponseT,
+)
+from rapidata.api_client.exceptions import ApiException
+import json
+import threading
+from contextlib import contextmanager
+from rapidata.rapidata_client.config import logger, tracer
+from opentelemetry import trace
+from opentelemetry.trace import format_trace_id, format_span_id, Link, SpanContext
+from opentelemetry.sdk.trace.id_generator import RandomIdGenerator
+
+
+# Thread-local storage for controlling error logging
+_thread_local = threading.local()
+
+
+@contextmanager
+def suppress_rapidata_error_logging():
+    """Context manager to suppress error logging for RapidataApiClient calls."""
+    old_value = getattr(_thread_local, "suppress_error_logging", False)
+    _thread_local.suppress_error_logging = True
+    try:
+        yield
+    finally:
+        _thread_local.suppress_error_logging = old_value
+
+
+def _should_suppress_error_logging() -> bool:
+    """Check if error logging should be suppressed for the current thread."""
+    return getattr(_thread_local, "suppress_error_logging", False)
+
+
+class RapidataError(Exception):
+    """Custom error class for Rapidata API errors."""
+
+    def __init__(
+        self,
+        status_code: Optional[int] = None,
+        message: str | None = None,
+        original_exception: Exception | None = None,
+        details: Any = None,
+    ):
+        self.status_code = status_code
+        self.message = message
+        self.original_exception = original_exception
+        self.details = details
+
+        # Create a nice error message
+        error_msg = "Rapidata API Error"
+        if status_code:
+            error_msg += f" ({status_code})"
+        if message:
+            error_msg += f": {message}"
+
+        super().__init__(error_msg)
+
+    def __str__(self):
+        """Return a string representation of the error."""
+        # Extract information from message if available
+        title = None
+        errors = None
+        trace_id = None
+
+        # Try to extract from details if available and is a dict
+        if self.details and isinstance(self.details, dict):
+            title = self.details.get("title")
+            errors = self.details.get("errors")
+            trace_id = self.details.get("traceId")
+
+        # Build the error string
+        error_parts = []
+
+        # Main error line
+        if title:
+            error_parts.append(f"{title}")
+        else:
+            error_parts.append(f"{self.message or 'Unknown error'}")
+
+        # Reasons
+        if errors:
+            if isinstance(errors, dict):
+                error_parts.append(f"Reasons: {json.dumps({'errors': errors})}")
+            else:
+                error_parts.append(f"Reasons: {errors}")
+
+        # Trace ID
+        if trace_id:
+            error_parts.append(f"Trace Id: {trace_id}")
+        else:
+            error_parts.append("Trace Id: N/A")
+
+        return "\n".join(error_parts)
+
+
+class RapidataApiClient(ApiClient):
+    """Custom API client that wraps errors in RapidataError."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.id_generator = RandomIdGenerator()
+
+    def call_api(
+        self,
+        method,
+        url,
+        header_params=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None,
+    ) -> rest.RESTResponse:
+        # Get the current span from OpenTelemetry
+        current_span = trace.get_current_span()
+
+        # Initialize header_params if it's None
+        if header_params is None:
+            header_params = {}
+
+        # Add tracing headers if we have a valid span
+        if not current_span.is_recording():
+            return super().call_api(
+                method,
+                url,
+                header_params,
+                body,
+                post_params,
+                _request_timeout,
+            )
+
+        current_span_context = current_span.get_span_context()
+
+        # Generate a new trace ID for backend communication
+        # This separates the backend trace from the SDK trace
+        backend_trace_id = self.id_generator.generate_trace_id()
+        backend_span_id = self.id_generator.generate_span_id()
+
+        # Create a new span context for the backend trace
+        backend_span_context = SpanContext(
+            trace_id=backend_trace_id,
+            span_id=backend_span_id,
+            is_remote=True,
+            trace_flags=current_span_context.trace_flags,
+        )
+
+        # Create a link from current SDK span to the backend trace
+        link_to_backend = Link(backend_span_context)
+
+        # Create a link from backend trace back to the original SDK span
+        link_back_to_sdk = Link(current_span_context)
+
+        # Create a span in the current SDK trace that links to the backend
+        with tracer.start_span(
+            f"{str(method).upper()} {url}",
+            links=[link_to_backend],
+        ) as sdk_request_span:
+            # Set attributes on the SDK span
+            sdk_request_span.set_attribute("http.method", method)
+            sdk_request_span.set_attribute("http.target", url)
+            sdk_request_span.set_attribute(
+                "rapidata.backend_trace_id", format_trace_id(backend_trace_id)
+            )
+            sdk_request_span.set_attribute(
+                "rapidata.original_trace_id",
+                format_trace_id(current_span_context.trace_id),
+            )
+
+            # Now create the initial span for the backend trace that will be sent
+            # This span will be the starting point for the backend trace
+            with tracer.start_span(
+                f"{str(method).upper()} {url}",
+                context=trace.set_span_in_context(
+                    trace.NonRecordingSpan(backend_span_context)
+                ),
+                links=[link_back_to_sdk],
+            ) as backend_initial_span:
+                # Set attributes on the backend initial span
+                backend_initial_span.set_attribute("http.method", method)
+                backend_initial_span.set_attribute("http.target", url)
+                backend_initial_span.set_attribute(
+                    "rapidata.trace_type", "backend_start"
+                )
+                backend_initial_span.set_attribute(
+                    "rapidata.sdk_trace_id",
+                    format_trace_id(current_span_context.trace_id),
+                )
+
+                # Format the traceparent header with the backend trace ID
+                # The backend will receive this and continue the trace
+                header_params["traceparent"] = (
+                    "00-"
+                    + format_trace_id(backend_trace_id)
+                    + "-"
+                    + format_span_id(backend_initial_span.get_span_context().span_id)
+                    + "-"
+                    + f"{backend_span_context.trace_flags:02x}"
+                )
+
+                return super().call_api(
+                    method,
+                    url,
+                    header_params,
+                    body,
+                    post_params,
+                    _request_timeout,
+                )
+
+    def response_deserialize(
+        self,
+        response_data: rest.RESTResponse,
+        response_types_map: Optional[dict[str, ApiResponseT]] = None,
+    ) -> ApiResponse[ApiResponseT]:
+        """Override the response_deserialize method to catch and convert exceptions."""
+        try:
+            return super().response_deserialize(response_data, response_types_map)
+        except ApiException as e:
+            status_code = getattr(e, "status", None)
+            message = str(e)
+            details = None
+
+            # Extract more detailed error message from response body if available
+            if hasattr(e, "body") and e.body:
+                try:
+                    body_json = json.loads(e.body)
+                    if isinstance(body_json, dict):
+                        if "message" in body_json:
+                            message = body_json["message"]
+                        elif "error" in body_json:
+                            message = body_json["error"]
+
+                        # Store the full error details for debugging
+                        details = body_json
+                except (json.JSONDecodeError, AttributeError):
+                    # If we can't parse the body as JSON, use the original message
+                    pass
+
+            error_formatted = RapidataError(
+                status_code=status_code,
+                message=message,
+                original_exception=e,
+                details=details,
+            )
+
+            # Only log error if not suppressed
+            if not _should_suppress_error_logging():
+                logger.error("Error: %s", error_formatted)
+            else:
+                logger.debug("Suppressed Error: %s", error_formatted)
+
+            raise error_formatted from None

rapidata/rapidata_client/audience/__init__.py

@@ -0,0 +1,2 @@
+from .rapidata_audience import RapidataAudience
+from .rapidata_audience_manager import RapidataAudienceManager

rapidata/rapidata_client/audience/audience_example_handler.py

@@ -0,0 +1,168 @@
+from typing import Literal
+
+from rapidata.api_client.models.i_validation_truth_attach_category_truth import (
+    IValidationTruthAttachCategoryTruth,
+)
+from rapidata.api_client.models.i_rapid_payload_classify_payload import (
+    IRapidPayloadClassifyPayload,
+)
+from rapidata.api_client.models.classify_payload_category import ClassifyPayloadCategory
+from rapidata.api_client.models.i_rapid_payload_compare_payload import (
+    IRapidPayloadComparePayload,
+)
+from rapidata.api_client.models.i_validation_truth_compare_truth import (
+    IValidationTruthCompareTruth,
+)
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.api_client.models.i_rapid_payload import IRapidPayload
+from rapidata.api_client.models.i_validation_truth import IValidationTruth
+from rapidata.rapidata_client.datapoints._asset_uploader import AssetUploader
+
+
+class AudienceExampleHandler:
+    """
+    Can be used to build different types of examples. That can then be added to Example sets
+    """
+
+    def __init__(self, openapi_service: OpenAPIService, audience_id: str):
+        self._openapi_service = openapi_service
+        self._audience_id = audience_id
+        self._asset_uploader = AssetUploader(openapi_service)
+
+    def add_classification_example(
+        self,
+        instruction: str,
+        answer_options: list[str],
+        datapoint: str,
+        truth: list[str],
+        data_type: Literal["media", "text"] = "media",
+        context: str | None = None,
+        media_context: str | None = None,
+        explanation: str | None = None,
+    ) -> None:
+        """add a classification example to the audience
+
+        Args:
+            instruction (str): The instruction/question to be shown to the labeler.
+            answer_options (list[str]): The options that the labeler can choose from to answer the question.
+            datapoint (str): The datapoint that the labeler will be labeling.
+            truts (list[str]): The correct answers to the question.
+            data_type (str, optional): The type of the datapoint. Defaults to "media" (any form of image, video or audio).
+            context (str, optional): The context is text that will be shown in addition to the instruction. Defaults to None.
+            media_context (str, optional): The media context is a link to an image / video that will be shown in addition to the instruction (can be combined with context). Defaults to None.
+            explanation (str, optional): The explanation that will be shown to the labeler if the answer is wrong. Defaults to None.
+        """
+        from rapidata.api_client.models.add_rapid_to_audience_model import (
+            AddRapidToAudienceModel,
+        )
+
+        if not isinstance(truth, list):
+            raise ValueError("Truth must be a list of strings")
+
+        if not all(truth in answer_options for truth in truth):
+            raise ValueError("Truth must be part of the answer options")
+
+        if data_type == "media":
+            asset_input = self._asset_uploader.get_uploaded_asset_input(datapoint)
+        else:
+            asset_input = self._asset_uploader.get_uploaded_text_input(datapoint)
+
+        payload = IRapidPayload(
+            actual_instance=IRapidPayloadClassifyPayload(
+                _t="ClassifyPayload",
+                categories=[
+                    ClassifyPayloadCategory(label=option, value=option)
+                    for option in answer_options
+                ],
+                title=instruction,
+            )
+        )
+        model_truth = IValidationTruth(
+            actual_instance=IValidationTruthAttachCategoryTruth(
+                correctCategories=truth, _t="AttachCategoryTruth"
+            )
+        )
+
+        self._openapi_service.audience_api.audience_audience_id_rapid_post(
+            audience_id=self._audience_id,
+            add_rapid_to_audience_model=AddRapidToAudienceModel(
+                asset=asset_input,
+                payload=payload,
+                truth=model_truth,
+                context=context,
+                contextAsset=(
+                    self._asset_uploader.get_uploaded_asset_input(media_context)
+                    if media_context
+                    else None
+                ),
+                explanation=explanation,
+                randomCorrectProbability=len(truth) / len(answer_options),
+            ),
+        )
+
+    def add_compare_example(
+        self,
+        instruction: str,
+        truth: str,
+        datapoint: list[str],
+        data_type: Literal["media", "text"] = "media",
+        context: str | None = None,
+        media_context: str | None = None,
+        explanation: str | None = None,
+    ) -> None:
+        """add a compare example to the audience
+
+        Args:
+            instruction (str): The instruction that the labeler will be comparing the assets on.
+            truth (str): The correct answer to the comparison. (has to be one of the assets)
+            datapoint (list[str]): The two assets that the labeler will be comparing.
+            data_type (str, optional): The type of the datapoint. Defaults to "media" (any form of image, video or audio).
+            context (str, optional): The context is text that will be shown in addition to the instruction. Defaults to None.
+            media_context (str, optional): The media context is a link to an image / video that will be shown in addition to the instruction (can be combined with context). Defaults to None.
+            explanation (str, optional): The explanation that will be shown to the labeler if the answer is wrong. Defaults to None.
+        """
+        from rapidata.api_client.models.add_rapid_to_audience_model import (
+            AddRapidToAudienceModel,
+        )
+
+        payload = IRapidPayload(
+            actual_instance=IRapidPayloadComparePayload(
+                _t="ComparePayload", criteria=instruction
+            )
+        )
+        model_truth = IValidationTruth(
+            actual_instance=IValidationTruthCompareTruth(
+                _t="CompareTruth", winnerId=truth
+            )
+        )
+
+        if data_type == "media":
+            asset_input = self._asset_uploader.get_uploaded_asset_input(datapoint)
+        else:
+            asset_input = self._asset_uploader.get_uploaded_text_input(datapoint)
+
+        if len(datapoint) != 2:
+            raise ValueError("Compare rapid requires exactly two media paths")
+
+        self._openapi_service.audience_api.audience_audience_id_rapid_post(
+            audience_id=self._audience_id,
+            add_rapid_to_audience_model=AddRapidToAudienceModel(
+                asset=asset_input,
+                payload=payload,
+                truth=model_truth,
+                context=context,
+                contextAsset=(
+                    self._asset_uploader.get_uploaded_asset_input(media_context)
+                    if media_context
+                    else None
+                ),
+                explanation=explanation,
+                randomCorrectProbability=0.5,
+            ),
+        )
+
+    def __str__(self) -> str:
+        return "RapidsManager"
+
+    def __repr__(self) -> str:
+        return self.__str__()