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

orca_sdk/_generated_api_client/models/http_validation_error.py

@@ -0,0 +1,86 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error import ValidationError
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """
+    Attributes:
+        detail (Union[Unset, List['ValidationError']]):
+    """
+
+    detail: Union[Unset, List["ValidationError"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+
+        d = src_dict.copy()
+        detail = []
+        _detail = d.pop("detail", UNSET)
+        for detail_item_data in _detail or []:
+            detail_item = ValidationError.from_dict(detail_item_data)
+
+            detail.append(detail_item)
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

orca_sdk/_generated_api_client/models/list_predictions_request.py

@@ -10,11 +10,13 @@ The main change is:
 
 # flake8: noqa: C901
 
+import datetime
 from enum import Enum
 from typing import Any, List, Type, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
+from dateutil.parser import isoparse
 
 from ..models.prediction_sort_item_item_type_0 import PredictionSortItemItemType0
 from ..models.prediction_sort_item_item_type_1 import PredictionSortItemItemType1
@@ -30,6 +32,8 @@ class ListPredictionsRequest:
         model_id (Union[None, Unset, str]):
         tag (Union[None, Unset, str]):
         prediction_ids (Union[List[str], None, Unset]):
+        start_timestamp (Union[None, Unset, datetime.datetime]):
+        end_timestamp (Union[None, Unset, datetime.datetime]):
         limit (Union[None, Unset, int]):
         offset (Union[None, Unset, int]):  Default: 0.
         sort (Union[Unset, List[List[Union[PredictionSortItemItemType0, PredictionSortItemItemType1]]]]):
@@ -39,6 +43,8 @@ class ListPredictionsRequest:
     model_id: Union[None, Unset, str] = UNSET
     tag: Union[None, Unset, str] = UNSET
     prediction_ids: Union[List[str], None, Unset] = UNSET
+    start_timestamp: Union[None, Unset, datetime.datetime] = UNSET
+    end_timestamp: Union[None, Unset, datetime.datetime] = UNSET
     limit: Union[None, Unset, int] = UNSET
     offset: Union[None, Unset, int] = 0
     sort: Union[Unset, List[List[Union[PredictionSortItemItemType0, PredictionSortItemItemType1]]]] = UNSET
@@ -67,6 +73,22 @@ class ListPredictionsRequest:
         else:
             prediction_ids = self.prediction_ids
 
+        start_timestamp: Union[None, Unset, str]
+        if isinstance(self.start_timestamp, Unset):
+            start_timestamp = UNSET
+        elif isinstance(self.start_timestamp, datetime.datetime):
+            start_timestamp = self.start_timestamp.isoformat()
+        else:
+            start_timestamp = self.start_timestamp
+
+        end_timestamp: Union[None, Unset, str]
+        if isinstance(self.end_timestamp, Unset):
+            end_timestamp = UNSET
+        elif isinstance(self.end_timestamp, datetime.datetime):
+            end_timestamp = self.end_timestamp.isoformat()
+        else:
+            end_timestamp = self.end_timestamp
+
         limit: Union[None, Unset, int]
         if isinstance(self.limit, Unset):
             limit = UNSET
@@ -118,6 +140,10 @@ class ListPredictionsRequest:
             field_dict["tag"] = tag
         if prediction_ids is not UNSET:
             field_dict["prediction_ids"] = prediction_ids
+        if start_timestamp is not UNSET:
+            field_dict["start_timestamp"] = start_timestamp
+        if end_timestamp is not UNSET:
+            field_dict["end_timestamp"] = end_timestamp
         if limit is not UNSET:
             field_dict["limit"] = limit
         if offset is not UNSET:
@@ -168,6 +194,40 @@ class ListPredictionsRequest:
 
         prediction_ids = _parse_prediction_ids(d.pop("prediction_ids", UNSET))
 
+        def _parse_start_timestamp(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                start_timestamp_type_0 = isoparse(data)
+
+                return start_timestamp_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        start_timestamp = _parse_start_timestamp(d.pop("start_timestamp", UNSET))
+
+        def _parse_end_timestamp(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                end_timestamp_type_0 = isoparse(data)
+
+                return end_timestamp_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        end_timestamp = _parse_end_timestamp(d.pop("end_timestamp", UNSET))
+
         def _parse_limit(data: object) -> Union[None, Unset, int]:
             if data is None:
                 return data
@@ -231,6 +291,8 @@ class ListPredictionsRequest:
             model_id=model_id,
             tag=tag,
             prediction_ids=prediction_ids,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
             limit=limit,
             offset=offset,
             sort=sort,

orca_sdk/_generated_api_client/models/memoryset_analysis_configs.py

@@ -13,7 +13,6 @@ The main change is:
 from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
-from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
@@ -44,7 +43,6 @@ class MemorysetAnalysisConfigs:
     duplicate: Union["MemorysetDuplicateAnalysisConfig", None, Unset] = UNSET
     projection: Union["MemorysetProjectionAnalysisConfig", None, Unset] = UNSET
     cluster: Union["MemorysetClusterAnalysisConfig", None, Unset] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         from ..models.memoryset_cluster_analysis_config import MemorysetClusterAnalysisConfig
@@ -94,7 +92,6 @@ class MemorysetAnalysisConfigs:
             cluster = self.cluster
 
         field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
         field_dict.update({})
         if neighbor is not UNSET:
             field_dict["neighbor"] = neighbor
@@ -212,21 +209,4 @@ class MemorysetAnalysisConfigs:
             cluster=cluster,
         )
 
-        memoryset_analysis_configs.additional_properties = d
         return memoryset_analysis_configs
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

orca_sdk/_generated_api_client/models/pretrained_embedding_model_name.py

@@ -2,11 +2,16 @@ from enum import Enum
 
 
 class PretrainedEmbeddingModelName(str, Enum):
+    BGE_BASE = "BGE_BASE"
     CDE_SMALL = "CDE_SMALL"
     CLIP_BASE = "CLIP_BASE"
     DISTILBERT = "DISTILBERT"
+    E5_LARGE = "E5_LARGE"
+    GIST_LARGE = "GIST_LARGE"
     GTE_BASE = "GTE_BASE"
     GTE_SMALL = "GTE_SMALL"
+    MXBAI_LARGE = "MXBAI_LARGE"
+    QWEN2_1_5B = "QWEN2_1_5B"
 
     def __str__(self) -> str:
         return str(self.value)

orca_sdk/_generated_api_client/models/validation_error.py

@@ -0,0 +1,99 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+from typing import Any, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ValidationError")
+
+
+@_attrs_define
+class ValidationError:
+    """
+    Attributes:
+        loc (List[Union[int, str]]):
+        msg (str):
+        type (str):
+    """
+
+    loc: List[Union[int, str]]
+    msg: str
+    type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        loc = []
+        for loc_item_data in self.loc:
+            loc_item: Union[int, str]
+            loc_item = loc_item_data
+            loc.append(loc_item)
+
+        msg = self.msg
+
+        type = self.type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "loc": loc,
+                "msg": msg,
+                "type": type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        loc = []
+        _loc = d.pop("loc")
+        for loc_item_data in _loc:
+
+            def _parse_loc_item(data: object) -> Union[int, str]:
+                return cast(Union[int, str], data)
+
+            loc_item = _parse_loc_item(loc_item_data)
+
+            loc.append(loc_item)
+
+        msg = d.pop("msg")
+
+        type = d.pop("type")
+
+        validation_error = cls(
+            loc=loc,
+            msg=msg,
+            type=type,
+        )
+
+        validation_error.additional_properties = d
+        return validation_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

orca_sdk/classification_model.py

@@ -382,7 +382,9 @@ class ClassificationModel:
                 expected_labels=(
                     expected_labels
                     if isinstance(expected_labels, list)
-                    else [expected_labels] if expected_labels is not None else None
+                    else [expected_labels]
+                    if expected_labels is not None
+                    else None
                 ),
                 tags=list(tags),
                 save_telemetry=save_telemetry,
@@ -403,8 +405,9 @@ class ClassificationModel:
                 memoryset=self.memoryset,
                 model=self,
                 logits=prediction.logits,
+                input_value=input_value,
             )
-            for prediction in response
+            for prediction, input_value in zip(response, value if isinstance(value, list) else [value])
         ]
         self._last_prediction_was_batch = isinstance(value, list)
         self._last_prediction = predictions[-1]
@@ -480,7 +483,6 @@ class ClassificationModel:
         predictions: list[LabelPrediction],
         expected_labels: list[int],
     ) -> ClassificationEvaluationResult:
