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

orca_sdk/regression_model.py

@@ -11,9 +11,12 @@ from ._shared.metrics import RegressionMetrics, calculate_regression_metrics
 from ._utils.common import UNSET, CreateMode, DropMode
 from .client import (
     OrcaClient,
+    PostRegressionModelByModelNameOrIdEvaluationParams,
     PredictiveModelUpdate,
     RARHeadType,
+    RegressionEvaluationRequest,
     RegressionModelMetadata,
+    RegressionPredictionRequest,
 )
 from .datasource import Datasource
 from .job import Job
@@ -287,6 +290,12 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        partition_id: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
+        use_gpu: bool = True,
     ) -> RegressionPrediction: ...
 
     @overload
@@ -299,6 +308,12 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        partition_id: str | list[str | None] | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
+        use_gpu: bool = True,
     ) -> list[RegressionPrediction]: ...
 
     # TODO: add filter support
@@ -311,6 +326,12 @@ class RegressionModel:
         prompt: str | None = None,
         use_lookup_cache: bool = True,
         timeout_seconds: int = 10,
+        ignore_unlabeled: bool = False,
+        partition_id: str | list[str | None] | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
+        use_gpu: bool = True,
     ) -> RegressionPrediction | list[RegressionPrediction]:
         """
         Make predictions using the regression model.
@@ -326,6 +347,15 @@ 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.
+            partition_id: Optional partition ID(s) to use during memory lookup
+            partition_filter_mode: Optional partition filter mode to use for the prediction(s). One of
+                * `"ignore_partitions"`: Ignore partitions
+                * `"include_global"`: Include global memories
+                * `"exclude_global"`: Exclude global memories
+                * `"only_global"`: Only include global memories
+            use_gpu: Whether to use GPU for the prediction (defaults to True)
 
         Returns:
             Single RegressionPrediction or list of RegressionPrediction objects
@@ -338,25 +368,36 @@ 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)
         client = OrcaClient._resolve_client()
+        request_json: RegressionPredictionRequest = {
+            "input_values": value if isinstance(value, list) else [value],
+            "memoryset_override_name_or_id": self._memoryset_override_id,
+            "expected_scores": (
+                expected_scores
+                if isinstance(expected_scores, list)
+                else [expected_scores] if expected_scores is not None else None
+            ),
+            "tags": list(tags or set()),
+            "save_telemetry": telemetry_on,
+            "save_telemetry_synchronously": telemetry_sync,
+            "prompt": prompt,
+            "use_lookup_cache": use_lookup_cache,
+            "ignore_unlabeled": ignore_unlabeled,
+            "partition_filter_mode": partition_filter_mode,
+        }
+        # Don't send partition_ids when partition_filter_mode is "ignore_partitions"
+        if partition_filter_mode != "ignore_partitions":
+            request_json["partition_ids"] = partition_id
         response = client.POST(
-            "/gpu/regression_model/{name_or_id}/prediction",
+            endpoint,
             params={"name_or_id": self.id},
-            json={
-                "input_values": value if isinstance(value, list) else [value],
-                "memoryset_override_name_or_id": self._memoryset_override_id,
-                "expected_scores": (
-                    expected_scores
-                    if isinstance(expected_scores, list)
-                    else [expected_scores] if expected_scores is not None else None
-                ),
-                "tags": list(tags or set()),
-                "save_telemetry": telemetry_on,
-                "save_telemetry_synchronously": telemetry_sync,
-                "prompt": prompt,
-                "use_lookup_cache": use_lookup_cache,
-            },
+            json=request_json,
             timeout=timeout_seconds,
         )
 
@@ -451,7 +492,13 @@ class RegressionModel:
         score_column: str,
         record_predictions: bool,
         tags: set[str] | None,
+        subsample: int | float | None,
         background: bool = False,
+        ignore_unlabeled: bool = False,
+        partition_column: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
     ) -> RegressionMetrics | Job[RegressionMetrics]:
         client = OrcaClient._resolve_client()
         response = client.POST(
@@ -464,14 +511,18 @@ 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,
+                "datasource_partition_column": partition_column,
+                "partition_filter_mode": partition_filter_mode,
             },
         )
 
         def get_value():
             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"]},
+                "/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(
@@ -487,7 +538,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(
@@ -499,6 +550,11 @@ class RegressionModel:
         tags: set[str],
         batch_size: int,
         prompt: str | None = None,
+        ignore_unlabeled: bool = False,
+        partition_column: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
     ) -> RegressionMetrics:
         if len(dataset) == 0:
             raise ValueError("Evaluation dataset cannot be empty")
@@ -515,6 +571,9 @@ class RegressionModel:
                 tags=tags,
                 save_telemetry="sync" if record_predictions else "off",
                 prompt=prompt,
+                ignore_unlabeled=ignore_unlabeled,
+                partition_id=dataset[i : i + batch_size][partition_column] if partition_column else None,
+                partition_filter_mode=partition_filter_mode,
             )
         ]
 
@@ -535,7 +594,13 @@ 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,
+        partition_column: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
     ) -> Job[RegressionMetrics]:
         pass
 
@@ -550,7 +615,13 @@ 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,
+        partition_column: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
     ) -> RegressionMetrics:
         pass
 
@@ -564,7 +635,13 @@ 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,
+        partition_column: str | None = None,
+        partition_filter_mode: Literal[
+            "ignore_partitions", "include_global", "exclude_global", "only_global"
+        ] = "include_global",
     ) -> RegressionMetrics | Job[RegressionMetrics]:
         """
         Evaluate the regression model on a given dataset or datasource
