orca-sdk 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

orca_sdk/memoryset_test.py

@@ -59,7 +59,6 @@ def test_create_empty_labeled_memoryset():
 
         # inserting should work on an empty memoryset
         memoryset.insert(dict(value="i love soup", label=1, key="k1"))
-        memoryset.refresh()
         assert memoryset.length == 1
         m = memoryset[0]
         assert isinstance(m, LabeledMemory)
@@ -104,7 +103,6 @@ def test_create_empty_scored_memoryset():
 
         # inserting should work on an empty memoryset
         memoryset.insert(dict(value="i love soup", score=0.25, key="k1", label=0))
-        memoryset.refresh()
         assert memoryset.length == 1
         m = memoryset[0]
         assert isinstance(m, ScoredMemory)
@@ -563,155 +561,6 @@ def test_query_memoryset_with_feedback_metrics_sort(classification_model: Classi
     assert memories[-1].feedback_metrics["positive"]["avg"] == -1.0
 
 
-def test_query_memoryset_with_partition_id(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with partition_id and include_global (default) - includes both p1 and global memories
-    memories = readonly_partitioned_memoryset.query(partition_id="p1")
-    assert len(memories) == 15  # 8 p1 + 7 global = 15
-    # Results should include both p1 and global memories
-    partition_ids = {memory.partition_id for memory in memories}
-    assert "p1" in partition_ids
-    assert None in partition_ids
-
-
-def test_query_memoryset_with_partition_id_and_exclude_global(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with partition_id and exclude_global mode - only returns p1 memories
-    memories = readonly_partitioned_memoryset.query(partition_id="p1", partition_filter_mode="exclude_global")
-    assert len(memories) == 8  # Only 8 p1 memories (no global)
-    # All results should be from partition p1 (no global memories)
-    assert all(memory.partition_id == "p1" for memory in memories)
-
-
-def test_query_memoryset_with_partition_id_and_include_global(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with partition_id and include_global mode (default) - includes both p1 and global
-    memories = readonly_partitioned_memoryset.query(partition_id="p1", partition_filter_mode="include_global")
-    assert len(memories) == 15  # 8 p1 + 7 global = 15
-    # Results should include both p1 and global memories
-    partition_ids = {memory.partition_id for memory in memories}
-    assert "p1" in partition_ids
-    assert None in partition_ids
-
-
-def test_query_memoryset_with_partition_filter_mode_exclude_global(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query excluding global memories requires a partition_id
-    # Test with a specific partition_id
-    memories = readonly_partitioned_memoryset.query(partition_id="p1", partition_filter_mode="exclude_global")
-    assert len(memories) == 8  # Only p1 memories
-    # All results should have a partition_id (not global)
-    assert all(memory.partition_id == "p1" for memory in memories)
-
-
-def test_query_memoryset_with_partition_filter_mode_only_global(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query only in global memories
-    memories = readonly_partitioned_memoryset.query(partition_filter_mode="only_global")
-    assert len(memories) == 7  # There are 7 global memories in SAMPLE_DATA
-    # All results should be global (partition_id is None)
-    assert all(memory.partition_id is None for memory in memories)
-
-
-def test_query_memoryset_with_partition_filter_mode_include_global(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query including global memories - when no partition_id is specified,
-    # include_global seems to only return global memories
-    memories = readonly_partitioned_memoryset.query(partition_filter_mode="include_global")
-    # Based on actual behavior, this returns only global memories
-    assert len(memories) == 7
-    # All results should be global
-    assert all(memory.partition_id is None for memory in memories)
-
-
-def test_query_memoryset_with_partition_filter_mode_ignore_partitions(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query ignoring partition filtering entirely - returns all memories
-    memories = readonly_partitioned_memoryset.query(partition_filter_mode="ignore_partitions", limit=100)
-    assert len(memories) == 22  # All 22 memories
-    # Results can come from any partition or global
-    partition_ids = {memory.partition_id for memory in memories}
-    # Should have results from multiple partitions/global
-    assert len(partition_ids) >= 1
-    # Verify we have p1, p2, and global
-    assert "p1" in partition_ids
-    assert "p2" in partition_ids
-    assert None in partition_ids
-
-
-def test_query_memoryset_with_filters_and_partition_id(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with filters and partition_id
-    memories = readonly_partitioned_memoryset.query(filters=[("label", "==", 0)], partition_id="p1")
-    assert len(memories) > 0
-    # All results should match the filter and be from partition p1
-    assert all(memory.label == 0 for memory in memories)
-    assert all(memory.partition_id == "p1" for memory in memories)
-
-
-def test_query_memoryset_with_filters_and_partition_filter_mode(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with filters and partition_filter_mode - exclude_global requires partition_id
-    memories = readonly_partitioned_memoryset.query(
-        filters=[("label", "==", 1)], partition_id="p1", partition_filter_mode="exclude_global"
-    )
-    assert len(memories) > 0
-    # All results should match the filter and be from p1 (not global)
-    assert all(memory.label == 1 for memory in memories)
-    assert all(memory.partition_id == "p1" for memory in memories)
-
-
-def test_query_memoryset_with_limit_and_partition_id(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with limit and partition_id
-    memories = readonly_partitioned_memoryset.query(partition_id="p2", limit=3)
-    assert len(memories) == 3
-    # All results should be from partition p2
-    assert all(memory.partition_id == "p2" for memory in memories)
-
-
-def test_query_memoryset_with_offset_and_partition_id(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with offset and partition_id - use exclude_global to get only p1 memories
-    memories_page1 = readonly_partitioned_memoryset.query(
-        partition_id="p1", partition_filter_mode="exclude_global", limit=5
-    )
-    memories_page2 = readonly_partitioned_memoryset.query(
-        partition_id="p1", partition_filter_mode="exclude_global", offset=5, limit=5
-    )
-    assert len(memories_page1) == 5
-    assert len(memories_page2) == 3  # Only 3 remaining p1 memories (8 total - 5 = 3)
-    # All results should be from partition p1
-    assert all(memory.partition_id == "p1" for memory in memories_page1)
-    assert all(memory.partition_id == "p1" for memory in memories_page2)
-    # Results should be different (pagination works)
-    memory_ids_page1 = {memory.memory_id for memory in memories_page1}
-    memory_ids_page2 = {memory.memory_id for memory in memories_page2}
-    assert memory_ids_page1.isdisjoint(memory_ids_page2)
-
-
-def test_query_memoryset_with_partition_id_p2(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query a different partition to verify it works
-    # With include_global (default), it includes both p2 and global memories
-    memories = readonly_partitioned_memoryset.query(partition_id="p2")
-    assert len(memories) == 14  # 7 p2 + 7 global = 14
-    # Results should include both p2 and global memories
-    partition_ids = {memory.partition_id for memory in memories}
-    assert "p2" in partition_ids
-    assert None in partition_ids
-
-
-def test_query_memoryset_with_metadata_filter_and_partition_id(readonly_partitioned_memoryset: LabeledMemoryset):
-    # Query with metadata filter and partition_id
-    memories = readonly_partitioned_memoryset.query(filters=[("metadata.key", "==", "g1")], partition_id="p1")
-    assert len(memories) > 0
-    # All results should match the metadata filter and be from partition p1
-    assert all(memory.metadata.get("key") == "g1" for memory in memories)
-    assert all(memory.partition_id == "p1" for memory in memories)
-
-
-def test_query_memoryset_with_partition_filter_mode_only_global_and_filters(
-    readonly_partitioned_memoryset: LabeledMemoryset,
-):
-    # Query only global memories with filters
-    memories = readonly_partitioned_memoryset.query(
-        filters=[("metadata.key", "==", "g3")], partition_filter_mode="only_global"
-    )
-    assert len(memories) > 0
-    # All results should match the filter and be global
-    assert all(memory.metadata.get("key") == "g3" for memory in memories)
-    assert all(memory.partition_id is None for memory in memories)
-
-
 def test_labeled_memory_predictions_property(classification_model: ClassificationModel):
     """Test that LabeledMemory.predictions() only returns classification predictions."""
     # Given: A classification model with memories
@@ -850,7 +699,6 @@ def test_memory_predictions_expected_label_filter(classification_model: Classifi
 
 
 def test_insert_memories(writable_memoryset: LabeledMemoryset):
-    writable_memoryset.refresh()
     prev_length = writable_memoryset.length
     writable_memoryset.insert(
         [
@@ -859,10 +707,8 @@ def test_insert_memories(writable_memoryset: LabeledMemoryset):
         ],
         batch_size=1,
     )
-    writable_memoryset.refresh()
     assert writable_memoryset.length == prev_length + 2
     writable_memoryset.insert(dict(value="tomato soup is my favorite", label=0, key="test", source_id="test"))
-    writable_memoryset.refresh()
     assert writable_memoryset.length == prev_length + 3
     last_memory = writable_memoryset[-1]
     assert last_memory.value == "tomato soup is my favorite"
@@ -873,16 +719,16 @@ 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
 
     # 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"))
+    updated_count = writable_memoryset.update(dict(memory_id=memory_id, value="i love soup so much"))
+    assert updated_count == 1
+    updated_memory = writable_memoryset.get(memory_id)
     assert updated_memory.value == "i love soup so much"
     assert updated_memory.label == hf_dataset[0]["label"]
-    writable_memoryset.refresh()  # Refresh to ensure consistency after update
     assert writable_memoryset.get(memory_id).value == "i love soup so much"
 
     # test updating a memory instance
@@ -894,15 +740,51 @@ def test_update_memories(writable_memoryset: LabeledMemoryset, hf_dataset: Datas
 
     # test updating multiple memories
     memory_ids = [memory.memory_id for memory in writable_memoryset[:2]]
-    updated_memories = writable_memoryset.update(
+    updated_count = 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"),
         ],
         batch_size=1,
     )
-    assert updated_memories[0].value == "i love soup so much"
-    assert updated_memories[1].value == "cats are so cute"
+    assert updated_count == 2
+    assert writable_memoryset.get(memory_ids[0]).value == "i love soup so much"
+    assert writable_memoryset.get(memory_ids[1]).value == "cats are so cute"
+
+
+@skip_in_prod("Production memorysets do not have session consistency guarantees")
+def test_update_memory_metadata(writable_memoryset: LabeledMemoryset):
+    memory = writable_memoryset[0]
+    assert memory.metadata["key"] == "g1"
+
+    # Updating label without metadata should preserve existing metadata
+    updated = memory.update(label=1)
+    assert updated.label == 1
+    assert updated.metadata["key"] == "g1", "Metadata should be preserved when not specified"
+
+    # Updating metadata via top-level keys should update only specified keys
+    updated = memory.update(key="updated", new_key="added")
+    assert updated.metadata["key"] == "updated", "Existing metadata key should be preserved"
+    assert updated.metadata["new_key"] == "added", "New metadata key should be added"
+
+    # Can explicitly clear metadata by passing metadata={}
+    writable_memoryset.update(dict(memory_id=memory.memory_id, metadata={}))
+    updated = writable_memoryset.get(memory.memory_id)
+    assert updated.metadata == {}, "Metadata should be cleared when explicitly set to {}"
+
+
+def test_update_memories_by_filter(writable_memoryset: LabeledMemoryset):
+    source_ids_to_update = ["s1", "s3"]
+    initial_length = len(writable_memoryset)
+    updated_count = writable_memoryset.update(
+        filters=[("source_id", "in", source_ids_to_update)],
+        patch={"label": 1},
+    )
+    assert updated_count == 2
+    assert len(writable_memoryset) == initial_length
+    updated_memories = writable_memoryset.query(filters=[("source_id", "in", source_ids_to_update)])
+    assert len(updated_memories) == 2
+    assert all(memory.label == 1 for memory in updated_memories)
 
 
 def test_delete_memories(writable_memoryset: LabeledMemoryset):
@@ -911,17 +793,60 @@ def test_delete_memories(writable_memoryset: LabeledMemoryset):
     # test deleting a single memory
     prev_length = writable_memoryset.length
     memory_id = writable_memoryset[0].memory_id
-    writable_memoryset.delete(memory_id)
+    deleted_count = writable_memoryset.delete(memory_id)
+    assert deleted_count == 1
     with pytest.raises(LookupError):
         writable_memoryset.get(memory_id)
     assert writable_memoryset.length == prev_length - 1
 
     # test deleting multiple memories
     prev_length = writable_memoryset.length
-    writable_memoryset.delete([writable_memoryset[0].memory_id, writable_memoryset[1].memory_id], batch_size=1)
+    deleted_count = writable_memoryset.delete(
+        [writable_memoryset[0].memory_id, writable_memoryset[1].memory_id], batch_size=1
+    )
+    assert deleted_count == 2
     assert writable_memoryset.length == prev_length - 2
 
 
+def test_delete_memories_by_filter(writable_memoryset: LabeledMemoryset):
+    source_ids_to_delete = ["s1", "s3"]
+    initial_length = len(writable_memoryset)
+    memories_before = writable_memoryset.query(filters=[("source_id", "in", source_ids_to_delete)])
+    assert len(memories_before) == 2
+    deleted_count = writable_memoryset.delete(filters=[("source_id", "in", source_ids_to_delete)])
+    assert deleted_count == 2
+    assert len(writable_memoryset) == initial_length - 2
+    memories_after = writable_memoryset.query(filters=[("source_id", "in", source_ids_to_delete)])
+    assert len(memories_after) == 0
+
+
+def test_delete_all_memories(writable_memoryset: LabeledMemoryset):
+    initial_count = writable_memoryset.length
+    deleted_count = writable_memoryset.truncate()
+    assert deleted_count == initial_count
+    assert writable_memoryset.length == 0
+
+
+def test_delete_all_memories_from_partition(writable_memoryset: LabeledMemoryset):
+    memories_in_partition = len(writable_memoryset.query(filters=[("partition_id", "==", "p1")]))
+    assert memories_in_partition > 0
+    deleted_count = writable_memoryset.truncate(partition_id="p1")
+    assert deleted_count == memories_in_partition
+    memories_in_partition_after = len(writable_memoryset.query(filters=[("partition_id", "==", "p1")]))
+    assert memories_in_partition_after == 0
+    assert writable_memoryset.length > 0
+
+
+def test_delete_all_memories_from_global_partition(writable_memoryset: LabeledMemoryset):
+    memories_in_global_partition = len(writable_memoryset.query(filters=[("partition_id", "==", None)]))
+    assert memories_in_global_partition > 0
+    deleted_count = writable_memoryset.truncate(partition_id=None)
+    assert deleted_count == memories_in_global_partition
+    memories_in_global_partition_after = len(writable_memoryset.query(filters=[("partition_id", "==", None)]))
+    assert memories_in_global_partition_after == 0
+    assert writable_memoryset.length > 0
+
+
 def test_clone_memoryset(readonly_memoryset: LabeledMemoryset):
     cloned_memoryset = readonly_memoryset.clone(
         "test_cloned_memoryset", embedding_model=PretrainedEmbeddingModel.DISTILBERT
@@ -983,7 +908,6 @@ async def test_group_potential_duplicates(writable_memoryset: LabeledMemoryset):
 
 
 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
@@ -993,11 +917,7 @@ def test_get_cascading_edits_suggestions(writable_memoryset: LabeledMemoryset):
             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,
@@ -1005,8 +925,6 @@ def test_get_cascading_edits_suggestions(writable_memoryset: LabeledMemoryset):
         max_neighbors=10,
         max_validation_neighbors=5,
     )
-
-    # Validate the suggestions
     assert len(suggestions) == 1
     assert suggestions[0]["neighbor"]["value"] == mislabeled_soup_text
 
@@ -1075,13 +993,10 @@ def test_update_scored_memory(scored_memoryset: ScoredMemoryset):
 
 @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"
@@ -1091,8 +1006,6 @@ async def test_insert_memories_async_single(writable_memoryset: LabeledMemoryset
 
 @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(
@@ -1102,7 +1015,6 @@ async def test_insert_memories_async_batch(writable_memoryset: LabeledMemoryset)
         ]
     )
 
-    await writable_memoryset.arefresh()
     assert writable_memoryset.length == prev_length + 2
 
     # Check the inserted memories
@@ -1121,8 +1033,6 @@ async def test_insert_memories_async_batch(writable_memoryset: LabeledMemoryset)
 
 @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(
@@ -1131,7 +1041,6 @@ async def test_insert_memories_async_with_source_id(writable_memoryset: LabeledM
         )
     )
 
-    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"

orca_sdk/regression_model.py

@@ -212,7 +212,7 @@ class RegressionModel:
             List of handles to all regression models in the OrcaCloud
         """
         client = OrcaClient._resolve_client()
-        return [cls(metadata) for metadata in client.GET("/regression_model")]
+        return [cls(metadata) for metadata in client.GET("/regression_model", params={})]
 
     @classmethod
     def drop(cls, name_or_id: str, if_not_exists: DropMode = "error"):

orca_sdk/regression_model_test.py

@@ -90,6 +90,12 @@ def test_list_models_unauthorized(unauthorized_client, regression_model: Regress
         assert RegressionModel.all() == []
 
 
+def test_memoryset_regression_models_property(regression_model: RegressionModel, scored_memoryset: ScoredMemoryset):
+    models = scored_memoryset.regression_models
+    assert len(models) > 0
+    assert any(model.id == regression_model.id for model in models)
+
+
 def test_update_model_attributes(regression_model: RegressionModel):
     regression_model.description = "New description"
     assert regression_model.description == "New description"
@@ -144,6 +150,29 @@ def test_delete_memoryset_before_model_constraint_violation(hf_dataset):
         ScoredMemoryset.drop(memoryset.id)
 
 
+def test_delete_memoryset_with_model_cascade(hf_dataset):
+    """Test that cascade=False prevents deletion and cascade=True allows it."""
+    memoryset = ScoredMemoryset.from_hf_dataset("test_memoryset_cascade_delete_regression", hf_dataset)
+    model = RegressionModel.create("test_regression_model_cascade_delete", memoryset)
+
+    # Verify model exists
+    assert RegressionModel.open(model.name) is not None
+
+    # Without cascade, deletion should fail
+    with pytest.raises(RuntimeError):
+        ScoredMemoryset.drop(memoryset.id, cascade=False)
+
+    # Model should still exist
+    assert RegressionModel.exists(model.name)
+
+    # With cascade, deletion should succeed
+    ScoredMemoryset.drop(memoryset.id, cascade=True)
+
+    # Model should be deleted along with the memoryset
+    assert not RegressionModel.exists(model.name)
+    assert not ScoredMemoryset.exists(memoryset.name)
+
+
 @pytest.mark.parametrize("data_type", ["dataset", "datasource"])
 def test_evaluate(
     regression_model: RegressionModel,
@@ -593,3 +622,18 @@ def test_drop(regression_model):
     name = regression_model.name
     RegressionModel.drop(name)
     assert not RegressionModel.exists(name)
+
+
+def test_predict_with_empty_partition(fully_partitioned_regression_resources):
+    datasource, memoryset, regression_model = fully_partitioned_regression_resources
+
+    assert memoryset.length == 15
+
+    with pytest.raises(RuntimeError, match="lookup failed to return the correct number of memories"):
+        regression_model.predict("i love cats", partition_filter_mode="only_global")
+
+    with pytest.raises(RuntimeError, match="lookup failed to return the correct number of memories"):
+        regression_model.predict("i love cats", partition_filter_mode="exclude_global", partition_id="p_does_not_exist")
+
+    with pytest.raises(RuntimeError, match="lookup failed to return the correct number of memories"):
+        regression_model.evaluate(datasource, partition_filter_mode="only_global")

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, cast, overload
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Self, overload
 
 from httpx import Timeout
 

{orca_sdk-0.1.10.dist-info → orca_sdk-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca_sdk
-Version: 0.1.10
+Version: 0.1.11
 Summary: SDK for interacting with Orca Services
 License-Expression: Apache-2.0
 Author: Orca DB Inc.
@@ -11,16 +11,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: ui
 Requires-Dist: datasets (>=4.4.0,<5)
-Requires-Dist: gradio (>=6.0.0,<7)
+Requires-Dist: gradio (>=6.0.0,<7) ; extra == "ui"
 Requires-Dist: httpx (>=0.28.1)
 Requires-Dist: httpx-retries (>=0.4.3,<0.5.0)
 Requires-Dist: numpy (>=2.1.0,<3)
-Requires-Dist: pandas (>=2.2.3,<3)
-Requires-Dist: pyarrow (>=22.0.0,<23)
 Requires-Dist: python-dotenv (>=1.1.0)
 Requires-Dist: scikit-learn (>=1.6.1,<2)
-Requires-Dist: torch (>=2.8.0,<3)
 Description-Content-Type: text/markdown
 
 <!--

orca_sdk-0.1.11.dist-info/RECORD

@@ -0,0 +1,42 @@
+orca_sdk/__init__.py,sha256=xyjNwkLQXaX8A-UYgGwYDjv2btOXArT_yiMTfmW7KA8,1003
+orca_sdk/_shared/__init__.py,sha256=3Kt0Hu3QLI5FEp9nqGTxqAm3hAoBJKcagfaGQZ-lbJQ,223
+orca_sdk/_shared/metrics.py,sha256=faeL1B1ftmns1ikfKrIlU3xOn6j0iAGLNUupxvAFza8,24968
+orca_sdk/_shared/metrics_test.py,sha256=vDIXoj8EuuLcdPJz_7EiVPgQ-FXiVT81JG30jxsg9HM,20752
+orca_sdk/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orca_sdk/_utils/analysis_ui.py,sha256=gXwCR972kffPjPyajcy7m8HgPARSfhXwBJ0rnOmu_7k,9418
+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=tTZwGJQ1xkl12gyq6gQ0dRIgDFaNDy3Sde8A_SIfmxo,5726
+orca_sdk/_utils/data_parsing_disk_test.py,sha256=0IxyUNnawlNkqFwVEzIfXzuOympYkZRUP0rgxXhUrW4,3781
+orca_sdk/_utils/data_parsing_torch_test.py,sha256=LTCd1H9V9OtBARv_SmyLEYMeAYPohf8IHJjUzxenEC8,5155
+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=N4Cj7PUEx2UeV-4Mhk-ZaPegilssaKtElSACVhVrx1w,4965
+orca_sdk/_utils/tqdm_file_reader.py,sha256=Lw7Cg1UgNuRUoN6jjqZb-IlV00H-kbRcrZLdudr1GxE,324
+orca_sdk/_utils/value_parser.py,sha256=pw-suYXKuZQ7mGV-QUFcD3-fmp6lJKjnyQ3f_Hb3Gg8,2379
+orca_sdk/_utils/value_parser_test.py,sha256=dKni8W7KV2RgwuwK0ZN1SN-lH-W4DSSYkHdIXz52kys,1210
+orca_sdk/async_client.py,sha256=qaDmmXrCjPql_y-_kZMskFR0OlE8n1Y_pxtC1JwGbF0,138668
+orca_sdk/classification_model.py,sha256=rb1TmjCMrXqhpu4YKzT0ZOmzxjCV4_sc0gI9GONTc2o,50208
+orca_sdk/classification_model_test.py,sha256=OXKv4vfnV3NYVcZypuDztVKiEFB_0sYX3S-iU5wui38,39534
+orca_sdk/client.py,sha256=pm_NChTd3qKIwwCYoFUOj4sjZQvZJKYX1fbuT-H7hEc,137755
+orca_sdk/conftest.py,sha256=sPxOUGHU9kFznPJ_JZ6vZxY4m6e290ygvUf47P4pW6I,16926
+orca_sdk/credentials.py,sha256=2SwC3tq5akP-F_u2s4xMZDp8mlsKMUT1T5T9Z99-eSY,6588
+orca_sdk/credentials_test.py,sha256=K_1aNVCE5eoqX-tfh0G0_Vhqzhui4qcfYqWaDXfaqTA,4020
+orca_sdk/datasource.py,sha256=kPp3wOcjhTJsSwi51oK-y7tNYlz6jDAGKX9R7CoqHXs,22720
+orca_sdk/datasource_test.py,sha256=qoePaetnlgQZAx6y5SvCv9JMdBSvB-0TB1ug0_L0FuY,16786
+orca_sdk/embedding_model.py,sha256=hCl6vWpW7LXaM1ovGP6GzEp7sRdyJECS_sNc8kKBsvQ,28495
+orca_sdk/embedding_model_test.py,sha256=CERI3Lk7U32N3qwZyzip41Mw1Yb4sHWPEGeSulsaY88,9368
+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=JhIyusMelyg9ZinkoZKGtZIoxLANRk8XGZPlrVtX5ds,164318
+orca_sdk/memoryset_test.py,sha256=3PsqzYkd-QG2nKQiWyW4qxC7QVPY76ytAmxkJ5EWfUs,46407
+orca_sdk/regression_model.py,sha256=KHDVUZfnY5joRsO4HFg62LPeISH9j_cjyWW1SouuPHU,33971
+orca_sdk/regression_model_test.py,sha256=SIVWS8gSnmolVLEdJ4k6AYCV1bY4Hcjej43Ynw-TDzE,27398
+orca_sdk/telemetry.py,sha256=e_FiN3JFkQV62CKygd78BVQwfQwdClAZvV-XvLDEIGI,27828
+orca_sdk/telemetry_test.py,sha256=eT66C5lFdNg-pQdo2I__BP7Tn5fTc9aTkVo9ZhWwhU0,5519
+orca_sdk-0.1.11.dist-info/METADATA,sha256=54iBK4DRJ-rBkhYTnxTrKlnWQhMd7t9dXCY-iQ_XER8,3638
+orca_sdk-0.1.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+orca_sdk-0.1.11.dist-info/RECORD,,

orca_sdk-0.1.10.dist-info/RECORD

@@ -1,41 +0,0 @@
-orca_sdk/__init__.py,sha256=xyjNwkLQXaX8A-UYgGwYDjv2btOXArT_yiMTfmW7KA8,1003
-orca_sdk/_shared/__init__.py,sha256=3Kt0Hu3QLI5FEp9nqGTxqAm3hAoBJKcagfaGQZ-lbJQ,223
-orca_sdk/_shared/metrics.py,sha256=faeL1B1ftmns1ikfKrIlU3xOn6j0iAGLNUupxvAFza8,24968
-orca_sdk/_shared/metrics_test.py,sha256=vDIXoj8EuuLcdPJz_7EiVPgQ-FXiVT81JG30jxsg9HM,20752
-orca_sdk/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orca_sdk/_utils/analysis_ui.py,sha256=R0xc4RyJKyBHJEEF_ztI4Dm5w8Y1uF0Wpkn4LQgXqBE,9258
-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=5vaTpvUOS-ldlcgnSARYw7s9mce-imzkU7kA48-pdIM,5396
-orca_sdk/_utils/data_parsing_test.py,sha256=u7BEjxtsU9gMs3tAZI0lJ--vOLlwKwH3hemdCedzxA0,8826
-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=PM7N-ggmtucfcUF1vQGtTZOCJpSNTOgd7l3LDNF5kP4,137192
-orca_sdk/classification_model.py,sha256=C58euWnNvwXnthR9RtVVCOcgPEbxCjjp3sHMb86V6YA,50197
-orca_sdk/classification_model_test.py,sha256=ElqxtR6gNwwk8dNXwfwAhpT7l0ZIP3H4pHmOyFXyTWk,37370
-orca_sdk/client.py,sha256=SKZv3zGG6OwLe_FlB5wL2cxltOLPCcHvoo2CbMwyKgA,136241
-orca_sdk/conftest.py,sha256=0O1VY-SPKNAvi9fBLdY1RMnYVgZvMjP92y99bNAqqiw,12461
-orca_sdk/credentials.py,sha256=2SwC3tq5akP-F_u2s4xMZDp8mlsKMUT1T5T9Z99-eSY,6588
-orca_sdk/credentials_test.py,sha256=TLbXJMz3IlThvtSrHeLM7jRsKnrncA_ahOTpHg15Ei4,4089
-orca_sdk/datasource.py,sha256=Qn5QloE84UXeyPk2wcy1lWe5wmh1iDBS044eWnxck_E,22371
-orca_sdk/datasource_test.py,sha256=sCk3IcQJbDut5oN4Wf7PXhTxyMwalxMuCXJekSxy9wk,16665
-orca_sdk/embedding_model.py,sha256=vLGnlO9I-cN1lklNBl_LxZ8m9oK3vkegFOpvYYw8u8g,28038
-orca_sdk/embedding_model_test.py,sha256=Lc6fZ0ifT0hh6ldkUfjwMPcP6OgN0Umlzu8XDLs7UO4,8144
-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=06v34fHabpkEaOv9VCKc0NhpMi_mNZGbQP_9GiW_nuE,157157
-orca_sdk/memoryset_test.py,sha256=O2o42XETtffXtZy0kbLk2b8cUDXU-w2ZAzXLi5-vDPQ,51278
-orca_sdk/regression_model.py,sha256=AXRzJG15sDJQSiDCDfRdcLnZDNkJWORYjhHqKyyL-Fc,33960
-orca_sdk/regression_model_test.py,sha256=90EyrhaMk1kTf87RFkMNz1PTItmeUISs6AvHmyp08DU,25447
-orca_sdk/telemetry.py,sha256=ZyCMiyyo_SchjadWZH55TlLrC4Ucq5S316NbW26LL4Y,27834
-orca_sdk/telemetry_test.py,sha256=eT66C5lFdNg-pQdo2I__BP7Tn5fTc9aTkVo9ZhWwhU0,5519
-orca_sdk-0.1.10.dist-info/METADATA,sha256=j_TIalbL8oztP39lnXjyAI6Aosvb6rnJKUc3gcuxD0k,3710
-orca_sdk-0.1.10.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-orca_sdk-0.1.10.dist-info/RECORD,,