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

orca_sdk/memoryset_test.py

@@ -9,6 +9,7 @@ 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
+from .regression_model import RegressionModel
 
 """
 Test Performance Note:
@@ -112,6 +113,51 @@ def test_if_exists_open_reuses_existing_datasource(
     assert not Datasource.exists(datasource_name)
 
 
+def test_create_memoryset_string_label():
+    assert not LabeledMemoryset.exists("test_string_label")
+    memoryset = LabeledMemoryset.from_hf_dataset(
+        "test_string_label",
+        Dataset.from_dict({"value": ["terrible", "great"], "label": ["negative", "positive"]}),
+    )
+    assert memoryset is not None
+    assert memoryset.length == 2
+    assert memoryset.label_names == ["negative", "positive"]
+    assert memoryset[0].label == 0
+    assert memoryset[1].label == 1
+    assert memoryset[0].label_name == "negative"
+    assert memoryset[1].label_name == "positive"
+
+
+def test_create_memoryset_integer_label():
+    assert not LabeledMemoryset.exists("test_integer_label")
+    memoryset = LabeledMemoryset.from_hf_dataset(
+        "test_integer_label",
+        Dataset.from_dict({"value": ["terrible", "great"], "label": [0, 1]}),
+        label_names=["negative", "positive"],
+    )
+    assert memoryset is not None
+    assert memoryset.length == 2
+    assert memoryset.label_names == ["negative", "positive"]
+    assert memoryset[0].label == 0
+    assert memoryset[1].label == 1
+    assert memoryset[0].label_name == "negative"
+    assert memoryset[1].label_name == "positive"
+
+
+def test_create_memoryset_null_labels():
+    memoryset = LabeledMemoryset.from_hf_dataset(
+        "test_null_labels",
+        Dataset.from_dict({"value": ["terrible", "great"]}),
+        label_names=["negative", "positive"],
+        label_column=None,
+    )
+    assert memoryset is not None
+    assert memoryset.length == 2
+    assert memoryset.label_names == ["negative", "positive"]
+    assert memoryset[0].label == None
+    assert memoryset[1].label == None
+
+
 def test_open_memoryset(readonly_memoryset, hf_dataset):
     fetched_memoryset = LabeledMemoryset.open(readonly_memoryset.name)
     assert fetched_memoryset is not None
@@ -335,6 +381,143 @@ def test_query_memoryset_with_feedback_metrics_sort(classification_model: Classi
     assert memories[-1].feedback_metrics["positive"]["avg"] == -1.0
 
 
+def test_labeled_memory_predictions_property(classification_model: ClassificationModel):
+    """Test that LabeledMemory.predictions() only returns classification predictions."""
+    # Given: A classification model with memories
+    memories = classification_model.memoryset.query(limit=1)
+    assert len(memories) > 0
+    memory = memories[0]
+
+    # When: I call the predictions method
+    predictions = memory.predictions()
+
+    # Then: It should return a list of ClassificationPrediction objects
+    assert isinstance(predictions, list)
+    for prediction in predictions:
+        assert prediction.__class__.__name__ == "ClassificationPrediction"
+        assert hasattr(prediction, "label")
+        assert not hasattr(prediction, "score") or prediction.score is None
+
+
+def test_scored_memory_predictions_property(regression_model: RegressionModel):
+    """Test that ScoredMemory.predictions() only returns regression predictions."""
+    # Given: A regression model with memories
+    memories = regression_model.memoryset.query(limit=1)
+    assert len(memories) > 0
+    memory = memories[0]
+
+    # When: I call the predictions method
+    predictions = memory.predictions()
+
+    # Then: It should return a list of RegressionPrediction objects
+    assert isinstance(predictions, list)
+    for prediction in predictions:
+        assert prediction.__class__.__name__ == "RegressionPrediction"
+        assert hasattr(prediction, "score")
+        assert not hasattr(prediction, "label") or prediction.label is None
+
+
+def test_memory_feedback_property(classification_model: ClassificationModel):
+    """Test that memory.feedback() returns feedback from relevant predictions."""
+    # Given: A prediction with recorded feedback
+    prediction = classification_model.predict("Test feedback")
+    feedback_category = f"test_feedback_{random.randint(0, 1000000)}"
+    prediction.record_feedback(category=feedback_category, value=True)
+
+    # And: A memory that was used in the prediction
+    memory_lookups = prediction.memory_lookups
+    assert len(memory_lookups) > 0
+    memory = memory_lookups[0]
+
+    # When: I access the feedback property
+    feedback = memory.feedback()
+
+    # Then: It should return feedback aggregated by category as a dict
+    assert isinstance(feedback, dict)
+    assert feedback_category in feedback
+    # Feedback values are lists (you may want to look at mean on the raw data)
+    assert isinstance(feedback[feedback_category], list)
+    assert len(feedback[feedback_category]) > 0
+    # For binary feedback, values should be booleans
+    assert isinstance(feedback[feedback_category][0], bool)
+
+
+def test_memory_predictions_method_parameters(classification_model: ClassificationModel):
+    """Test that memory.predictions() method supports pagination, sorting, and filtering."""
+    # Given: A classification model with memories
+    memories = classification_model.memoryset.query(limit=1)
+    assert len(memories) > 0
+    memory = memories[0]
+
+    # When: I call predictions with limit parameter
+    predictions_limited = memory.predictions(limit=2)
+
+    # Then: It should respect the limit
+    assert isinstance(predictions_limited, list)
+    assert len(predictions_limited) <= 2
+
+    # When: I call predictions with offset parameter
+    all_predictions = memory.predictions(limit=100)
+    if len(all_predictions) > 1:
+        predictions_offset = memory.predictions(limit=1, offset=1)
+        # Then: offset should skip the first prediction
+        assert predictions_offset[0].prediction_id != all_predictions[0].prediction_id
+
+    # When: I call predictions with sort parameter
+    predictions_sorted = memory.predictions(limit=10, sort=[("timestamp", "desc")])
+    # Then: It should return predictions (sorting verified by API)
+    assert isinstance(predictions_sorted, list)
+
+    # When: I call predictions with expected_label_match parameter
+    correct_predictions = memory.predictions(expected_label_match=True)
+    incorrect_predictions = memory.predictions(expected_label_match=False)
+    # Then: Both should return lists (correctness verified by API filtering)
+    assert isinstance(correct_predictions, list)
+    assert isinstance(incorrect_predictions, list)
+
+
+def test_memory_predictions_expected_label_filter(classification_model: ClassificationModel):
+    """Test that memory.predictions(expected_label_match=...) filters predictions by correctness."""
+    # Given: Make an initial prediction to learn the model's label for a known input
+    baseline_prediction = classification_model.predict("Filter test input", save_telemetry="sync")
+    original_label = baseline_prediction.label
+    alternate_label = 0 if original_label else 1
+
+    # When: Make a second prediction with an intentionally incorrect expected label
+    mismatched_prediction = classification_model.predict(
+        "Filter test input",
+        expected_labels=alternate_label,
+        save_telemetry="sync",
+    )
+    mismatched_memory = mismatched_prediction.memory_lookups[0]
+
+    # Then: The prediction should show up when filtering for incorrect predictions
+    incorrect_predictions = mismatched_memory.predictions(expected_label_match=False)
+    assert any(pred.prediction_id == mismatched_prediction.prediction_id for pred in incorrect_predictions)
+
+    # Produce a correct prediction (predicted label matches expected label)
+    correct_prediction = classification_model.predict(
+        "Filter test input",
+        expected_labels=original_label,
+        save_telemetry="sync",
+    )
+
+    # Ensure we are inspecting a memory used by both correct and incorrect predictions
+    correct_lookup_ids = {lookup.memory_id for lookup in correct_prediction.memory_lookups}
+    if mismatched_memory.memory_id not in correct_lookup_ids:
+        shared_lookup = next(
+            (lookup for lookup in mismatched_prediction.memory_lookups if lookup.memory_id in correct_lookup_ids),
+            None,
+        )
+        assert shared_lookup is not None, "No shared memory lookup between correct and incorrect predictions"
+        mismatched_memory = shared_lookup
+
+    # And: The correct prediction should appear when filtering for correct predictions
+    correct_predictions = mismatched_memory.predictions(expected_label_match=True)
+    assert any(pred.prediction_id == correct_prediction.prediction_id for pred in correct_predictions)
+    assert all(pred.prediction_id != mismatched_prediction.prediction_id for pred in correct_predictions)
+
+
 def test_insert_memories(writable_memoryset: LabeledMemoryset):
     writable_memoryset.refresh()
     prev_length = writable_memoryset.length
@@ -513,7 +696,8 @@ def test_scored_memoryset(scored_memoryset: ScoredMemoryset):
     assert isinstance(scored_memoryset[0], ScoredMemory)
     assert scored_memoryset[0].value == "i love soup"
     assert scored_memoryset[0].score is not None
-    assert scored_memoryset[0].metadata == {"key": "g1", "source_id": "s1", "label": 0}
+    assert scored_memoryset[0].metadata == {"key": "g1", "label": 0}
+    assert scored_memoryset[0].source_id == "s1"
     lookup = scored_memoryset.search("i love soup", count=1)
     assert len(lookup) == 1
     assert lookup[0].score is not None

orca_sdk/regression_model.py

@@ -11,8 +11,10 @@ from ._shared.metrics import RegressionMetrics, calculate_regression_metrics
 from ._utils.common import UNSET, CreateMode, DropMode
 from .client import (
     OrcaClient,
+    PostRegressionModelByModelNameOrIdEvaluationParams,
     PredictiveModelUpdate,
     RARHeadType,
+    RegressionEvaluationRequest,
     RegressionModelMetadata,
 )
 from .datasource import Datasource
@@ -287,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
@@ -299,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
@@ -311,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.
@@ -326,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
@@ -338,10 +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)
         client = OrcaClient._resolve_client()
         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],
@@ -356,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,
         )
@@ -451,7 +468,9 @@ 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]:
         client = OrcaClient._resolve_client()
         response = client.POST(
@@ -464,14 +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():
             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 +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(
@@ -499,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")
@@ -515,6 +537,7 @@ class RegressionModel:
                 tags=tags,
                 save_telemetry="sync" if record_predictions else "off",
                 prompt=prompt,
+                ignore_unlabeled=ignore_unlabeled,
             )
         ]
 
@@ -535,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
 
@@ -550,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
 
@@ -564,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
@@ -577,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
@@ -606,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(
@@ -617,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)}")

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.4.dist-info}/METADATA

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

{orca_sdk-0.1.3.dist-info → orca_sdk-0.1.4.dist-info}/RECORD

@@ -17,25 +17,25 @@ orca_sdk/_utils/prediction_result_ui.py,sha256=Ur_FY7dz3oWNmtPiP3Wl3yRlEMgK8q9Uf
 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/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=dcGBnzIwaU74CMzUh1ObKJbVmZekF5n57gQY6YcQwHE,124550
+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=DJt1Hr8iwaTFbtFD1aqbUPytpmjPr39qISeqSumoraM,20668
-orca_sdk/datasource_test.py,sha256=yBR0NbsAzChV97pSOU0IvlfF5_WbMe49wZeWNXxwNl4,12128
-orca_sdk/embedding_model.py,sha256=IQCpGUUlKHtz33Ld1-Ag8eLMk72qT7K-cHDjBJGJqhQ,27689
+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=BOHg9ksVcN26VtAmuA2cNjGed_Gsx2zbdCO6FBZjuqI,13119
+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=angGB6OUJRDoBa2xzl4WsYhNsRRj99dEKEaAKUqgxO8,100113
-orca_sdk/memoryset_test.py,sha256=wqoHXP60CBvtsReCunQNUxj6_ZDT67TTTluguQapigs,25368
-orca_sdk/regression_model.py,sha256=kIT2i4XMrTBZXXVqDENoYILLF7Zqa8o2ndhraXHUPbY,26437
+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=C0rTudfAV3_t_uADATrl06d7vk-Sgop24FiSSqYhqmc,26209
+orca_sdk/telemetry.py,sha256=ZyCMiyyo_SchjadWZH55TlLrC4Ucq5S316NbW26LL4Y,27834
 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,,
+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,,