@@ -577,8 +654,15 @@ 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
+            partition_column: Optional name of the column that contains the partition IDs
+            partition_filter_mode: Optional partition filter mode to use for the evaluation. One of
+                * `"ignore_partitions"`: Ignore partitions
+                * `"include_global"`: Include global memories
+                * `"exclude_global"`: Exclude global memories
+                * `"only_global"`: Only include global memories
         Returns:
             RegressionMetrics containing metrics including MAE, MSE, RMSE, R2, and anomaly score statistics
 
@@ -606,7 +690,11 @@ class RegressionModel:
                 score_column=score_column,
                 record_predictions=record_predictions,
                 tags=tags,
+                subsample=subsample,
                 background=background,
+                ignore_unlabeled=ignore_unlabeled,
+                partition_column=partition_column,
+                partition_filter_mode=partition_filter_mode,
             )
         elif isinstance(data, Dataset):
             return self._evaluate_dataset(
@@ -617,6 +705,9 @@ class RegressionModel:
                 tags=tags,
                 batch_size=batch_size,
                 prompt=prompt,
+                ignore_unlabeled=ignore_unlabeled,
+                partition_column=partition_column,
+                partition_filter_mode=partition_filter_mode,
             )
         else:
             raise ValueError(f"Invalid data type: {type(data)}")

orca_sdk/regression_model_test.py

@@ -193,6 +193,140 @@ def test_evaluate_with_telemetry(regression_model, eval_dataset: Dataset):
     assert all(np.allclose(p.expected_score, s) for p, s in zip(predictions, eval_dataset["score"]))
 
 