-
         targets_array = np.array(expected_labels)
         predictions_array = np.array([p.label for p in predictions])
 

orca_sdk/classification_model_test.py

@@ -1,3 +1,5 @@
+import logging
+import os
 from uuid import uuid4
 
 import numpy as np
@@ -9,6 +11,11 @@ from .datasource import Datasource
 from .embedding_model import PretrainedEmbeddingModel
 from .memoryset import LabeledMemoryset
 
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+
+SKIP_IN_GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true"
+
 
 def test_create_model(model: ClassificationModel, readonly_memoryset: LabeledMemoryset):
     assert model is not None
@@ -338,3 +345,42 @@ def test_last_prediction_with_single(model: ClassificationModel):
     assert model.last_prediction.prediction_id == prediction.prediction_id
     assert model.last_prediction.input_value == "Do you love soup?"
     assert model._last_prediction_was_batch is False
+
+
+@pytest.mark.skipif(
+    SKIP_IN_GITHUB_ACTIONS, reason="Skipping explanation test because in CI we don't have Anthropic API key"
+)
+def test_explain(writable_memoryset: LabeledMemoryset):
+
+    writable_memoryset.analyze(
+        {"name": "neighbor", "neighbor_counts": [1, 3]},
+        lookup_count=3,
+    )
+
+    model = ClassificationModel.create(
+        "test_model_for_explain",
+        writable_memoryset,
+        num_classes=2,
+        memory_lookup_count=3,
+        description="This is a test model for explain",
+    )
+
+    predictions = model.predict(["Do you love soup?", "Are cats cute?"])
+    assert len(predictions) == 2
+
+    try:
+        explanation = predictions[0].explanation
+        print(explanation)
+        assert explanation is not None
+        assert len(explanation) > 10
+        assert "soup" in explanation.lower()
+    except Exception as e:
+        if "ANTHROPIC_API_KEY" in str(e):
+            logging.info("Skipping explanation test because ANTHROPIC_API_KEY is not set on server")
+        else:
+            raise e
+    finally:
+        try:
+            ClassificationModel.drop("test_model_for_explain")
+        except Exception as e:
+            logging.info(f"Failed to drop test model for explain: {e}")

