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

orca_sdk/memoryset_test.py

@@ -5,7 +5,7 @@ import pytest
 from datasets.arrow_dataset import Dataset
 
 from .classification_model import ClassificationModel
-from .conftest import skip_in_prod
+from .conftest import skip_in_ci, skip_in_prod
 from .datasource import Datasource
 from .embedding_model import PretrainedEmbeddingModel
 from .memoryset import LabeledMemoryset, ScoredMemory, ScoredMemoryset, Status
@@ -39,9 +39,10 @@ def test_create_memoryset(readonly_memoryset: LabeledMemoryset, hf_dataset: Data
     assert readonly_memoryset.index_params == {"n_lists": 100}
 
 
-def test_create_memoryset_unauthenticated(unauthenticated, datasource):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.create("test_memoryset", datasource)
+def test_create_memoryset_unauthenticated(unauthenticated_client, datasource):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            LabeledMemoryset.create("test_memoryset", datasource)
 
 
 def test_create_memoryset_invalid_input(datasource):
@@ -87,6 +88,30 @@ def test_create_memoryset_already_exists_open(hf_dataset, label_names, readonly_
     assert opened_memoryset.length == len(hf_dataset)
 
 
+def test_if_exists_error_no_datasource_creation(
+    readonly_memoryset: LabeledMemoryset,
+):
+    memoryset_name = readonly_memoryset.name
+    datasource_name = f"{memoryset_name}_datasource"
+    Datasource.drop(datasource_name, if_not_exists="ignore")
+    assert not Datasource.exists(datasource_name)
+    with pytest.raises(ValueError):
+        LabeledMemoryset.from_list(memoryset_name, [{"value": "new value", "label": 0}], if_exists="error")
+    assert not Datasource.exists(datasource_name)
+
+
+def test_if_exists_open_reuses_existing_datasource(
+    readonly_memoryset: LabeledMemoryset,
+):
+    memoryset_name = readonly_memoryset.name
+    datasource_name = f"{memoryset_name}_datasource"
+    Datasource.drop(datasource_name, if_not_exists="ignore")
+    assert not Datasource.exists(datasource_name)
+    reopened = LabeledMemoryset.from_list(memoryset_name, [{"value": "new value", "label": 0}], if_exists="open")
+    assert reopened.id == readonly_memoryset.id
+    assert not Datasource.exists(datasource_name)
+
+
 def test_open_memoryset(readonly_memoryset, hf_dataset):
     fetched_memoryset = LabeledMemoryset.open(readonly_memoryset.name)
     assert fetched_memoryset is not None
@@ -96,9 +121,10 @@ def test_open_memoryset(readonly_memoryset, hf_dataset):
     assert fetched_memoryset.index_params == {"n_lists": 100}
 
 
-def test_open_memoryset_unauthenticated(unauthenticated, readonly_memoryset):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.open(readonly_memoryset.name)
+def test_open_memoryset_unauthenticated(unauthenticated_client, readonly_memoryset):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            LabeledMemoryset.open(readonly_memoryset.name)
 
 
 def test_open_memoryset_not_found():
@@ -111,9 +137,10 @@ def test_open_memoryset_invalid_input():
         LabeledMemoryset.open("not valid id")
 
 
-def test_open_memoryset_unauthorized(unauthorized, readonly_memoryset):
-    with pytest.raises(LookupError):
-        LabeledMemoryset.open(readonly_memoryset.name)
+def test_open_memoryset_unauthorized(unauthorized_client, readonly_memoryset):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            LabeledMemoryset.open(readonly_memoryset.name)
 
 
 def test_all_memorysets(readonly_memoryset: LabeledMemoryset):
@@ -142,18 +169,21 @@ def test_all_memorysets_hidden(
     assert hidden_memoryset in all_memorysets
 
 
-def test_all_memorysets_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.all()
+def test_all_memorysets_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            LabeledMemoryset.all()
 
 
-def test_all_memorysets_unauthorized(unauthorized, readonly_memoryset):
-    assert readonly_memoryset not in LabeledMemoryset.all()
+def test_all_memorysets_unauthorized(unauthorized_client, readonly_memoryset):
+    with unauthorized_client.use():
+        assert readonly_memoryset not in LabeledMemoryset.all()
 
 
-def test_drop_memoryset_unauthenticated(unauthenticated, readonly_memoryset):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.drop(readonly_memoryset.name)
+def test_drop_memoryset_unauthenticated(unauthenticated_client, readonly_memoryset):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            LabeledMemoryset.drop(readonly_memoryset.name)
 
 
 def test_drop_memoryset_not_found():
@@ -163,9 +193,10 @@ def test_drop_memoryset_not_found():
     LabeledMemoryset.drop(str(uuid4()), if_not_exists="ignore")
 
 
-def test_drop_memoryset_unauthorized(unauthorized, readonly_memoryset):
-    with pytest.raises(LookupError):
-        LabeledMemoryset.drop(readonly_memoryset.name)
+def test_drop_memoryset_unauthorized(unauthorized_client, readonly_memoryset):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            LabeledMemoryset.drop(readonly_memoryset.name)
 
 
 def test_update_memoryset_attributes(writable_memoryset: LabeledMemoryset):
@@ -327,6 +358,7 @@ def test_insert_memories(writable_memoryset: LabeledMemoryset):
 
 
 @skip_in_prod("Production memorysets do not have session consistency guarantees")
+@skip_in_ci("CI environment may not have session consistency guarantees")
 def test_update_memories(writable_memoryset: LabeledMemoryset, hf_dataset: Dataset):
     # We've combined the update tests into one to avoid multiple expensive requests for a writable_memoryset
 
@@ -385,17 +417,6 @@ def test_clone_memoryset(readonly_memoryset: LabeledMemoryset):
     assert cloned_memoryset.insertion_status == Status.COMPLETED
 
 
-def test_embedding_evaluation(eval_datasource: Datasource):
-    results = LabeledMemoryset.run_embedding_evaluation(
-        eval_datasource, embedding_models=["CDE_SMALL"], neighbor_count=3
-    )
-    assert isinstance(results, list)
-    assert len(results) == 1
-    assert results[0] is not None
-    assert results[0]["embedding_model_name"] == "CDE_SMALL"
-    assert results[0]["embedding_model_path"] == "OrcaDB/cde-small-v1"
-
-
 @pytest.fixture(scope="function")
 async def test_group_potential_duplicates(writable_memoryset: LabeledMemoryset):
     writable_memoryset.insert(
@@ -508,3 +529,80 @@ def test_update_scored_memory(scored_memoryset: ScoredMemoryset):
     assert scored_memoryset[0].label == 3
     memory.update(label=4)
     assert scored_memoryset[0].label == 4
+
+
+@pytest.mark.asyncio
+async def test_insert_memories_async_single(writable_memoryset: LabeledMemoryset):
+    """Test async insertion of a single memory"""
+    await writable_memoryset.arefresh()
+    prev_length = writable_memoryset.length
+
+    await writable_memoryset.ainsert(dict(value="async tomato soup is my favorite", label=0, key="async_test"))
+
+    await writable_memoryset.arefresh()
+    assert writable_memoryset.length == prev_length + 1
+    last_memory = writable_memoryset[-1]
+    assert last_memory.value == "async tomato soup is my favorite"
+    assert last_memory.label == 0
+    assert last_memory.metadata["key"] == "async_test"
+
+
+@pytest.mark.asyncio
+async def test_insert_memories_async_batch(writable_memoryset: LabeledMemoryset):
+    """Test async insertion of multiple memories"""
+    await writable_memoryset.arefresh()
+    prev_length = writable_memoryset.length
+
+    await writable_memoryset.ainsert(
+        [
+            dict(value="async batch soup is delicious", label=0, key="batch_test_1"),
+            dict(value="async batch cats are adorable", label=1, key="batch_test_2"),
+        ]
+    )
+
+    await writable_memoryset.arefresh()
+    assert writable_memoryset.length == prev_length + 2
+
+    # Check the inserted memories
+    last_two_memories = writable_memoryset[-2:]
+    values = [memory.value for memory in last_two_memories]
+    labels = [memory.label for memory in last_two_memories]
+    keys = [memory.metadata.get("key") for memory in last_two_memories]
+
+    assert "async batch soup is delicious" in values
+    assert "async batch cats are adorable" in values
+    assert 0 in labels
+    assert 1 in labels
+    assert "batch_test_1" in keys
+    assert "batch_test_2" in keys
+
+
+@pytest.mark.asyncio
+async def test_insert_memories_async_with_source_id(writable_memoryset: LabeledMemoryset):
+    """Test async insertion with source_id and metadata"""
+    await writable_memoryset.arefresh()
+    prev_length = writable_memoryset.length
+
+    await writable_memoryset.ainsert(
+        dict(
+            value="async soup with source id", label=0, source_id="async_source_123", custom_field="async_custom_value"
+        )
+    )
+
+    await writable_memoryset.arefresh()
+    assert writable_memoryset.length == prev_length + 1
+    last_memory = writable_memoryset[-1]
+    assert last_memory.value == "async soup with source id"
+    assert last_memory.label == 0
+    assert last_memory.source_id == "async_source_123"
+    assert last_memory.metadata["custom_field"] == "async_custom_value"
+
+
+@pytest.mark.asyncio
+async def test_insert_memories_async_unauthenticated(
+    unauthenticated_async_client, writable_memoryset: LabeledMemoryset
+):
+    """Test async insertion with invalid authentication"""
+    with unauthenticated_async_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            await writable_memoryset.ainsert(dict(value="this should fail", label=0))

orca_sdk/regression_model.py

@@ -10,10 +10,10 @@ from datasets import Dataset
 from ._shared.metrics import RegressionMetrics, calculate_regression_metrics
 from ._utils.common import UNSET, CreateMode, DropMode
 from .client import (
+    OrcaClient,
     PredictiveModelUpdate,
     RARHeadType,
     RegressionModelMetadata,
-    orca_api,
 )
 from .datasource import Datasource
 from .job import Job
@@ -154,7 +154,8 @@ class RegressionModel:
 
                 return existing
 
-        metadata = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        metadata = client.POST(
             "/regression_model",
             json={
                 "name": name,
@@ -179,7 +180,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 +208,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 +228,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 +265,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:
@@ -334,7 +339,8 @@ class RegressionModel:
             raise ValueError("timeout_seconds must be a positive integer")
 
         telemetry_on, telemetry_sync = _get_telemetry_config(save_telemetry)
-        response = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        response = client.POST(
             "/gpu/regression_model/{name_or_id}/prediction",
             params={"name_or_id": self.id},
             json={
@@ -409,7 +415,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,
@@ -446,7 +453,8 @@ class RegressionModel:
         tags: set[str] | None,
         background: 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={
@@ -460,7 +468,8 @@ class RegressionModel:
         )
 
         def get_value():
-            res = orca_api.GET(
+            client = OrcaClient._resolve_client()
+            res = client.GET(
                 "/regression_model/{model_name_or_id}/evaluation/{task_id}",
                 params={"model_name_or_id": self.id, "task_id": response["task_id"]},
             )
@@ -676,7 +685,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

@@ -11,11 +11,11 @@ from httpx import Timeout
 from ._utils.common import UNSET
 from .client import (
     LabelPredictionWithMemoriesAndFeedback,
+    OrcaClient,
     PredictionFeedbackCategory,
     PredictionFeedbackRequest,
     ScorePredictionWithMemoriesAndFeedback,
     UpdatePredictionRequest,
-    orca_api,
 )
 from .memoryset import (
     LabeledMemoryLookup,
@@ -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):
@@ -190,7 +192,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
@@ -229,7 +232,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 +251,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),
@@ -341,14 +346,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 +380,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 +438,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 +462,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)],
         )
@@ -571,7 +580,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 +621,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,

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

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

orca_sdk-0.1.3.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=HK52VxltotpDdq-aTgsCHQPsDAYzOSZDxdlbOnal99c,125459
+orca_sdk/classification_model.py,sha256=WJM6oLBuGrxleTWakc-ZgSRfNyiZxb6-GIMH-S7k12w,39700
+orca_sdk/classification_model_test.py,sha256=_gaDg8QB0h0ByN4UwTk2fIIDXE4UzahuJBjz7NSPK28,23605
+orca_sdk/client.py,sha256=dcGBnzIwaU74CMzUh1ObKJbVmZekF5n57gQY6YcQwHE,124550
+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=DJt1Hr8iwaTFbtFD1aqbUPytpmjPr39qISeqSumoraM,20668
+orca_sdk/datasource_test.py,sha256=yBR0NbsAzChV97pSOU0IvlfF5_WbMe49wZeWNXxwNl4,12128
+orca_sdk/embedding_model.py,sha256=IQCpGUUlKHtz33Ld1-Ag8eLMk72qT7K-cHDjBJGJqhQ,27689
+orca_sdk/embedding_model_test.py,sha256=-NItbNb3tTVj5jAvSi3WjV3FP448q08lmT5iObg9vwA,8133
+orca_sdk/job.py,sha256=BOHg9ksVcN26VtAmuA2cNjGed_Gsx2zbdCO6FBZjuqI,13119
+orca_sdk/job_test.py,sha256=nRSWxd_1UIfrj9oMVvrXjt6OBkBpddYAjb2y6P-DTUg,4327
+orca_sdk/memoryset.py,sha256=angGB6OUJRDoBa2xzl4WsYhNsRRj99dEKEaAKUqgxO8,100113
+orca_sdk/memoryset_test.py,sha256=wqoHXP60CBvtsReCunQNUxj6_ZDT67TTTluguQapigs,25368
+orca_sdk/regression_model.py,sha256=kIT2i4XMrTBZXXVqDENoYILLF7Zqa8o2ndhraXHUPbY,26437
+orca_sdk/regression_model_test.py,sha256=slwxbty_vL9d24OCn5xN61eKyri5GS7Jv2YmpEOMTrM,15856
+orca_sdk/telemetry.py,sha256=C0rTudfAV3_t_uADATrl06d7vk-Sgop24FiSSqYhqmc,26209
+orca_sdk/telemetry_test.py,sha256=eT66C5lFdNg-pQdo2I__BP7Tn5fTc9aTkVo9ZhWwhU0,5519
+orca_sdk-0.1.3.dist-info/METADATA,sha256=tbUzJDcZGUOkwPeToA74JXtkJErdpmtx7UtL1mhzm_M,3659
+orca_sdk-0.1.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+orca_sdk-0.1.3.dist-info/RECORD,,