+def test_evaluate_with_partition_column_dataset(partitioned_regression_model: RegressionModel):
+    """Test evaluate with partition_column on a Dataset"""
+    # Create a test dataset with partition_id column
+    eval_dataset_with_partition = Dataset.from_list(
+        [
+            {"value": "soup is good", "score": 0.1, "partition_id": "p1"},
+            {"value": "cats are cute", "score": 0.9, "partition_id": "p1"},
+            {"value": "homemade soup recipes", "score": 0.1, "partition_id": "p2"},
+            {"value": "cats purr when happy", "score": 0.9, "partition_id": "p2"},
+        ]
+    )
+
+    # Evaluate with partition_column
+    result = partitioned_regression_model.evaluate(
+        eval_dataset_with_partition,
+        partition_column="partition_id",
+        partition_filter_mode="exclude_global",
+    )
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+    assert isinstance(result.mae, float)
+    assert isinstance(result.mse, float)
+    assert isinstance(result.rmse, float)
+    assert result.r2 is not None
+
+
+def test_evaluate_with_partition_column_include_global(partitioned_regression_model: RegressionModel):
+    """Test evaluate with partition_column and include_global mode"""
+    eval_dataset_with_partition = Dataset.from_list(
+        [
+            {"value": "soup is good", "score": 0.1, "partition_id": "p1"},
+            {"value": "cats are cute", "score": 0.9, "partition_id": "p1"},
+        ]
+    )
+
+    # Evaluate with partition_column and include_global (default)
+    result = partitioned_regression_model.evaluate(
+        eval_dataset_with_partition,
+        partition_column="partition_id",
+        partition_filter_mode="include_global",
+    )
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+
+
+def test_evaluate_with_partition_column_exclude_global(partitioned_regression_model: RegressionModel):
+    """Test evaluate with partition_column and exclude_global mode"""
+    eval_dataset_with_partition = Dataset.from_list(
+        [
+            {"value": "soup is good", "score": 0.1, "partition_id": "p1"},
+            {"value": "cats are cute", "score": 0.9, "partition_id": "p1"},
+        ]
+    )
+
+    # Evaluate with partition_column and exclude_global
+    result = partitioned_regression_model.evaluate(
+        eval_dataset_with_partition,
+        partition_column="partition_id",
+        partition_filter_mode="exclude_global",
+    )
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+
+
+def test_evaluate_with_partition_column_only_global(partitioned_regression_model: RegressionModel):
+    """Test evaluate with partition_filter_mode only_global"""
+    eval_dataset_with_partition = Dataset.from_list(
+        [
+            {"value": "cats are independent animals", "score": 0.9, "partition_id": None},
+            {"value": "i love the beach", "score": 0.5, "partition_id": None},
+        ]
+    )
+
+    # Evaluate with only_global mode
+    result = partitioned_regression_model.evaluate(
+        eval_dataset_with_partition,
+        partition_column="partition_id",
+        partition_filter_mode="only_global",
+    )
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+
+
+def test_evaluate_with_partition_column_ignore_partitions(partitioned_regression_model: RegressionModel):
+    """Test evaluate with partition_filter_mode ignore_partitions"""
+    eval_dataset_with_partition = Dataset.from_list(
+        [
+            {"value": "soup is good", "score": 0.1, "partition_id": "p1"},
+            {"value": "cats are cute", "score": 0.9, "partition_id": "p2"},
+        ]
+    )
+
+    # Evaluate with ignore_partitions mode
+    result = partitioned_regression_model.evaluate(
+        eval_dataset_with_partition,
+        partition_column="partition_id",
+        partition_filter_mode="ignore_partitions",
+    )
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+
+
+@pytest.mark.parametrize("data_type", ["dataset", "datasource"])
+def test_evaluate_with_partition_column_datasource(partitioned_regression_model: RegressionModel, data_type):
+    """Test evaluate with partition_column on a Datasource"""
+    # Create a test datasource with partition_id column
+    eval_data_with_partition = [
+        {"value": "soup is good", "score": 0.1, "partition_id": "p1"},
+        {"value": "cats are cute", "score": 0.9, "partition_id": "p1"},
+        {"value": "homemade soup recipes", "score": 0.1, "partition_id": "p2"},
+        {"value": "cats purr when happy", "score": 0.9, "partition_id": "p2"},
+    ]
+
+    if data_type == "dataset":
+        eval_data = Dataset.from_list(eval_data_with_partition)
+        result = partitioned_regression_model.evaluate(
+            eval_data,
+            partition_column="partition_id",
+            partition_filter_mode="exclude_global",
+        )
+    else:
+        eval_datasource = Datasource.from_list("eval_datasource_with_partition_regression", eval_data_with_partition)
+        result = partitioned_regression_model.evaluate(
+            eval_datasource,
+            partition_column="partition_id",
+            partition_filter_mode="exclude_global",
+        )
+
+    assert result is not None
+    assert isinstance(result, RegressionMetrics)
+    assert isinstance(result.mae, float)
+    assert isinstance(result.mse, float)
+
+
 def test_predict(regression_model: RegressionModel):
     predictions = regression_model.predict(["Do you love soup?", "Are cats cute?"])
     assert len(predictions) == 2
@@ -248,6 +382,85 @@ def test_predict_with_prompt(regression_model: RegressionModel):
     assert 0 <= prediction_without_prompt.confidence <= 1
 
 
