orca-sdk 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

orca_sdk/regression_model.py

@@ -10,10 +10,12 @@ from datasets import Dataset
 from ._shared.metrics import RegressionMetrics, calculate_regression_metrics
 from ._utils.common import UNSET, CreateMode, DropMode
 from .client import (
+    OrcaClient,
+    PostRegressionModelByModelNameOrIdEvaluationParams,
     PredictiveModelUpdate,
     RARHeadType,
+    RegressionEvaluationRequest,
     RegressionModelMetadata,
-    orca_api,
 )
 from .datasource import Datasource
 from .job import Job
@@ -154,7 +156,8 @@ class RegressionModel:
 
                 return existing
 
-        metadata = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        metadata = client.POST(
             "/regression_model",
             json={
                 "name": name,
@@ -179,7 +182,8 @@ class RegressionModel:
         Raises:
             LookupError: If the regression model does not exist
         """
-        return cls(orca_api.GET("/regression_model/{name_or_id}", params={"name_or_id": name}))
+        client = OrcaClient._resolve_client()
+        return cls(client.GET("/regression_model/{name_or_id}", params={"name_or_id": name}))
 
     @classmethod
     def exists(cls, name_or_id: str) -> bool:
@@ -206,7 +210,8 @@ class RegressionModel:
         Returns:
             List of handles to all regression models in the OrcaCloud
         """
-        return [cls(metadata) for metadata in orca_api.GET("/regression_model")]
+        client = OrcaClient._resolve_client()
+        return [cls(metadata) for metadata in client.GET("/regression_model")]
 
     @classmethod
     def drop(cls, name_or_id: str, if_not_exists: DropMode = "error"):
@@ -225,7 +230,8 @@ class RegressionModel:
             LookupError: If the regression model does not exist and if_not_exists is `"error"`
         """
         try:
-            orca_api.DELETE("/regression_model/{name_or_id}", params={"name_or_id": name_or_id})
+            client = OrcaClient._resolve_client()
+            client.DELETE("/regression_model/{name_or_id}", params={"name_or_id": name_or_id})
             logging.info(f"Deleted model {name_or_id}")
         except LookupError:
             if if_not_exists == "error":
@@ -261,7 +267,8 @@ class RegressionModel:
             update["description"] = description
         if locked is not UNSET:
             update["locked"] = locked
-        orca_api.PATCH("/regression_model/{name_or_id}", params={"name_or_id": self.id}, json=update)
+        client = OrcaClient._resolve_client()
+        client.PATCH("/regression_model/{name_or_id}", params={"name_or_id": self.id}, json=update)
         self.refresh()
 
     def lock(self) -> None:
@@ -282,6 +289,8 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        use_gpu: bool = True,
     ) -> RegressionPrediction: ...
 
     @overload
@@ -294,6 +303,8 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        use_gpu: bool = True,
     ) -> list[RegressionPrediction]: ...
 
     # TODO: add filter support
@@ -306,6 +317,8 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        use_gpu: bool = True,
     ) -> RegressionPrediction | list[RegressionPrediction]:
         """
         Make predictions using the regression model.
@@ -321,6 +334,9 @@ class RegressionModel:
             prompt: Optional prompt for instruction-tuned embedding models
             use_lookup_cache: Whether to use cached lookup results for faster predictions
             timeout_seconds: Timeout in seconds for the request, defaults to 10 seconds
+            ignore_unlabeled: If True, only use memories with scores during lookup.
+                If False (default), allow memories without scores when necessary.
+            use_gpu: Whether to use GPU for the prediction (defaults to True)
 
         Returns:
             Single RegressionPrediction or list of RegressionPrediction objects
@@ -333,9 +349,15 @@ class RegressionModel:
         if timeout_seconds <= 0:
             raise ValueError("timeout_seconds must be a positive integer")
 
+        if use_gpu:
+            endpoint = "/gpu/regression_model/{name_or_id}/prediction"
+        else:
+            endpoint = "/regression_model/{name_or_id}/prediction"
+
         telemetry_on, telemetry_sync = _get_telemetry_config(save_telemetry)
-        response = orca_api.POST(
-            "/gpu/regression_model/{name_or_id}/prediction",
+        client = OrcaClient._resolve_client()
+        response = client.POST(
+            endpoint,
             params={"name_or_id": self.id},
             json={
                 "input_values": value if isinstance(value, list) else [value],
@@ -350,6 +372,7 @@ class RegressionModel:
                 "save_telemetry_synchronously": telemetry_sync,
                 "prompt": prompt,
                 "use_lookup_cache": use_lookup_cache,
+                "ignore_unlabeled": ignore_unlabeled,
             },
             timeout=timeout_seconds,
         )
@@ -409,7 +432,8 @@ class RegressionModel:
             >>> predictions = model.predictions(sort=[("confidence", "desc")], offset=1, limit=1)
             [RegressionPrediction({score: 4.2, confidence: 0.90, anomaly_score: 0.1, input_value: 'Good service'})]
         """
-        predictions = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        predictions = client.POST(
             "/telemetry/prediction",
             json={
                 "model_id": self.id,
@@ -444,9 +468,12 @@ class RegressionModel:
         score_column: str,
         record_predictions: bool,
         tags: set[str] | None,
+        subsample: int | float | None,
         background: bool = False,
+        ignore_unlabeled: bool = False,
     ) -> RegressionMetrics | Job[RegressionMetrics]:
-        response = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        response = client.POST(
             "/regression_model/{model_name_or_id}/evaluation",
             params={"model_name_or_id": self.id},
             json={
@@ -456,13 +483,16 @@ class RegressionModel:
                 "memoryset_override_name_or_id": self._memoryset_override_id,
                 "record_telemetry": record_predictions,
                 "telemetry_tags": list(tags) if tags else None,
+                "subsample": subsample,
+                "ignore_unlabeled": ignore_unlabeled,
             },
         )
 
         def get_value():
-            res = orca_api.GET(
-                "/regression_model/{model_name_or_id}/evaluation/{task_id}",
-                params={"model_name_or_id": self.id, "task_id": response["task_id"]},
+            client = OrcaClient._resolve_client()
+            res = client.GET(
+                "/regression_model/{model_name_or_id}/evaluation/{job_id}",
+                params={"model_name_or_id": self.id, "job_id": response["job_id"]},
             )
             assert res["result"] is not None
             return RegressionMetrics(
@@ -478,7 +508,7 @@ class RegressionModel:
                 anomaly_score_variance=res["result"].get("anomaly_score_variance"),
             )
 
-        job = Job(response["task_id"], get_value)
+        job = Job(response["job_id"], get_value)
         return job if background else job.result()
 
     def _evaluate_dataset(
@@ -490,6 +520,7 @@ class RegressionModel:
         tags: set[str],
         batch_size: int,
         prompt: str | None = None,
+        ignore_unlabeled: bool = False,
     ) -> RegressionMetrics:
         if len(dataset) == 0:
             raise ValueError("Evaluation dataset cannot be empty")
@@ -506,6 +537,7 @@ class RegressionModel:
                 tags=tags,
                 save_telemetry="sync" if record_predictions else "off",
                 prompt=prompt,
+                ignore_unlabeled=ignore_unlabeled,
             )
         ]
 
@@ -526,7 +558,9 @@ class RegressionModel:
         tags: set[str] = {"evaluation"},
         batch_size: int = 100,
         prompt: str | None = None,
+        subsample: int | float | None = None,
         background: Literal[True],
+        ignore_unlabeled: bool = False,
     ) -> Job[RegressionMetrics]:
         pass
 
@@ -541,7 +575,9 @@ class RegressionModel:
         tags: set[str] = {"evaluation"},
         batch_size: int = 100,
         prompt: str | None = None,
+        subsample: int | float | None = None,
         background: Literal[False] = False,
+        ignore_unlabeled: bool = False,
     ) -> RegressionMetrics:
         pass
 
@@ -555,7 +591,9 @@ class RegressionModel:
         tags: set[str] = {"evaluation"},
         batch_size: int = 100,
         prompt: str | None = None,
+        subsample: int | float | None = None,
         background: bool = False,
+        ignore_unlabeled: bool = False,
     ) -> RegressionMetrics | Job[RegressionMetrics]:
         """
         Evaluate the regression model on a given dataset or datasource
@@ -568,7 +606,9 @@ class RegressionModel:
             tags: Optional tags to add to the recorded [`RegressionPrediction`][orca_sdk.telemetry.RegressionPrediction]s
             batch_size: Batch size for processing Dataset inputs (only used when input is a Dataset)
             prompt: Optional prompt for instruction-tuned embedding models
+            subsample: Optional number (int) of rows to sample or fraction (float in (0, 1]) of data to sample for evaluation.
             background: Whether to run the operation in the background and return a job handle
+            ignore_unlabeled: If True, only use memories with scores during lookup. If False (default), allow memories without scores
 
         Returns:
             RegressionMetrics containing metrics including MAE, MSE, RMSE, R2, and anomaly score statistics
@@ -597,7 +637,9 @@ class RegressionModel:
                 score_column=score_column,
                 record_predictions=record_predictions,
                 tags=tags,
+                subsample=subsample,
                 background=background,
+                ignore_unlabeled=ignore_unlabeled,
             )
         elif isinstance(data, Dataset):
             return self._evaluate_dataset(
@@ -608,6 +650,7 @@ class RegressionModel:
                 tags=tags,
                 batch_size=batch_size,
                 prompt=prompt,
+                ignore_unlabeled=ignore_unlabeled,
             )
         else:
             raise ValueError(f"Invalid data type: {type(data)}")
@@ -676,7 +719,8 @@ class RegressionModel:
             ValueError: If the value does not match previous value types for the category, or is a
                 [`float`][float] that is not between `-1.0` and `+1.0`.
         """
-        orca_api.PUT(
+        client = OrcaClient._resolve_client()
+        client.PUT(
             "/telemetry/prediction/feedback",
             json=[
                 _parse_feedback(f) for f in (cast(list[dict], [feedback]) if isinstance(feedback, dict) else feedback)

orca_sdk/regression_model_test.py

@@ -36,9 +36,10 @@ def test_create_model_already_exists_return(scored_memoryset, regression_model:
     assert new_model.memory_lookup_count == 3
 
 
-def test_create_model_unauthenticated(unauthenticated, scored_memoryset: ScoredMemoryset):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        RegressionModel.create("test_regression_model", scored_memoryset)
+def test_create_model_unauthenticated(unauthenticated_client, scored_memoryset: ScoredMemoryset):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            RegressionModel.create("test_regression_model", scored_memoryset)
 
 
 def test_get_model(regression_model: RegressionModel):
@@ -50,9 +51,10 @@ def test_get_model(regression_model: RegressionModel):
     assert fetched_model == regression_model
 
 
-def test_get_model_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        RegressionModel.open("test_regression_model")
+def test_get_model_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            RegressionModel.open("test_regression_model")
 
 
 def test_get_model_invalid_input():
@@ -65,9 +67,10 @@ def test_get_model_not_found():
         RegressionModel.open(str(uuid4()))
 
 
-def test_get_model_unauthorized(unauthorized, regression_model: RegressionModel):
-    with pytest.raises(LookupError):
-        RegressionModel.open(regression_model.name)
+def test_get_model_unauthorized(unauthorized_client, regression_model: RegressionModel):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            RegressionModel.open(regression_model.name)
 
 
 def test_list_models(regression_model: RegressionModel):
@@ -76,13 +79,15 @@ def test_list_models(regression_model: RegressionModel):
     assert any(model.name == regression_model.name for model in models)
 
 
-def test_list_models_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        RegressionModel.all()
+def test_list_models_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            RegressionModel.all()
 
 
-def test_list_models_unauthorized(unauthorized, regression_model: RegressionModel):
-    assert RegressionModel.all() == []
+def test_list_models_unauthorized(unauthorized_client, regression_model: RegressionModel):
+    with unauthorized_client.use():
+        assert RegressionModel.all() == []
 
 
 def test_update_model_attributes(regression_model: RegressionModel):
@@ -113,9 +118,10 @@ def test_delete_model(scored_memoryset: ScoredMemoryset):
         RegressionModel.open("regression_model_to_delete")
 
 
-def test_delete_model_unauthenticated(unauthenticated, regression_model: RegressionModel):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        RegressionModel.drop(regression_model.name)
+def test_delete_model_unauthenticated(unauthenticated_client, regression_model: RegressionModel):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            RegressionModel.drop(regression_model.name)
 
 
 def test_delete_model_not_found():
@@ -125,9 +131,10 @@ def test_delete_model_not_found():
     RegressionModel.drop(str(uuid4()), if_not_exists="ignore")
 
 
-def test_delete_model_unauthorized(unauthorized, regression_model: RegressionModel):
-    with pytest.raises(LookupError):
-        RegressionModel.drop(regression_model.name)
+def test_delete_model_unauthorized(unauthorized_client, regression_model: RegressionModel):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            RegressionModel.drop(regression_model.name)
 
 
 def test_delete_memoryset_before_model_constraint_violation(hf_dataset):
@@ -204,14 +211,16 @@ def test_regression_prediction_has_no_score(regression_model: RegressionModel):
     assert prediction.score is None
 
 
-def test_predict_unauthenticated(unauthenticated, regression_model: RegressionModel):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        regression_model.predict(["This is excellent!", "This is terrible!"])
+def test_predict_unauthenticated(unauthenticated_client, regression_model: RegressionModel):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            regression_model.predict(["This is excellent!", "This is terrible!"])
 
 
-def test_predict_unauthorized(unauthorized, regression_model: RegressionModel):
-    with pytest.raises(LookupError):
-        regression_model.predict(["This is excellent!", "This is terrible!"])
+def test_predict_unauthorized(unauthorized_client, regression_model: RegressionModel):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            regression_model.predict(["This is excellent!", "This is terrible!"])
 
 
 def test_predict_constraint_violation(scored_memoryset: ScoredMemoryset):

orca_sdk/telemetry.py

@@ -4,28 +4,28 @@ import logging
 import os
 from abc import ABC
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Iterable, Literal, Self, overload
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Self, cast, overload
 
 from httpx import Timeout
 
 from ._utils.common import UNSET
 from .client import (
     LabelPredictionWithMemoriesAndFeedback,
+    OrcaClient,
     PredictionFeedbackCategory,
     PredictionFeedbackRequest,
     ScorePredictionWithMemoriesAndFeedback,
     UpdatePredictionRequest,
-    orca_api,
-)
-from .memoryset import (
-    LabeledMemoryLookup,
-    LabeledMemoryset,
-    ScoredMemoryLookup,
-    ScoredMemoryset,
 )
 
 if TYPE_CHECKING:
     from .classification_model import ClassificationModel
+    from .memoryset import (
+        LabeledMemoryLookup,
+        LabeledMemoryset,
+        ScoredMemoryLookup,
+        ScoredMemoryset,
+    )
     from .regression_model import RegressionModel
 
 TelemetryMode = Literal["off", "on", "sync", "async"]
@@ -98,7 +98,8 @@ class FeedbackCategory:
         Returns:
             List with information about all existing feedback categories.
         """
-        return [FeedbackCategory(category) for category in orca_api.GET("/telemetry/feedback_category")]
+        client = OrcaClient._resolve_client()
+        return [FeedbackCategory(category) for category in client.GET("/telemetry/feedback_category")]
 
     @classmethod
     def drop(cls, name: str) -> None:
@@ -115,7 +116,8 @@ class FeedbackCategory:
         Raises:
             LookupError: If the category is not found.
         """
-        orca_api.DELETE("/telemetry/feedback_category/{name_or_id}", params={"name_or_id": name})
+        client = OrcaClient._resolve_client()
+        client.DELETE("/telemetry/feedback_category/{name_or_id}", params={"name_or_id": name})
         logging.info(f"Deleted feedback category {name} with all associated feedback")
 
     def __repr__(self):
@@ -145,6 +147,8 @@ class AddMemorySuggestions:
         )
 
     def apply(self) -> None:
+        from .memoryset import LabeledMemoryset
+
         memoryset = LabeledMemoryset.open(self.memoryset_id)
         label_name_to_label = {label_name: label for label, label_name in enumerate(memoryset.label_names)}
         memoryset.insert(
@@ -190,7 +194,8 @@ class PredictionBase(ABC):
         if self.__telemetry is None:
             if self.prediction_id is None:
                 raise ValueError("Cannot fetch telemetry with no prediction ID")
-            self.__telemetry = orca_api.GET(
+            client = OrcaClient._resolve_client()
+            self.__telemetry = client.GET(
                 "/telemetry/prediction/{prediction_id}", params={"prediction_id": self.prediction_id}
             )
         return self.__telemetry
@@ -204,6 +209,8 @@ class PredictionBase(ABC):
 
     @property
     def memory_lookups(self) -> list[LabeledMemoryLookup] | list[ScoredMemoryLookup]:
+        from .memoryset import LabeledMemoryLookup, ScoredMemoryLookup
+
         if "label" in self._telemetry:
             return [
                 LabeledMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]
@@ -215,12 +222,42 @@ class PredictionBase(ABC):
 
     @property
     def feedback(self) -> dict[str, bool | float]:
-        return {
-            f["category_name"]: (
-                f["value"] if f["category_type"] == "CONTINUOUS" else True if f["value"] == 1 else False
-            )
-            for f in self._telemetry["feedbacks"]
-        }
+        feedbacks = self._telemetry.get("feedbacks", [])
+        if not feedbacks:
+            return {}
+
+        feedback_by_category: dict[str, bool | float] = {}
+        seen_categories: set[str] = set()
+        total_categories = len(set(f["category_name"] for f in feedbacks))
+
+        for f in feedbacks:
+            category_name = f["category_name"]
+            if category_name not in seen_categories:
+                # Convert BINARY (1/0) to boolean, CONTINUOUS to float
+                value = f["value"]
+                if f["category_type"] == "BINARY":
+                    value = bool(value)
+                else:
+                    value = float(value)
+                feedback_by_category[category_name] = value
+                seen_categories.add(category_name)
+
+                # Early exit once we've found the most recent value for all categories
+                if len(seen_categories) == total_categories:
+                    break
+
+        return feedback_by_category
+
+    @property
+    def is_correct(self) -> bool:
+        if "label" in self._telemetry:
+            expected_label = self._telemetry.get("expected_label")
+            label = self._telemetry.get("label")
+            return expected_label is not None and label is not None and label == expected_label
+        else:
+            expected_score = self._telemetry.get("expected_score")
+            score = self._telemetry.get("score")
+            return expected_score is not None and score is not None and abs(score - expected_score) < 0.001
 
     @property
     def tags(self) -> set[str]:
@@ -229,7 +266,8 @@ class PredictionBase(ABC):
     @property
     def explanation(self) -> str:
         if self._telemetry["explanation"] is None:
-            self._telemetry["explanation"] = orca_api.GET(
+            client = OrcaClient._resolve_client()
+            self._telemetry["explanation"] = client.GET(
                 "/telemetry/prediction/{prediction_id}/explanation",
                 params={"prediction_id": self._telemetry["prediction_id"]},
                 parse_as="text",
@@ -247,7 +285,8 @@ class PredictionBase(ABC):
         if not refresh and self._telemetry["explanation"] is not None:
             print(self._telemetry["explanation"])
         else:
-            with orca_api.stream(
+            client = OrcaClient._resolve_client()
+            with client.stream(
                 "GET",
                 f"/telemetry/prediction/{self.prediction_id}/explanation?refresh={refresh}",
                 timeout=Timeout(connect=3, read=None),
@@ -321,6 +360,7 @@ class PredictionBase(ABC):
         def create_prediction(
             prediction: LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback,
         ) -> Self:
+            from .memoryset import LabeledMemoryset, ScoredMemoryset
 
             if "label" in prediction:
                 memoryset = LabeledMemoryset.open(prediction["memoryset_id"])
@@ -341,14 +381,15 @@ class PredictionBase(ABC):
                 telemetry=prediction,
             )
 
+        client = OrcaClient._resolve_client()
         if isinstance(prediction_id, str):
             return create_prediction(
-                orca_api.GET("/telemetry/prediction/{prediction_id}", params={"prediction_id": prediction_id})
+                client.GET("/telemetry/prediction/{prediction_id}", params={"prediction_id": prediction_id})
             )
         else:
             return [
                 create_prediction(prediction)
-                for prediction in orca_api.POST("/telemetry/prediction", json={"prediction_ids": list(prediction_id)})
+                for prediction in client.POST("/telemetry/prediction", json={"prediction_ids": list(prediction_id)})
             ]
 
     def refresh(self):
@@ -374,7 +415,8 @@ class PredictionBase(ABC):
             payload["expected_label"] = expected_label
         if expected_score is not UNSET:
             payload["expected_score"] = expected_score
-        orca_api.PATCH(
+        client = OrcaClient._resolve_client()
+        client.PATCH(
             "/telemetry/prediction/{prediction_id}", params={"prediction_id": self.prediction_id}, json=payload
         )
         self.refresh()
@@ -431,7 +473,8 @@ class PredictionBase(ABC):
             ValueError: If the value does not match previous value types for the category, or is a
                 [`float`][float] that is not between `-1.0` and `+1.0`.
         """
-        orca_api.PUT(
+        client = OrcaClient._resolve_client()
+        client.PUT(
             "/telemetry/prediction/feedback",
             json=[
                 _parse_feedback(
@@ -454,7 +497,8 @@ class PredictionBase(ABC):
         if self.prediction_id is None:
             raise ValueError("Cannot delete feedback with no prediction ID")
 
-        orca_api.PUT(
+        client = OrcaClient._resolve_client()
+        client.PUT(
             "/telemetry/prediction/feedback",
             json=[PredictionFeedbackRequest(prediction_id=self.prediction_id, category_name=category, value=None)],
         )
@@ -511,6 +555,8 @@ class ClassificationPrediction(PredictionBase):
 
     @property
     def memory_lookups(self) -> list[LabeledMemoryLookup]:
+        from .memoryset import LabeledMemoryLookup
+
         assert "label" in self._telemetry
         return [LabeledMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]]
 
@@ -571,7 +617,8 @@ class ClassificationPrediction(PredictionBase):
         if self.prediction_id is None:
             raise ValueError("Cannot get action recommendation with no prediction ID")
 
-        response = orca_api.GET(
+        client = OrcaClient._resolve_client()
+        response = client.GET(
             "/telemetry/prediction/{prediction_id}/action",
             params={"prediction_id": self.prediction_id},
             timeout=30,
@@ -611,7 +658,8 @@ class ClassificationPrediction(PredictionBase):
         if self.prediction_id is None:
             raise ValueError("Cannot generate memory suggestions with no prediction ID")
 
-        response = orca_api.GET(
+        client = OrcaClient._resolve_client()
+        response = client.GET(
             "/telemetry/prediction/{prediction_id}/memory_suggestions",
             params={"prediction_id": self.prediction_id, "num_memories": num_memories},
             timeout=30,
@@ -660,6 +708,8 @@ class RegressionPrediction(PredictionBase):
 
     @property
     def memory_lookups(self) -> list[ScoredMemoryLookup]:
+        from .memoryset import ScoredMemoryLookup
+
         assert "score" in self._telemetry
         return [ScoredMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]]
 

{orca_sdk-0.1.2.dist-info → orca_sdk-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca_sdk
-Version: 0.1.2
+Version: 0.1.4
 Summary: SDK for interacting with Orca Services
 License-Expression: Apache-2.0
 Author: Orca DB Inc.

orca_sdk-0.1.4.dist-info/RECORD

@@ -0,0 +1,41 @@
+orca_sdk/__init__.py,sha256=xyjNwkLQXaX8A-UYgGwYDjv2btOXArT_yiMTfmW7KA8,1003
+orca_sdk/_shared/__init__.py,sha256=3Kt0Hu3QLI5FEp9nqGTxqAm3hAoBJKcagfaGQZ-lbJQ,223
+orca_sdk/_shared/metrics.py,sha256=LEZfAUWUtUWv_WWy9F_yjGLlUQHQpmR9WxG2fbKxa7U,14419
+orca_sdk/_shared/metrics_test.py,sha256=Rw1MaH37FppNsMnW8Ir9vMd8xxnZt3eo2Iypx1igtBI,9440
+orca_sdk/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orca_sdk/_utils/analysis_ui.py,sha256=nT-M_YcNRCVPQzvuqYNFKnNHhYkADYBvq1GlIUePrWw,9232
+orca_sdk/_utils/analysis_ui_style.css,sha256=q_ba_-_KtgztepHg829zLzypaxKayl7ySC1-oYDzV3k,836
+orca_sdk/_utils/auth.py,sha256=nC252O171_3_wn4KBAN7kg8GNvoZFiQ5Xtzkrm5dWDo,2645
+orca_sdk/_utils/auth_test.py,sha256=ygVWv1Ex53LaxIP7p2hzPHl8l9qYyBD5IGmEFJMps6s,1056
+orca_sdk/_utils/common.py,sha256=wUm2pNDWytEecC5WiDWd02-yCZw3Akx0bIutG4lHsFA,805
+orca_sdk/_utils/data_parsing.py,sha256=gkAwWEC8qRt3vRUObe7n7Pr0azOayNwc2yFY04WFp7E,5220
+orca_sdk/_utils/data_parsing_test.py,sha256=fNEYzPzE1jt3KWE2Kj91KqIeuv-L5REHFAa98zkNGSQ,8962
+orca_sdk/_utils/pagination.py,sha256=986z0QPZixrZeurJWorF6eMgnTRdDF84AagEA6qNbMw,4245
+orca_sdk/_utils/pagination_test.py,sha256=BUylCrcHnwoKEBmMUzVr0lwLpA35ivcCwdBK4rMw9y8,4887
+orca_sdk/_utils/prediction_result_ui.css,sha256=sqBlkRLnovb5X5EcUDdB6iGpH63nVRlTW4uAmXuD0WM,258
+orca_sdk/_utils/prediction_result_ui.py,sha256=Ur_FY7dz3oWNmtPiP3Wl3yRlEMgK8q9UfT-SDu9UPxA,4805
+orca_sdk/_utils/tqdm_file_reader.py,sha256=Lw7Cg1UgNuRUoN6jjqZb-IlV00H-kbRcrZLdudr1GxE,324
+orca_sdk/_utils/value_parser.py,sha256=c3qMABCCDQcIjn9N1orYYnlRwDW9JWdGwW_2TDZPLdI,1286
+orca_sdk/_utils/value_parser_test.py,sha256=OybsiC-Obi32RRi9NIuwrVBRAnlyPMV1xVAaevSrb7M,1079
+orca_sdk/async_client.py,sha256=mBd8z5xuHpE8-7Zd0D7YjH2e1OHSO-sRm2tSddqsc9Q,130387
+orca_sdk/classification_model.py,sha256=iYUrGjeYHvPvXwYXjXU_LGL7Dn2XxUcGCt6w93DlJO8,41702
+orca_sdk/classification_model_test.py,sha256=_gaDg8QB0h0ByN4UwTk2fIIDXE4UzahuJBjz7NSPK28,23605
+orca_sdk/client.py,sha256=voNo4NPsc-rsZQ3lZO2fsFuFLw4DC4Dl9REVJQEyKhY,129454
+orca_sdk/conftest.py,sha256=RtINF1xea2iMycMkpMXIOOqRbfWeIZsceSAemhBmgNE,9761
+orca_sdk/credentials.py,sha256=80_1r8n5jruEvN_E629SaRrRhKvF_NhWUEZyZzPXkqQ,6620
+orca_sdk/credentials_test.py,sha256=TLbXJMz3IlThvtSrHeLM7jRsKnrncA_ahOTpHg15Ei4,4089
+orca_sdk/datasource.py,sha256=6QaccghiyFEUSFcqnwjIJzpgIh9Id0snJk2EqViqPsU,22356
+orca_sdk/datasource_test.py,sha256=sCk3IcQJbDut5oN4Wf7PXhTxyMwalxMuCXJekSxy9wk,16665
+orca_sdk/embedding_model.py,sha256=bZhbNJBimWc9Ryklza3q9HS0MRWsiH5Lhn6p7pff0RI,28165
+orca_sdk/embedding_model_test.py,sha256=-NItbNb3tTVj5jAvSi3WjV3FP448q08lmT5iObg9vwA,8133
+orca_sdk/job.py,sha256=wHwVt-s7i-v8udhLGybB-90Kp4dwOLrY806bE4Tam5Q,13092
+orca_sdk/job_test.py,sha256=nRSWxd_1UIfrj9oMVvrXjt6OBkBpddYAjb2y6P-DTUg,4327
+orca_sdk/memoryset.py,sha256=QSnHA2SpAJkGdpVd8wQX2weAhLu9Iw-lfpeQvJxLedg,111690
+orca_sdk/memoryset_test.py,sha256=7wGOtbVa3MEu91fN8DTjiYgB6QIObuA3cTchHmddTIk,33551
+orca_sdk/regression_model.py,sha256=GIL-KgKtGzdb5dFraOKu6OD8yrcavc-CeXASPsKGLGM,28086
+orca_sdk/regression_model_test.py,sha256=slwxbty_vL9d24OCn5xN61eKyri5GS7Jv2YmpEOMTrM,15856
+orca_sdk/telemetry.py,sha256=ZyCMiyyo_SchjadWZH55TlLrC4Ucq5S316NbW26LL4Y,27834
+orca_sdk/telemetry_test.py,sha256=eT66C5lFdNg-pQdo2I__BP7Tn5fTc9aTkVo9ZhWwhU0,5519
+orca_sdk-0.1.4.dist-info/METADATA,sha256=AQBTSp780409HcaGN9ozHCYUCElgNqP30XP8u4fyBiw,3659
+orca_sdk-0.1.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+orca_sdk-0.1.4.dist-info/RECORD,,