orca-sdk 0.0.92__py3-none-any.whl → 0.0.93__py3-none-any.whl

orca_sdk/memoryset_test.py

@@ -1,23 +1,45 @@
 import random
+import time
+from typing import Generator
 from uuid import uuid4
 
 import pytest
+from datasets import ClassLabel, Features, Value
 from datasets.arrow_dataset import Dataset
 
+from orca_sdk.conftest import SAMPLE_DATA
+
+from ._generated_api_client.models import CascadingEditSuggestion
 from .classification_model import ClassificationModel
 from .datasource import Datasource
 from .embedding_model import PretrainedEmbeddingModel
 from .memoryset import LabeledMemoryset, TaskStatus
 
+"""
+Test Performance Note:
+
+Creating new `LabeledMemoryset` objects is expensive, so this test file applies the following optimizations:
+
+- Two fixtures are used to manage memorysets:
+    - `readonly_memoryset` is a session-scoped fixture shared across tests that do not modify state.
+      It should only be used in nullipotent tests.
+    - `writable_memoryset` is a function-scoped, regenerating fixture.
+      It can be used in tests that mutate or delete the memoryset, and will be reset before each test.
+
+- To minimize fixture overhead, tests using `writable_memoryset` should combine related behaviors.
+  For example, prefer a single `test_delete` that covers both single and multiple deletion cases,
+  rather than separate `test_delete_single` and `test_delete_multiple` tests.
+"""
 