+def test_predict_with_partition_id(partitioned_regression_model: RegressionModel):
+    """Test predict with a specific partition_id"""
+    # Predict with partition_id p1 - should use memories from p1
+    prediction = partitioned_regression_model.predict("soup", partition_id="p1", partition_filter_mode="exclude_global")
+    assert prediction.score is not None
+    assert 0 <= prediction.confidence <= 1
+
+    # Predict with partition_id p2 - should use memories from p2
+    prediction_p2 = partitioned_regression_model.predict(
+        "cats", partition_id="p2", partition_filter_mode="exclude_global"
+    )
+    assert prediction_p2.score is not None
+    assert 0 <= prediction_p2.confidence <= 1
+
+
+def test_predict_with_partition_id_include_global(partitioned_regression_model: RegressionModel):
+    """Test predict with partition_id and include_global mode (default)"""
+    # Predict with partition_id p1 and include_global (default) - should include both p1 and global memories
+    prediction = partitioned_regression_model.predict("soup", partition_id="p1", partition_filter_mode="include_global")
+    assert prediction.score is not None
+    assert 0 <= prediction.confidence <= 1
+
+
+def test_predict_with_partition_id_exclude_global(partitioned_regression_model: RegressionModel):
+    """Test predict with partition_id and exclude_global mode"""
+    # Predict with partition_id p1 and exclude_global - should only use p1 memories
+    prediction = partitioned_regression_model.predict("soup", partition_id="p1", partition_filter_mode="exclude_global")
+    assert prediction.score is not None
+    assert 0 <= prediction.confidence <= 1
+
+
+def test_predict_with_partition_id_only_global(partitioned_regression_model: RegressionModel):
+    """Test predict with partition_filter_mode only_global"""
+    # Predict with only_global mode - should only use global memories
+    prediction = partitioned_regression_model.predict("cats", partition_filter_mode="only_global")
+    assert prediction.score is not None
+    assert 0 <= prediction.confidence <= 1
+
+
+def test_predict_with_partition_id_ignore_partitions(partitioned_regression_model: RegressionModel):
+    """Test predict with partition_filter_mode ignore_partitions"""
+    # Predict with ignore_partitions mode - should ignore partition filtering
+    prediction = partitioned_regression_model.predict("soup", partition_filter_mode="ignore_partitions")
+    assert prediction.score is not None
+    assert 0 <= prediction.confidence <= 1
+
+
+def test_predict_batch_with_partition_id(partitioned_regression_model: RegressionModel):
+    """Test batch predict with partition_id"""
+    # Batch predict with partition_id p1
+    predictions = partitioned_regression_model.predict(
+        ["soup is good", "cats are cute"],
+        partition_id="p1",
+        partition_filter_mode="exclude_global",
+    )
+    assert len(predictions) == 2
+    assert all(p.score is not None for p in predictions)
+    assert all(0 <= p.confidence <= 1 for p in predictions)
+
+
+def test_predict_batch_with_list_of_partition_ids(partitioned_regression_model: RegressionModel):
+    """Test batch predict with a list of partition_ids (one for each query input)"""
+    # Batch predict with a list of partition_ids - one for each input
+    # First input uses p1, second input uses p2
+    predictions = partitioned_regression_model.predict(
+        ["soup is good", "cats are cute"],
+        partition_id=["p1", "p2"],
+        partition_filter_mode="exclude_global",
+    )
+    assert len(predictions) == 2
+    assert all(p.score is not None for p in predictions)
+    assert all(0 <= p.confidence <= 1 for p in predictions)
+
+    # Verify that predictions were made using the correct partitions
+    # Each prediction should use memories from its respective partition
+    assert predictions[0].input_value == "soup is good"
+    assert predictions[1].input_value == "cats are cute"
+
+
 def test_record_prediction_feedback(regression_model: RegressionModel):
     predictions = regression_model.predict(["This is excellent!", "This is terrible!"])
     expected_scores = [0.9, 0.1]

orca_sdk/telemetry.py

@@ -4,7 +4,7 @@ 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
 
@@ -17,15 +17,15 @@ from .client import (
     ScorePredictionWithMemoriesAndFeedback,
     UpdatePredictionRequest,
 )
-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"]
@@ -147,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(
@@ -207,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"]
@@ -218,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]:
@@ -326,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"])
@@ -520,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"]]
 
@@ -671,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.3.dist-info → orca_sdk-0.1.5.dist-info}/METADATA

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