orca_sdk/conftest.py

@@ -176,6 +176,7 @@ def writable_memoryset(datasource: Datasource, api_key: str) -> Generator[Labele
 
             if memory_ids:
                 memoryset.delete(memory_ids)
+            memoryset.refresh()
             assert len(memoryset) == 0
             memoryset.insert(SAMPLE_DATA)
         # If the test dropped the memoryset, do nothing — it will be recreated on the next use.

orca_sdk/datasource.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import tempfile
+import zipfile
 from datetime import datetime
 from os import PathLike
 from pathlib import Path
@@ -84,6 +85,39 @@ class Datasource:
             + "})"
         )
 
+    def download(self, output_path: str | PathLike) -> None:
+        """
+        Download the datasource as a ZIP and extract them to a specified path.
+
+        Params:
+            output_path: The local file path or directory where the downloaded files will be saved.
+
+        Returns:
+            None
+
+        Raises:
+            RuntimeError: If the download fails.
+        """
+
+        output_path = Path(output_path)
+        client = get_client().get_httpx_client()
+        url = f"/datasource/{self.id}/download"
+        response = client.get(url)
+        if response.status_code == 404:
+            raise LookupError(f"Datasource {self.id} not found")
+        if response.status_code != 200:
+            raise RuntimeError(f"Failed to download datasource: {response.status_code} {response.text}")
+
+        with tempfile.NamedTemporaryFile(suffix=".zip") as tmp_zip:
+            tmp_zip.write(response.content)
+            tmp_zip.flush()
+            with zipfile.ZipFile(tmp_zip.name, "r") as zf:
+                output_path.mkdir(parents=True, exist_ok=True)
+                for file in zf.namelist():
+                    out_file = output_path / Path(file).name
+                    with zf.open(file) as af:
+                        out_file.write_bytes(af.read())
+
     @classmethod
     def from_hf_dataset(
         cls, name: str, dataset: Dataset, if_exists: CreateMode = "error", description: str | None = None

orca_sdk/datasource_test.py

@@ -1,3 +1,5 @@
+import os
+import tempfile
 from uuid import uuid4
 
 import pytest
@@ -94,3 +96,10 @@ def test_drop_datasource_unauthorized(datasource, unauthorized):
 def test_drop_datasource_invalid_input():
     with pytest.raises(ValueError, match=r"Invalid input:.*"):
         Datasource.drop("not valid id")
+
+
+def test_download_datasource(datasource):
+    with tempfile.TemporaryDirectory() as temp_dir:
+        output_path = os.path.join(temp_dir, "datasource.zip")
+        datasource.download(output_path)
+        assert os.path.exists(output_path)

orca_sdk/memoryset_test.py

@@ -281,8 +281,10 @@ def test_insert_memories(writable_memoryset: LabeledMemoryset):
             dict(value="cats are fun to play with", label=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"

orca_sdk/telemetry.py

@@ -149,6 +149,7 @@ class LabelPrediction:
         model: ClassificationModel | str,
         telemetry: LabelPredictionWithMemoriesAndFeedback | None = None,
         logits: list[float] | None = None,
+        input_value: str | list[list[float]] | None = None,
     ):
         # for internal use only, do not document
         from .classification_model import ClassificationModel
@@ -162,15 +163,14 @@ class LabelPrediction:
         self.model = ClassificationModel.open(model) if isinstance(model, str) else model
         self.__telemetry = telemetry if telemetry else None
         self.logits = logits
+        self._input_value = input_value
 
     def __repr__(self):
         return (
             "LabelPrediction({"
             + f"label: <{self.label_name}: {self.label}>, "
             + f"confidence: {self.confidence:.2f}, "
-            + f"anomaly_score: {self.anomaly_score:.2f}, "
-            if self.anomaly_score is not None
-            else ""
+            + (f"anomaly_score: {self.anomaly_score:.2f}, " if self.anomaly_score is not None else "")
             + f"input_value: '{str(self.input_value)[:100] + '...' if len(str(self.input_value)) > 100 else self.input_value}'"
             + "})"
         )
@@ -188,6 +188,8 @@ class LabelPrediction:
 
     @property
     def input_value(self) -> str | list[list[float]] | None:
+        if self._input_value is not None:
+            return self._input_value
         return self._telemetry.input_value
 
     @property

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

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