-def test_create_memoryset(memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
-    assert memoryset is not None
-    assert memoryset.name == "test_memoryset"
-    assert memoryset.embedding_model == PretrainedEmbeddingModel.GTE_BASE
-    assert memoryset.label_names == label_names
-    assert memoryset.insertion_status == TaskStatus.COMPLETED
-    assert isinstance(memoryset.length, int)
-    assert memoryset.length == len(hf_dataset)
+
+def test_create_memoryset(readonly_memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
+    assert readonly_memoryset is not None
+    assert readonly_memoryset.name == "test_readonly_memoryset"
+    assert readonly_memoryset.embedding_model == PretrainedEmbeddingModel.GTE_BASE
+    assert readonly_memoryset.label_names == label_names
+    assert readonly_memoryset.insertion_status == TaskStatus.COMPLETED
+    assert isinstance(readonly_memoryset.length, int)
+    assert readonly_memoryset.length == len(hf_dataset)
 
 
 def test_create_memoryset_unauthenticated(unauthenticated, datasource):
@@ -29,61 +51,55 @@ def test_create_memoryset_invalid_input(datasource):
     # invalid name
     with pytest.raises(ValueError, match=r"Invalid input:.*"):
         LabeledMemoryset.create("test memoryset", datasource)
-    # invalid datasource
-    datasource.id = str(uuid4())
-    with pytest.raises(ValueError, match=r"Invalid input:.*"):
-        LabeledMemoryset.create("test_memoryset_invalid_datasource", datasource)
 
 
-def test_create_memoryset_already_exists_error(hf_dataset, label_names, memoryset):
+def test_create_memoryset_already_exists_error(hf_dataset, label_names, readonly_memoryset):
+    memoryset_name = readonly_memoryset.name
     with pytest.raises(ValueError):
-        LabeledMemoryset.from_hf_dataset("test_memoryset", hf_dataset, label_names=label_names, value_column="text")
+        LabeledMemoryset.from_hf_dataset(memoryset_name, hf_dataset, label_names=label_names)
     with pytest.raises(ValueError):
-        LabeledMemoryset.from_hf_dataset(
-            "test_memoryset", hf_dataset, label_names=label_names, value_column="text", if_exists="error"
-        )
+        LabeledMemoryset.from_hf_dataset(memoryset_name, hf_dataset, label_names=label_names, if_exists="error")
 
 
-def test_create_memoryset_already_exists_open(hf_dataset, label_names, memoryset):
+def test_create_memoryset_already_exists_open(hf_dataset, label_names, readonly_memoryset):
     # invalid label names
     with pytest.raises(ValueError):
         LabeledMemoryset.from_hf_dataset(
-            memoryset.name,
+            readonly_memoryset.name,
             hf_dataset,
             label_names=["turtles", "frogs"],
-            value_column="text",
             if_exists="open",
         )
     # different embedding model
     with pytest.raises(ValueError):
         LabeledMemoryset.from_hf_dataset(
-            memoryset.name,
+            readonly_memoryset.name,
             hf_dataset,
             label_names=label_names,
             embedding_model=PretrainedEmbeddingModel.DISTILBERT,
             if_exists="open",
         )
     opened_memoryset = LabeledMemoryset.from_hf_dataset(
-        memoryset.name,
+        readonly_memoryset.name,
         hf_dataset,
         embedding_model=PretrainedEmbeddingModel.GTE_BASE,
         if_exists="open",
     )
     assert opened_memoryset is not None
-    assert opened_memoryset.name == memoryset.name
+    assert opened_memoryset.name == readonly_memoryset.name
     assert opened_memoryset.length == len(hf_dataset)
 
 
-def test_open_memoryset(memoryset, hf_dataset):
-    fetched_memoryset = LabeledMemoryset.open(memoryset.name)
+def test_open_memoryset(readonly_memoryset, hf_dataset):
+    fetched_memoryset = LabeledMemoryset.open(readonly_memoryset.name)
     assert fetched_memoryset is not None
-    assert fetched_memoryset.name == memoryset.name
+    assert fetched_memoryset.name == readonly_memoryset.name
     assert fetched_memoryset.length == len(hf_dataset)
 
 
-def test_open_memoryset_unauthenticated(unauthenticated, memoryset):
+def test_open_memoryset_unauthenticated(unauthenticated, readonly_memoryset):
     with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.open(memoryset.name)
+        LabeledMemoryset.open(readonly_memoryset.name)
 
 
 def test_open_memoryset_not_found():
@@ -96,15 +112,15 @@ def test_open_memoryset_invalid_input():
         LabeledMemoryset.open("not valid id")
 
 
-def test_open_memoryset_unauthorized(unauthorized, memoryset):
+def test_open_memoryset_unauthorized(unauthorized, readonly_memoryset):
     with pytest.raises(LookupError):
-        LabeledMemoryset.open(memoryset.name)
+        LabeledMemoryset.open(readonly_memoryset.name)
 
 
-def test_all_memorysets(memoryset):
+def test_all_memorysets(readonly_memoryset: LabeledMemoryset):
     memorysets = LabeledMemoryset.all()
     assert len(memorysets) > 0
-    assert any(memoryset.name == memoryset.name for memoryset in memorysets)
+    assert any(memoryset.name == readonly_memoryset.name for memoryset in memorysets)
 
 
 def test_all_memorysets_unauthenticated(unauthenticated):
@@ -112,51 +128,39 @@ def test_all_memorysets_unauthenticated(unauthenticated):
         LabeledMemoryset.all()
 
 
-def test_all_memorysets_unauthorized(unauthorized, memoryset):
-    assert memoryset not in LabeledMemoryset.all()
-
-
-def test_drop_memoryset(hf_dataset):
-    memoryset = LabeledMemoryset.from_hf_dataset(
-        "test_memoryset_delete",
-        hf_dataset.select(range(1)),
-        value_column="text",
-    )
-    assert LabeledMemoryset.exists(memoryset.name)
-    LabeledMemoryset.drop(memoryset.name)
-    assert not LabeledMemoryset.exists(memoryset.name)
+def test_all_memorysets_unauthorized(unauthorized, readonly_memoryset):
+    assert readonly_memoryset not in LabeledMemoryset.all()
 
 
-def test_drop_memoryset_unauthenticated(unauthenticated, memoryset):
+def test_drop_memoryset_unauthenticated(unauthenticated, readonly_memoryset):
     with pytest.raises(ValueError, match="Invalid API key"):
-        LabeledMemoryset.drop(memoryset.name)
+        LabeledMemoryset.drop(readonly_memoryset.name)
 
 
-def test_drop_memoryset_not_found(memoryset):
+def test_drop_memoryset_not_found():
     with pytest.raises(LookupError):
         LabeledMemoryset.drop(str(uuid4()))
     # ignores error if specified
     LabeledMemoryset.drop(str(uuid4()), if_not_exists="ignore")
 
 
-def test_drop_memoryset_unauthorized(unauthorized, memoryset):
+def test_drop_memoryset_unauthorized(unauthorized, readonly_memoryset):
     with pytest.raises(LookupError):
-        LabeledMemoryset.drop(memoryset.name)
+        LabeledMemoryset.drop(readonly_memoryset.name)
 
 
-def test_update_memoryset_metadata(memoryset: LabeledMemoryset):
-    memoryset.update_metadata(description="New description")
-    assert memoryset.description == "New description"
+def test_update_memoryset_metadata(writable_memoryset: LabeledMemoryset):
+    # NOTE: We're combining multiple tests into one here to avoid multiple API calls
 
+    writable_memoryset.update_metadata(description="New description")
+    assert writable_memoryset.description == "New description"
 
-def test_update_memoryset_no_description(memoryset: LabeledMemoryset):
-    assert memoryset.description is not None
-    memoryset.update_metadata(description=None)
-    assert memoryset.description is None
+    writable_memoryset.update_metadata(description=None)
+    assert writable_memoryset.description is None
 
 
-def test_search(memoryset: LabeledMemoryset):
-    memory_lookups = memoryset.search(["i love soup", "cats are cute"])
+def test_search(readonly_memoryset: LabeledMemoryset):
+    memory_lookups = readonly_memoryset.search(["i love soup", "cats are cute"])
     assert len(memory_lookups) == 2
     assert len(memory_lookups[0]) == 1
     assert len(memory_lookups[1]) == 1
@@ -164,53 +168,53 @@ def test_search(memoryset: LabeledMemoryset):
     assert memory_lookups[1][0].label == 1
 
 
-def test_search_count(memoryset: LabeledMemoryset):
-    memory_lookups = memoryset.search("i love soup", count=3)
+def test_search_count(readonly_memoryset: LabeledMemoryset):
+    memory_lookups = readonly_memoryset.search("i love soup", count=3)
     assert len(memory_lookups) == 3
     assert memory_lookups[0].label == 0
     assert memory_lookups[1].label == 0
     assert memory_lookups[2].label == 0
 
 
-def test_get_memory_at_index(memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
-    memory = memoryset[0]
-    assert memory.value == hf_dataset[0]["text"]
+def test_get_memory_at_index(readonly_memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
+    memory = readonly_memoryset[0]
+    assert memory.value == hf_dataset[0]["value"]
     assert memory.label == hf_dataset[0]["label"]
     assert memory.label_name == label_names[hf_dataset[0]["label"]]
     assert memory.source_id == hf_dataset[0]["source_id"]
     assert memory.score == hf_dataset[0]["score"]
     assert memory.key == hf_dataset[0]["key"]
-    last_memory = memoryset[-1]
-    assert last_memory.value == hf_dataset[-1]["text"]
+    last_memory = readonly_memoryset[-1]
+    assert last_memory.value == hf_dataset[-1]["value"]
     assert last_memory.label == hf_dataset[-1]["label"]
 
 
-def test_get_range_of_memories(memoryset: LabeledMemoryset, hf_dataset: Dataset):
-    memories = memoryset[1:3]
+def test_get_range_of_memories(readonly_memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memories = readonly_memoryset[1:3]
     assert len(memories) == 2
-    assert memories[0].value == hf_dataset["text"][1]
-    assert memories[1].value == hf_dataset["text"][2]
+    assert memories[0].value == hf_dataset["value"][1]
+    assert memories[1].value == hf_dataset["value"][2]
 
 
-def test_get_memory_by_id(memoryset: LabeledMemoryset, hf_dataset: Dataset):
-    memory = memoryset.get(memoryset[0].memory_id)
-    assert memory.value == hf_dataset[0]["text"]
-    assert memory == memoryset[memory.memory_id]
+def test_get_memory_by_id(readonly_memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memory = readonly_memoryset.get(readonly_memoryset[0].memory_id)
+    assert memory.value == hf_dataset[0]["value"]
+    assert memory == readonly_memoryset[memory.memory_id]
 
 
-def test_get_memories_by_id(memoryset: LabeledMemoryset, hf_dataset: Dataset):
-    memories = memoryset.get([memoryset[0].memory_id, memoryset[1].memory_id])
+def test_get_memories_by_id(readonly_memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memories = readonly_memoryset.get([readonly_memoryset[0].memory_id, readonly_memoryset[1].memory_id])
     assert len(memories) == 2
-    assert memories[0].value == hf_dataset[0]["text"]
-    assert memories[1].value == hf_dataset[1]["text"]
+    assert memories[0].value == hf_dataset[0]["value"]
+    assert memories[1].value == hf_dataset[1]["value"]
 
 
-def test_query_memoryset(memoryset: LabeledMemoryset):
-    memories = memoryset.query(filters=[("label", "==", 1)])
+def test_query_memoryset(readonly_memoryset: LabeledMemoryset):
+    memories = readonly_memoryset.query(filters=[("label", "==", 1)])
     assert len(memories) == 8
     assert all(memory.label == 1 for memory in memories)
-    assert len(memoryset.query(limit=2)) == 2
-    assert len(memoryset.query(filters=[("metadata.key", "==", "val1")])) == 1
+    assert len(readonly_memoryset.query(limit=2)) == 2
+    assert len(readonly_memoryset.query(filters=[("metadata.key", "==", "val1")])) == 1
 
 
 def test_query_memoryset_with_feedback_metrics(model: ClassificationModel):
@@ -268,19 +272,19 @@ def test_query_memoryset_with_feedback_metrics_sort(model: ClassificationModel):
     assert memories[-1].feedback_metrics["positive"]["avg"] == -1.0
 
 
-def test_insert_memories(memoryset: LabeledMemoryset):
-    memoryset.refresh()
-    prev_length = memoryset.length
-    memoryset.insert(
+def test_insert_memories(writable_memoryset: LabeledMemoryset):
+    writable_memoryset.refresh()
+    prev_length = writable_memoryset.length
+    writable_memoryset.insert(
         [
             dict(value="tomato soup is my favorite", label=0),
             dict(value="cats are fun to play with", label=1),
         ]
     )
-    assert memoryset.length == prev_length + 2
-    memoryset.insert(dict(value="tomato soup is my favorite", label=0, key="test", source_id="test"))
-    assert memoryset.length == prev_length + 3
-    last_memory = memoryset[-1]
+    assert writable_memoryset.length == prev_length + 2
+    writable_memoryset.insert(dict(value="tomato soup is my favorite", label=0, key="test", source_id="test"))
+    assert writable_memoryset.length == prev_length + 3
+    last_memory = writable_memoryset[-1]
     assert last_memory.value == "tomato soup is my favorite"
     assert last_memory.label == 0
     assert last_memory.metadata
@@ -288,25 +292,26 @@ def test_insert_memories(memoryset: LabeledMemoryset):
     assert last_memory.source_id == "test"
 
 
-def test_update_memory(memoryset: LabeledMemoryset, hf_dataset: Dataset):
-    memory_id = memoryset[0].memory_id
-    updated_memory = memoryset.update(dict(memory_id=memory_id, value="i love soup so much"))
+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
+
+    # test updating a single memory
+    memory_id = writable_memoryset[0].memory_id
+    updated_memory = writable_memoryset.update(dict(memory_id=memory_id, value="i love soup so much"))
     assert updated_memory.value == "i love soup so much"
     assert updated_memory.label == hf_dataset[0]["label"]
-    assert memoryset.get(memory_id).value == "i love soup so much"
-
+    assert writable_memoryset.get(memory_id).value == "i love soup so much"
 
-def test_update_memory_instance(memoryset: LabeledMemoryset, hf_dataset: Dataset):
-    memory = memoryset[0]
+    # test updating a memory instance
+    memory = writable_memoryset[0]
     updated_memory = memory.update(value="i love soup even more")
     assert updated_memory is memory
     assert memory.value == "i love soup even more"
     assert memory.label == hf_dataset[0]["label"]
 
-
-def test_update_memories(memoryset: LabeledMemoryset):
-    memory_ids = [memory.memory_id for memory in memoryset[:2]]
-    updated_memories = memoryset.update(
+    # test updating multiple memories
+    memory_ids = [memory.memory_id for memory in writable_memoryset[:2]]
+    updated_memories = writable_memoryset.update(
         [
             dict(memory_id=memory_ids[0], value="i love soup so much"),
             dict(memory_id=memory_ids[1], value="cats are so cute"),
@@ -316,35 +321,37 @@ def test_update_memories(memoryset: LabeledMemoryset):
     assert updated_memories[1].value == "cats are so cute"
 
 
-def test_delete_memory(memoryset: LabeledMemoryset):
-    memoryset.refresh()
-    prev_length = memoryset.length
-    memory_id = memoryset[0].memory_id
-    memoryset.delete(memory_id)
-    with pytest.raises(LookupError):
-        memoryset.get(memory_id)
-    assert memoryset.length == prev_length - 1
+def test_delete_memories(writable_memoryset: LabeledMemoryset):
+    # We've combined the delete tests into one to avoid multiple expensive requests for a writable_memoryset
 
+    # test deleting a single memory
+    prev_length = writable_memoryset.length
+    memory_id = writable_memoryset[0].memory_id
+    writable_memoryset.delete(memory_id)
+    with pytest.raises(LookupError):
+        writable_memoryset.get(memory_id)
+    assert writable_memoryset.length == prev_length - 1
 
-def test_delete_memories(memoryset: LabeledMemoryset):
-    prev_length = memoryset.length
-    memoryset.delete([memoryset[0].memory_id, memoryset[1].memory_id])
-    assert memoryset.length == prev_length - 2
+    # test deleting multiple memories
+    prev_length = writable_memoryset.length
+    writable_memoryset.delete([writable_memoryset[0].memory_id, writable_memoryset[1].memory_id])
+    assert writable_memoryset.length == prev_length - 2
 
 
-def test_clone_memoryset(memoryset: LabeledMemoryset):
-    cloned_memoryset = memoryset.clone("test_cloned_memoryset", embedding_model=PretrainedEmbeddingModel.DISTILBERT)
+def test_clone_memoryset(readonly_memoryset: LabeledMemoryset):
+    cloned_memoryset = readonly_memoryset.clone(
+        "test_cloned_memoryset", embedding_model=PretrainedEmbeddingModel.DISTILBERT
+    )
     assert cloned_memoryset is not None
     assert cloned_memoryset.name == "test_cloned_memoryset"
-    assert cloned_memoryset.length == memoryset.length
+    assert cloned_memoryset.length == readonly_memoryset.length
     assert cloned_memoryset.embedding_model == PretrainedEmbeddingModel.DISTILBERT
     assert cloned_memoryset.insertion_status == TaskStatus.COMPLETED
 
 
-def test_embedding_evaluation(hf_dataset):
-    datasource = Datasource.from_hf_dataset("eval_datasource", hf_dataset, if_exists="open")
+def test_embedding_evaluation(eval_datasource: Datasource):
     response = LabeledMemoryset.run_embedding_evaluation(
-        datasource, embedding_models=["CDE_SMALL"], neighbor_count=2, value_column="text"
+        eval_datasource, embedding_models=["CDE_SMALL"], neighbor_count=2
     )
     assert response is not None
     assert isinstance(response, dict)
@@ -358,8 +365,8 @@ def test_embedding_evaluation(hf_dataset):
 
 
 @pytest.fixture(scope="function")
-async def test_group_potential_duplicates(memoryset: LabeledMemoryset):
-    memoryset.insert(
+async def test_group_potential_duplicates(writable_memoryset: LabeledMemoryset):
+    writable_memoryset.insert(
         [
             dict(value="raspberry soup Is my favorite", label=0),
             dict(value="Raspberry soup is MY favorite", label=0),
@@ -375,7 +382,74 @@ async def test_group_potential_duplicates(memoryset: LabeledMemoryset):
         ]
     )
 
-    memoryset.analyze({"name": "duplicate", "possible_duplicate_threshold": 0.97})
-    response = memoryset.get_potential_duplicate_groups()
+    writable_memoryset.analyze({"name": "duplicate", "possible_duplicate_threshold": 0.97})
+    response = writable_memoryset.get_potential_duplicate_groups()
     assert isinstance(response, list)
     assert sorted([len(res) for res in response]) == [5, 6]  # 5 favorite, 6 mom
+
+
+def test_get_cascading_edits_suggestions(writable_memoryset: LabeledMemoryset):
+    # Insert a memory to test cascading edits
+    SOUP = 0
+    CATS = 1
+    query_text = "i love soup"  # from SAMPLE_DATA in conftest.py
+    mislabeled_soup_text = "soup is comfort in a bowl"
+    writable_memoryset.insert(
+        [
+            dict(value=mislabeled_soup_text, label=CATS),  # mislabeled soup memory
+        ]
+    )
+
+    # Fetch the memory to update
+    memory = writable_memoryset.query(filters=[("value", "==", query_text)])[0]
+
+    # Update the label and get cascading edit suggestions
+    suggestions = writable_memoryset.get_cascading_edits_suggestions(
+        memory=memory,
+        old_label=CATS,
+        new_label=SOUP,
+        max_neighbors=10,
+        max_validation_neighbors=5,
+    )
+
+    # Validate the suggestions
+    assert len(suggestions) == 1
+    assert suggestions[0].neighbor.value == mislabeled_soup_text
+
+
+def test_analyze_invalid_analysis_name(readonly_memoryset: LabeledMemoryset):
+    """Test that analyze() raises ValueError for invalid analysis names"""
+    memoryset = LabeledMemoryset.open(readonly_memoryset.name)
+
+    # Test with string input
+    with pytest.raises(ValueError) as excinfo:
+        memoryset.analyze("invalid_name")
+    assert "Invalid analysis name: invalid_name" in str(excinfo.value)
+    assert "Valid names are:" in str(excinfo.value)
+
+    # Test with dict input
+    with pytest.raises(ValueError) as excinfo:
+        memoryset.analyze({"name": "invalid_name"})
+    assert "Invalid analysis name: invalid_name" in str(excinfo.value)
+    assert "Valid names are:" in str(excinfo.value)
+
+    # Test with multiple analyses where one is invalid
+    with pytest.raises(ValueError) as excinfo:
+        memoryset.analyze("duplicate", "invalid_name")
+    assert "Invalid analysis name: invalid_name" in str(excinfo.value)
+    assert "Valid names are:" in str(excinfo.value)
+
+    # Test with valid analysis names
+    result = memoryset.analyze("duplicate", "cluster")
+    assert isinstance(result, dict)
+    assert "duplicate" in result
+    assert "cluster" in result
+
+
+def test_drop_memoryset(writable_memoryset: LabeledMemoryset):
+    # NOTE: Keep this test at the end to ensure the memoryset is dropped after all tests.
+    # Otherwise, it would be recreated on the next test run if it were dropped earlier, and
+    # that's expensive.
+    assert LabeledMemoryset.exists(writable_memoryset.name)
+    LabeledMemoryset.drop(writable_memoryset.name)
+    assert not LabeledMemoryset.exists(writable_memoryset.name)

{orca_sdk-0.0.92.dist-info → orca_sdk-0.0.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: orca_sdk
-Version: 0.0.92
+Version: 0.0.93
 Summary: SDK for interacting with Orca Services
 License: Apache-2.0
 Author: Orca DB Inc.

{orca_sdk-0.0.92.dist-info → orca_sdk-0.0.93.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orca_sdk/__init__.py,sha256=n0csZZlmu18cSj9aelY0SGIMoM4ymz0Wx00RK2GN8jQ,783
 orca_sdk/_generated_api_client/__init__.py,sha256=2-BPUe-gQ4yMDdxcfBZ1PEHKn-te41oFdKgrzK29JV0,69
-orca_sdk/_generated_api_client/api/__init__.py,sha256=4oVjtFRCqyyenbFtaOOIyKZ8q9wQ0drWrsTu4Iy9VKE,9123
+orca_sdk/_generated_api_client/api/__init__.py,sha256=3Kwwz_mNGgVMnYF-VRXiHnwZNBomWwM9HNI1ROrvbtA,9301
 orca_sdk/_generated_api_client/api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orca_sdk/_generated_api_client/api/auth/check_authentication_auth_get.py,sha256=lARAAY0SCTCBUPRo9r31yGoJZ2RklwaqD6kQBnsXfsY,3900
 orca_sdk/_generated_api_client/api/auth/create_api_key_auth_api_key_post.py,sha256=HeSjn9M8vplZdoeZE8jYyHq_s_chx4ElwF6FZptI_f4,4570
@@ -53,6 +53,7 @@ orca_sdk/_generated_api_client/api/memoryset/list_memorysets_memoryset_get.py,sh
 orca_sdk/_generated_api_client/api/memoryset/memoryset_lookup_gpu_memoryset_name_or_id_lookup_post.py,sha256=LlbgqtFbIcmLIEficz6NqNDi3ofb2dk1mtwSb5TW6hk,5426
 orca_sdk/_generated_api_client/api/memoryset/potential_duplicate_groups_memoryset_name_or_id_potential_duplicate_groups_get.py,sha256=GFV-VC26gnrKsBbUJ-r8an27IOKTRO8zwuH3m97-dbA,4812
 orca_sdk/_generated_api_client/api/memoryset/query_memoryset_memoryset_name_or_id_memories_post.py,sha256=AZuWJjzVX4Q5rEhuByGMdd3eIlkijUHTyB4NsevCg3U,5110
+orca_sdk/_generated_api_client/api/memoryset/suggest_cascading_edits_memoryset_name_or_id_memory_memory_id_cascading_edits_post.py,sha256=GRkPaFCjQEK1sqW_pA6HM790020Tth7tgDwbTs1VOHI,7238
 orca_sdk/_generated_api_client/api/memoryset/update_memories_gpu_memoryset_name_or_id_memories_patch.py,sha256=830keCUt7CaGsd0TlxPK_TuhiMTVQKhFobRpJGVzq9I,5284
 orca_sdk/_generated_api_client/api/memoryset/update_memory_gpu_memoryset_name_or_id_memory_patch.py,sha256=cbfnljmpDMto1dRcrhZDxLJRXYeCMvaZjas9mzA51w8,5144
 orca_sdk/_generated_api_client/api/memoryset/update_memoryset_memoryset_name_or_id_patch.py,sha256=VxXtTAl_NDMJYOEOnAEZw8yqhP0w-ADtXGmYbsnfAdk,5010
@@ -77,14 +78,16 @@ orca_sdk/_generated_api_client/api/telemetry/record_prediction_feedback_telemetr
 orca_sdk/_generated_api_client/api/telemetry/update_prediction_telemetry_prediction_prediction_id_patch.py,sha256=l94sgnNg4IkhigmFmx3gpeTA6pl-WwdFZmsNCWX2hw0,4779
 orca_sdk/_generated_api_client/client.py,sha256=fPYjw_Y3Q2xbosRZAHb5hlOuV4KqIfHgFtEnJx1Yce8,8430
 orca_sdk/_generated_api_client/errors.py,sha256=jgL5oFlxjCNjjxWNpaFtFMqNxrG8TK6jpk5bZDvWeRM,1853
-orca_sdk/_generated_api_client/models/__init__.py,sha256=3fjbYdRtS5POw4Ce2FfBdnUqaVU4YRhj2iCy4wOJbvQ,10719
+orca_sdk/_generated_api_client/models/__init__.py,sha256=bdrEE4WTcf4kaRWd2BOOeIGe95Cb1wwJGL6cVy6p0SE,10926
 orca_sdk/_generated_api_client/models/analyze_neighbor_labels_result.py,sha256=n5xhKNRx_QaAmXgveWSwLRlAjTHkuEGiH0-Vr1H6RsY,4256
 orca_sdk/_generated_api_client/models/api_key_metadata.py,sha256=jQrSe_X5hCgFYh8PwX-X0M6VINVGVhLBlKmv4qN5otA,3789
 orca_sdk/_generated_api_client/models/api_key_metadata_scope_item.py,sha256=umhWzrAt0ZEI9B7pLpnOEsc5Kc-dxeJdzHX7iHyjt4I,182
 orca_sdk/_generated_api_client/models/base_label_prediction_result.py,sha256=wJBkJcUdI588tOXimOZ6lBIFGPAaStBrOC84m4-8CIw,3828
 orca_sdk/_generated_api_client/models/base_model.py,sha256=0UY9I_q-b6kOG0LYcw_C192PKRfmejYX9rZa7POCrTc,1563
 orca_sdk/_generated_api_client/models/body_create_datasource_datasource_post.py,sha256=w5Ni3zFPMTf8XYsH-EZmlokx7vV0vpQiSnbXlktoQBY,6713
-orca_sdk/_generated_api_client/models/classification_evaluation_result.py,sha256=mdSZjv7qy6OreEjwNTV_VpfoeuZHdrnlCG8sr0elhoo,4715
+orca_sdk/_generated_api_client/models/cascade_edit_suggestions_request.py,sha256=juE1BymgvGCihm0KFKle6x2rw3C2KbDsQY8Jhydxpb4,5742
+orca_sdk/_generated_api_client/models/cascading_edit_suggestion.py,sha256=lXgBJ663mtHpmHxfkzIdTktnvF9BZFitVdqavjgOcNs,2679
+orca_sdk/_generated_api_client/models/classification_evaluation_result.py,sha256=0rdQWoW5F9c2FpPHiq8pkNQVRCHOGrNtNM5z7Y4KR64,7401
 orca_sdk/_generated_api_client/models/clone_labeled_memoryset_request.py,sha256=oMZL1jSF0twNNEwbBuz5VuLewcRcbIOc4h7MxMvI4uY,6535
 orca_sdk/_generated_api_client/models/cluster_metrics.py,sha256=u5ODh3udSzndaKaStb1vK1P49J7l0UtZ9Q977jyTxZ8,2078
 orca_sdk/_generated_api_client/models/column_info.py,sha256=aI0YD5aOabF0B_JpUU6uFSWmN6nTiDUwnjb6L9KKj9M,3358
@@ -110,7 +113,7 @@ orca_sdk/_generated_api_client/models/evaluation_response.py,sha256=3ADAPevS7WOm
 orca_sdk/_generated_api_client/models/feedback_metrics.py,sha256=1Y8aRPTIShFRPGoqN4kqoI0DnoOKmI7mx3jfx4gCoS8,2229
 orca_sdk/_generated_api_client/models/feedback_type.py,sha256=EtKEUBoLVnJLdXiiH6R9QKPHqgTrbGJ_svdeDogn69k,169
 orca_sdk/_generated_api_client/models/filter_item.py,sha256=pYj2qR1SaPrXbk7D02sKa3mIZACz8AX1Nz7Mq_-ss5k,8257
-orca_sdk/_generated_api_client/models/filter_item_field_type_0_item.py,sha256=8R3BKCeXrmanscp-3-E28UStjN3A2aaVzK7e-8xis-o,355
+orca_sdk/_generated_api_client/models/filter_item_field_type_0_item.py,sha256=iyRsQvQKAnthnbtIzXFwQqVZsWjVkRUfBL9jbogfo1I,383
 orca_sdk/_generated_api_client/models/filter_item_field_type_2_item_type_1.py,sha256=5E9GwCFT1TyGjqF1cUBqJ5g4dL7MyaFMMpPOKMvd1gs,926
 orca_sdk/_generated_api_client/models/filter_item_op.py,sha256=vtjnJWrVJMwg6gj6BjDl6FasWzBCQygHpBbpRycOdGM,283
 orca_sdk/_generated_api_client/models/finetune_embedding_model_request.py,sha256=O9iHbzevRZ-oQLHXMv-v4IEKG7GboRDLDuLePzng9v4,10211
@@ -119,19 +122,19 @@ orca_sdk/_generated_api_client/models/finetuned_embedding_model_metadata.py,sha2
 orca_sdk/_generated_api_client/models/get_memories_request.py,sha256=xNit9r5gJqqXId1KhNdQsoMh_cKjvbl9UVapfT6W3Ks,1949
 orca_sdk/_generated_api_client/models/internal_server_error_response.py,sha256=RBVgjZKuBM-fql-N_hts-RvgfrN09T7yqqOOhHYBVN8,2310
 orca_sdk/_generated_api_client/models/label_class_metrics.py,sha256=Q3vWLw8F_IdwAwhunLp0f_l7PvP1gZN1XGCZQRJtbAY,3144
-orca_sdk/_generated_api_client/models/label_prediction_memory_lookup.py,sha256=DEwdX5532kHRpsKJe3wOgUWUTZOdeaJV30XvsI8dyOI,6005
+orca_sdk/_generated_api_client/models/label_prediction_memory_lookup.py,sha256=_r2UeP1Op3w2luQiOgQ7cQmdG8X0q9VbmdSG2T07mfw,6248
 orca_sdk/_generated_api_client/models/label_prediction_memory_lookup_metadata.py,sha256=bsXtXEf25ch5qAdpnXWSi2qzCkQPZ4xhKcHWMxlgOhQ,2338
 orca_sdk/_generated_api_client/models/label_prediction_with_memories_and_feedback.py,sha256=ZxmUTIY02_eZz5EeO6xwehFyS4yYzt_Nw3v0pEbTclQ,9004
-orca_sdk/_generated_api_client/models/labeled_memory.py,sha256=BYG1PqvL3FXKQCuBTg3pLwIgA0Uv8KU5YoxvdR2zZxg,5205
+orca_sdk/_generated_api_client/models/labeled_memory.py,sha256=bLCcyezGKT05PROBXnObnaxvj5ymSrBc2r4fPH2mgcQ,5448
 orca_sdk/_generated_api_client/models/labeled_memory_insert.py,sha256=O3rgrloH3eu9YPzP7X1AKRfq6wxx9Eznl_prpRiMVVM,3768
 orca_sdk/_generated_api_client/models/labeled_memory_insert_metadata.py,sha256=b9T8i61YUIkNpbJzLwUztfUGNqwRzYJ51RfFpukNS5I,2295
-orca_sdk/_generated_api_client/models/labeled_memory_lookup.py,sha256=t2mOLObeEVATumYskejgPr7d0pmggygBjyPxGCgIViY,5370
+orca_sdk/_generated_api_client/models/labeled_memory_lookup.py,sha256=ufC44ri2gkSK8Dodnq1oSqvtB2_28H-wfoPKsIPy-p4,5613
 orca_sdk/_generated_api_client/models/labeled_memory_lookup_metadata.py,sha256=8-gqpENgh8ZxLPIvm2nrnpzlCdKQBeBlKAj20dCPpo8,2295
 orca_sdk/_generated_api_client/models/labeled_memory_metadata.py,sha256=2BEZAYpUCJwF9xd_avvR8m-gh13MXjgfUXVXFFSj-UE,2262
 orca_sdk/_generated_api_client/models/labeled_memory_metrics.py,sha256=fXDYee3im18yfNtV8OwbDZNgXRkDhYBpu3f87v_NHFc,10765
 orca_sdk/_generated_api_client/models/labeled_memory_update.py,sha256=stIKFqWNQR6SGPnhraH3L5EBnsSn7I5UUK6IX8sKdX0,5662
 orca_sdk/_generated_api_client/models/labeled_memory_update_metadata_type_0.py,sha256=PVuiR3MpN2PGcui-L1airH44rs_1Ith076kpvItstf0,2326
-orca_sdk/_generated_api_client/models/labeled_memory_with_feedback_metrics.py,sha256=pr2cM9z2F4iAMW6N38xGCYD_fr8R5co70-p0TVRN94w,6307
+orca_sdk/_generated_api_client/models/labeled_memory_with_feedback_metrics.py,sha256=oFvoGzk7i4Z2kwPY8Ko-IPJ2XTQzsKWeeuaI0qwzcH4,6550
 orca_sdk/_generated_api_client/models/labeled_memory_with_feedback_metrics_feedback_metrics.py,sha256=qSUl04WibCHV-1yoytEW2TI5in2cf1HCerpOJ8wej3w,2272
 orca_sdk/_generated_api_client/models/labeled_memory_with_feedback_metrics_metadata.py,sha256=wYnU5KuMTlUwIxpbrCe4obx40h_-FJExxoCOMd0-Qik,2366
 orca_sdk/_generated_api_client/models/labeled_memoryset_metadata.py,sha256=1GiEJSXBA6VnUoLYSNk2f5Zxyj8bi_kWvUGOUzHNKyQ,7669
@@ -166,7 +169,7 @@ orca_sdk/_generated_api_client/models/prediction_feedback.py,sha256=wigdEfcKnuGr
 orca_sdk/_generated_api_client/models/prediction_feedback_category.py,sha256=qlaU7wRFtgNQt-hsTwZvt0uPtFJepv0v4TPFP19N00E,3031
 orca_sdk/_generated_api_client/models/prediction_feedback_request.py,sha256=uhtjJ5y4H4tTAQGqzYY5RzzSsntXsb2EP3dxzjnfIYE,3812
 orca_sdk/_generated_api_client/models/prediction_feedback_result.py,sha256=uFqV0S9opm6fkcMo1cVS4rXTXHY259YvacRUKtfbGl0,3317
-orca_sdk/_generated_api_client/models/prediction_request.py,sha256=aUJaAzeOIXLyMklVHRqGIuq5hTgxHrJVB8DdHicum8w,6315
+orca_sdk/_generated_api_client/models/prediction_request.py,sha256=HE4AVf1d2yp_tUWdmie8zsTGh7bRdHh_gY2QJSocpl4,6787
 orca_sdk/_generated_api_client/models/prediction_sort_item_item_type_0.py,sha256=Q9RNooVV_he9I9J20ugXylFQPYIuBLfVX2d9XJha6VI,226
 orca_sdk/_generated_api_client/models/prediction_sort_item_item_type_1.py,sha256=iW6iIk_mpkkPFaxDcyLfkRQ75vrAMlEap_7hp4263pE,166
 orca_sdk/_generated_api_client/models/pretrained_embedding_model_metadata.py,sha256=XMHvBdeGpbSn7ZPJaBVT3QeNa2lVD1zioyj9X957wmo,2928
@@ -199,26 +202,27 @@ orca_sdk/_utils/analysis_ui_style.css,sha256=q_ba_-_KtgztepHg829zLzypaxKayl7ySC1
 orca_sdk/_utils/auth.py,sha256=9nLgcuw5B9BCkThN8Qhyq0TeJAyaRSK4bLbOsZCDIqg,2793
 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=1bGQttjgdPuORNnB_otg4CHHxaO1zeB7fNJDkubllkA,4106
-orca_sdk/_utils/data_parsing_test.py,sha256=n-6iQ-WOgux7PywCor2YXXaaurv_FsuHVu6jy1D2ZbY,8802
+orca_sdk/_utils/data_parsing.py,sha256=2XPiZEV6yQ_W0brCO1QEdVuYQnZCh7h-1-1WskRnegg,5326
+orca_sdk/_utils/data_parsing_test.py,sha256=XFluNehttlZtdy5cuQwzMx9KVUKv1Nh1FvTmPU4X8_0,9068
 orca_sdk/_utils/prediction_result_ui.css,sha256=sqBlkRLnovb5X5EcUDdB6iGpH63nVRlTW4uAmXuD0WM,258
 orca_sdk/_utils/prediction_result_ui.py,sha256=dudc21ka2Bqdtr_8wQaMVFxLGvrsZxWUZvfC9dn4i2A,2990
 orca_sdk/_utils/task.py,sha256=WOfFuRCoh6QHVDDYrGeq3Hi6NVihQQZJii0cBCONOWk,2400
+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/classification_model.py,sha256=j3b277NGeF2kDehwPN7s95KkEyjafvH52ip9t-dRFPk,26439
-orca_sdk/classification_model_test.py,sha256=gbqyjjnwVZB_Z7IHLIVJ7U3jY-xdKag9hIXULDelVqQ,13272
-orca_sdk/conftest.py,sha256=_7O6yVccU-_zteUTCX3j7j7ZfyKNBD7nYL-G8ln6qXY,4661
+orca_sdk/classification_model.py,sha256=E_Mmo3SzsUBue8t1mugLfPFsoAZcEzudgw_qfPayKBk,27564
+orca_sdk/classification_model_test.py,sha256=flhk3vhdIpjuPlpVDrzIgpyoAGGiiYyWB1cRtuNE1oQ,14183
+orca_sdk/conftest.py,sha256=JfwN_-43_EzPtJLY58R7ucVWXnAdw_HGRCf_8XFtXf4,7025
 orca_sdk/credentials.py,sha256=gq_4w_o-igCCLNR6TY1x4RzMYysKUCsXJvdi6nem-A0,3558
 orca_sdk/credentials_test.py,sha256=ETTyDZ9MEpb_X6yiRcgYGWNKCB2QZ5CLYB_unRGg1b8,1028
-orca_sdk/datasource.py,sha256=zdkA32FYY8XuWHMUBjgMDFtuEspdtl0-iTOMOHic90w,13733
+orca_sdk/datasource.py,sha256=hRw9GIQAAQLk-bQWqaKZSLJXt5XcBPr-CWzwXvftz2U,14217
 orca_sdk/datasource_test.py,sha256=5zRew9Wi05cPJj-xSF0PwRZ8oDaaO5MhqJojlfqT5p4,3158
 orca_sdk/embedding_model.py,sha256=Hw8NlwzWVK5ts8SF0lHIs7hL38hCTreEiIyoqHY-OFA,14187
-orca_sdk/embedding_model_test.py,sha256=j6uGu9ZJSafDV7uFiJiG8SZVGvPQBgxxDcg7i1xbWho,6914
-orca_sdk/memoryset.py,sha256=xvaNn3YwG3fzk3MZhk3LeX_K5yRKP-yRf79bIAUBR-Y,56058
-orca_sdk/memoryset_test.py,sha256=w8-2RXFePg1pqC67uMpHSevjnW4P0GbNpqRjJXAmIa0,15122
+orca_sdk/embedding_model_test.py,sha256=YbhA8flPuhhb6p67CR4sBj31e6mmbIa6-YRDPMF-xJE,6875
+orca_sdk/memoryset.py,sha256=_YayL3m-qdkiiRefq0J7b3320cV1hnU-jww16SU0ThY,59864
+orca_sdk/memoryset_test.py,sha256=z4aW4ljeGOiWkBC2mXGGm4pu5JAQCNDqYuHcaw4I6UQ,18968
 orca_sdk/telemetry.py,sha256=U53NI7_D1IpWqdV8NYuUrwvhpX0CF_PJvRRvOiFekno,16393
 orca_sdk/telemetry_test.py,sha256=7JfS0k7r9STMCkasCjXWL3KmbrdmVjVnFeYPCdT8jqQ,5059
-orca_sdk-0.0.92.dist-info/METADATA,sha256=W1Ee5mRfJQH03lS5XQAztQC1cE4gupmRJaibugGAcrs,3229
-orca_sdk-0.0.92.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-orca_sdk-0.0.92.dist-info/RECORD,,
+orca_sdk-0.0.93.dist-info/METADATA,sha256=VKQ_ZnIWW5P9okjSzZZjRvjtXTU9zkNLKbbWRI9mHLE,3229
+orca_sdk-0.0.93.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+orca_sdk-0.0.93.dist-info/RECORD,,