orca-sdk 0.1.0__py3-none-any.whl

orca_sdk/_generated_api_client/models/unauthorized_error_response.py

@@ -0,0 +1,80 @@
+"""
+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, Literal, Type, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="UnauthorizedErrorResponse")
+
+
+@_attrs_define
+class UnauthorizedErrorResponse:
+    """
+    Attributes:
+        status_code (Literal[403]):
+        reason (str):
+    """
+
+    status_code: Literal[403]
+    reason: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status_code = self.status_code
+
+        reason = self.reason
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status_code": status_code,
+                "reason": reason,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        status_code = cast(Literal[403], d.pop("status_code"))
+        if status_code != 403:
+            raise ValueError(f"status_code must match const 403, got '{status_code}'")
+
+        reason = d.pop("reason")
+
+        unauthorized_error_response = cls(
+            status_code=status_code,
+            reason=reason,
+        )
+
+        unauthorized_error_response.additional_properties = d
+        return unauthorized_error_response
+
+    @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/unprocessable_input_error_response.py

@@ -0,0 +1,94 @@
+"""
+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, List, Literal, Type, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.field_validation_error import FieldValidationError
+
+
+T = TypeVar("T", bound="UnprocessableInputErrorResponse")
+
+
+@_attrs_define
+class UnprocessableInputErrorResponse:
+    """
+    Attributes:
+        status_code (Literal[422]):
+        validation_issues (List['FieldValidationError']):
+    """
+
+    status_code: Literal[422]
+    validation_issues: List["FieldValidationError"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status_code = self.status_code
+
+        validation_issues = []
+        for validation_issues_item_data in self.validation_issues:
+            validation_issues_item = validation_issues_item_data.to_dict()
+            validation_issues.append(validation_issues_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status_code": status_code,
+                "validation_issues": validation_issues,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.field_validation_error import FieldValidationError
+
+        d = src_dict.copy()
+        status_code = cast(Literal[422], d.pop("status_code"))
+        if status_code != 422:
+            raise ValueError(f"status_code must match const 422, got '{status_code}'")
+
+        validation_issues = []
+        _validation_issues = d.pop("validation_issues")
+        for validation_issues_item_data in _validation_issues:
+            validation_issues_item = FieldValidationError.from_dict(validation_issues_item_data)
+
+            validation_issues.append(validation_issues_item)
+
+        unprocessable_input_error_response = cls(
+            status_code=status_code,
+            validation_issues=validation_issues,
+        )
+
+        unprocessable_input_error_response.additional_properties = d
+        return unprocessable_input_error_response
+
+    @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/update_prediction_request.py

@@ -0,0 +1,93 @@
+"""
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdatePredictionRequest")
+
+
+@_attrs_define
+class UpdatePredictionRequest:
+    """
+    Attributes:
+        expected_label (Union[None, Unset, int]):
+        tags (Union[Unset, List[str]]):
+    """
+
+    expected_label: Union[None, Unset, int] = UNSET
+    tags: Union[Unset, List[str]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        expected_label: Union[None, Unset, int]
+        if isinstance(self.expected_label, Unset):
+            expected_label = UNSET
+        else:
+            expected_label = self.expected_label
+
+        tags: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if expected_label is not UNSET:
+            field_dict["expected_label"] = expected_label
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+
+        def _parse_expected_label(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        expected_label = _parse_expected_label(d.pop("expected_label", UNSET))
+
+        tags = cast(List[str], d.pop("tags", UNSET))
+
+        update_prediction_request = cls(
+            expected_label=expected_label,
+            tags=tags,
+        )
+
+        update_prediction_request.additional_properties = d
+        return update_prediction_request
+
+    @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/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

orca_sdk/_generated_api_client/types.py

@@ -0,0 +1,56 @@
+"""
+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/types.py.jinja
+
+The main change is:
+- Make Response's parsed type required
+"""
+
+from collections.abc import MutableMapping
+from http import HTTPStatus
+from typing import BinaryIO, Generic, Literal, Optional, TypeVar
+
+from attrs import define
+
+""" Contains some shared types for properties """
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+FileJsonType = tuple[Optional[str], BinaryIO, Optional[str]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileJsonType:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T
+
+
+__all__ = ["UNSET", "File", "FileJsonType", "Response", "Unset"]

orca_sdk/_utils/analysis_ui.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import TypedDict, cast
+
+import gradio as gr
+
+from ..labeled_memoryset import LabeledMemory, LabeledMemoryset
+
+# Suppress all httpx logs
+logging.getLogger("httpx").setLevel(logging.CRITICAL)
+
+# Optionally suppress other libraries Gradio might use
+logging.getLogger("gradio").setLevel(logging.CRITICAL)
+
+
+class RelabelStatus(TypedDict):
+    memory_id: str
+    approved: bool
+    new_label: int | None
+    full_memory: LabeledMemory
+
+
+def display_suggested_memory_relabels(memoryset: LabeledMemoryset):
+    suggested_relabels = memoryset.query(
+        filters=[("metrics.neighbor_predicted_label_matches_current_label", "==", False)]
+    )
+    # Sort memories by confidence score (higher confidence first)
+    suggested_relabels.sort(
+        key=lambda x: (x.metrics and x.metrics.neighbor_predicted_label_confidence) or 0.0, reverse=True
+    )
+
+    def update_approved(memory_id: str, selected: bool, current_memory_relabel_map: dict[str, RelabelStatus]):
+        current_memory_relabel_map[memory_id]["approved"] = selected
+        return current_memory_relabel_map
+
+    def approve_all(current_all_approved, selected: bool):
+        for mem_id in current_all_approved:
+            current_all_approved[mem_id]["approved"] = selected
+        return current_all_approved, selected
+
+    def apply_selected(current_memory_relabel_map: dict[str, RelabelStatus], progress=gr.Progress(track_tqdm=True)):
+        progress(0, desc="Processing label updates...")
+        to_be_deleted = []
+        approved_relabels = [mem for mem in current_memory_relabel_map.values() if mem["approved"]]
+        for memory in progress.tqdm(approved_relabels, desc="Applying label updates..."):
+            memory = cast(RelabelStatus, memory)
+            new_label = memory["new_label"]
+            assert isinstance(new_label, int)
+            memoryset.update(
+                {
+                    "memory_id": memory["memory_id"],
+                    "label": new_label,
+                }
+            )
+            to_be_deleted.append(memory["memory_id"])
+        for mem_id in to_be_deleted:
+            del current_memory_relabel_map[mem_id]
+        return (
+            current_memory_relabel_map,
+            gr.HTML(
+                f"<h1 style='display: inline-block; position: fixed; z-index: 1000; left: 36px; top: 14px;'>Suggested Label Updates: {len(current_memory_relabel_map)}</h1>",
+            ),
+        )
+
+    def update_label(mem_id: str, label: str, current_memory_relabel_map: dict[str, RelabelStatus]):
+        match = re.search(r".*\((\d+)\)$", label)
+        if match:
+            new_label = int(match.group(1))
+            current_memory_relabel_map[mem_id]["new_label"] = new_label
+            confidence = "--"
+            current_metrics = current_memory_relabel_map[mem_id]["full_memory"].metrics
+            if current_metrics and new_label == current_metrics.neighbor_predicted_label:
+                confidence = (
+                    round(current_metrics.neighbor_predicted_label_confidence or 0.0, 2) if current_metrics else 0
+                )
+            return (
+                gr.HTML(
+                    f"<p style='font-size: 10px; color: #888;'>Confidence: {confidence}</p>",
+                    elem_classes="no-padding",
+                ),
+                current_memory_relabel_map,
+            )
+        else:
+            logging.error(f"Invalid label format: {label}")
+
+    with gr.Blocks(
+        fill_width=True,
+        title="Suggested Label Updates",
+        css_paths=str(Path(__file__).parent / "analysis_ui_style.css"),
+    ) as demo:
+        label_names = memoryset.label_names
+
+        refresh = gr.State(False)
+        all_approved = gr.State(False)
+        memory_relabel_map = gr.State(
+            {
+                mem.memory_id: RelabelStatus(
+                    memory_id=mem.memory_id,
+                    approved=False,
+                    new_label=(
+                        mem.metrics.neighbor_predicted_label
+                        if (mem.metrics and isinstance(mem.metrics.neighbor_predicted_label, int))
+                        else None
+                    ),
+                    full_memory=mem,
+                )
+                for mem in suggested_relabels
+            }
+        )
+
+        @gr.render(
+            inputs=[memory_relabel_map, all_approved],
+            triggers=[demo.load, refresh.change, all_approved.change, memory_relabel_map.change],
+        )
+        def render_table(current_memory_relabel_map, current_all_approved):
+            if len(current_memory_relabel_map):
+                with gr.Group(elem_classes="header"):
+                    title = gr.HTML(
+                        f"<h1 style='display: inline-block; position: fixed; z-index: 1000; left: 36px; top: 14px;'>Suggested Label Updates: {len(current_memory_relabel_map)}</h1>"
+                    )
+                    apply_selected_button = gr.Button("Apply Selected", elem_classes="button")
+                    apply_selected_button.click(
+                        apply_selected,
+                        inputs=[memory_relabel_map],
+                        outputs=[memory_relabel_map, title],
+                        show_progress="full",
+                    )
+                with gr.Row(equal_height=True, variant="panel", elem_classes="margin-top"):
+                    with gr.Column(scale=9):
+                        gr.Markdown("**Value**")
+                    with gr.Column(scale=2, min_width=90):
+                        gr.Markdown("**Current Label**")
+                    with gr.Column(scale=3, min_width=150):
+                        gr.Markdown("**Suggested Label**", elem_classes="centered")
+                    with gr.Column(scale=2, min_width=50):
+                        approve_all_checkbox = gr.Checkbox(
+                            show_label=False,
+                            value=current_all_approved,
+                            label="",
+                            container=False,
+                            elem_classes="centered",
+                        )
+                        approve_all_checkbox.change(
+                            approve_all,
+                            inputs=[memory_relabel_map, approve_all_checkbox],
+                            outputs=[memory_relabel_map, all_approved],
+                        )
+                for i, memory_relabel in enumerate(current_memory_relabel_map.values()):
+                    mem = memory_relabel["full_memory"]
+                    with gr.Row(equal_height=True, variant="panel", elem_classes="white" if i % 2 == 0 else None):
+                        with gr.Column(scale=9):
+                            assert isinstance(mem.value, str)
+                            gr.Markdown(mem.value, label="Value", height=50)
+                        with gr.Column(scale=2, min_width=90):
+                            gr.Markdown(f"{mem.label_name} ({mem.label})", label="Current Label", height=50)
+                        with gr.Column(scale=3, min_width=150):
+                            dropdown = gr.Dropdown(
+                                choices=[f"{label_name} ({i})" for i, label_name in enumerate(label_names)],
+                                label="SuggestedLabel",
+                                value=f"{label_names[mem.metrics.neighbor_predicted_label]} ({mem.metrics.neighbor_predicted_label})",
+                                interactive=True,
+                                container=False,
+                            )
+                            confidence = gr.HTML(
+                                f"<p style='font-size: 10px; color: #888;'>Confidence: {mem.metrics.neighbor_predicted_label_confidence:.2f}</p>",
+                                elem_classes="no-padding",
+                            )
+                            dropdown.change(
+                                lambda val, map, mem_id=mem.memory_id: update_label(mem_id, val, map),
+                                inputs=[dropdown, memory_relabel_map],
+                                outputs=[confidence, memory_relabel_map],
+                            )
+                        with gr.Column(scale=2, min_width=50):
+                            checkbox = gr.Checkbox(
+                                show_label=False,
+                                label="",
+                                value=current_memory_relabel_map[mem.memory_id]["approved"],
+                                container=False,
+                                elem_classes="centered",
+                                interactive=True,
+                            )
+                            checkbox.input(
+                                lambda selected, map, mem_id=mem.memory_id: update_approved(mem_id, selected, map),
+                                inputs=[checkbox, memory_relabel_map],
+                                outputs=[memory_relabel_map],
+                            )
+
+            else:
+                gr.HTML("<h1>No suggested label updates</h1>")
+
+    demo.launch()

orca_sdk/_utils/analysis_ui_style.css

@@ -0,0 +1,54 @@
+.white {
+  background-color: white;
+}
+.centered input {
+  margin: auto;
+}
+.centered p {
+  text-align: center;
+}
+.button {
+  display: inline-block;
+  max-width: 250px;
+  background-color: #2b9a66;
+  color: white;
+  position: fixed;
+  z-index: 1000;
+  right: 36px;
+  border-radius: 8px;
+  top: 12px;
+}
+.margin-top {
+  margin-top: 60px;
+}
+.header {
+  position: fixed;
+  z-index: 1000;
+  height: 64px;
+  left: 0;
+  top: 0;
+  border-radius: 0;
+}
+
+input[type='checkbox']:checked,
+input[type='checkbox']:checked:hover,
+input[type='checkbox']:checked:focus {
+  background-color: #2b9a66;
+  border-color: #2b9a66;
+}
+input[type='checkbox']:focus {
+  border-color: #2b9a66;
+}
+.html-container:has(.no-padding) {
+  padding: 0;
+}
+
+.progress-bar {
+  background-color: #2b9a66;
+}
+.header .full {
+  position: fixed !important;
+  z-index: 1100;
+  background-color: #e4e4e7;
+  height: 68px;
+}

orca_sdk/_utils/auth.py

@@ -0,0 +1,63 @@
+"""This module contains internal utils for managing api keys in tests"""
+
+import logging
+import os
+from typing import List
+
+from dotenv import load_dotenv
+
+from .._generated_api_client.api import (
+    check_authentication,
+    create_api_key,
+    delete_api_key,
+    delete_org,
+    list_api_keys,
+)
+from .._generated_api_client.client import headers_context, set_base_url, set_headers
+from .._generated_api_client.models import CreateApiKeyRequest
+from .._generated_api_client.models.api_key_metadata import ApiKeyMetadata
+from .common import DropMode
+
+load_dotenv()  # this needs to be here to ensure env is populated before accessing it
+_ORCA_ROOT_ACCESS_API_KEY = os.environ.get("ORCA_ROOT_ACCESS_API_KEY", "00000000-0000-0000-0000-000000000000")
+
+
+def _create_api_key(org_id: str, name: str) -> str:
+    """Creates an API key for the given organization"""
+    with headers_context({"Api-Key": _ORCA_ROOT_ACCESS_API_KEY, "Org-Id": org_id}):
+        res = create_api_key(body=CreateApiKeyRequest(name=name))
+        return res.api_key
+
+
+def _list_api_keys(org_id: str) -> List[ApiKeyMetadata]:
+    """Lists all API keys for the given organization"""
+    with headers_context({"Api-Key": _ORCA_ROOT_ACCESS_API_KEY, "Org-Id": org_id}):
+        return list_api_keys()
+
+
+def _delete_api_key(org_id: str, name: str, if_not_exists: DropMode = "error") -> None:
+    """Deletes the API key with the given name from the organization"""
+    with headers_context({"Api-Key": _ORCA_ROOT_ACCESS_API_KEY, "Org-Id": org_id}):
+        try:
+            delete_api_key(name_or_id=name)
+        except LookupError:
+            if if_not_exists == "error":
+                raise
+
+
+def _delete_org(org_id: str) -> None:
+    """Deletes the organization"""
+    with headers_context({"Api-Key": _ORCA_ROOT_ACCESS_API_KEY, "Org-Id": org_id}):
+        delete_org()
+
+
+def _authenticate_local_api(org_id: str = "10e50000-0000-4000-a000-a78dca14af3a", api_key_name: str = "local") -> None:
+    """Connect to the local API at http://localhost:1584/ and authenticate with a new API key"""
+    set_base_url("http://localhost:1584/")
+    _delete_api_key(org_id, api_key_name, if_not_exists="ignore")
+    set_headers({"Api-Key": _create_api_key(org_id, api_key_name)})
+    check_authentication()
+    logging.info(f"Authenticated against local API at 'http://localhost:1584' with '{api_key_name}' API key")
+
+
+__all__ = ["_create_api_key", "_delete_api_key", "_delete_org", "_list_api_keys", "_authenticate_local_api"]

orca_sdk/_utils/auth_test.py

@@ -0,0 +1,31 @@
+from uuid import uuid4
+
+from ..orca_credentials import OrcaCredentials
+from .auth import _create_api_key, _delete_api_key, _delete_org, _list_api_keys
+
+
+def test_list_api_keys(org_id):
+    assert len(_list_api_keys(org_id)) >= 1
+
+
+def test_create_api_key(org_id):
+    name = f"test-{uuid4().hex[:8]}"
+    api_key = _create_api_key(org_id=org_id, name=name)
+    assert api_key is not None
+    assert name in [api_key.name for api_key in OrcaCredentials.list_api_keys()]
+
+
+def test_delete_api_key(org_id):
+    name = f"test-{uuid4().hex[:8]}"
+    api_key = _create_api_key(org_id=org_id, name=name)
+    assert api_key is not None
+    assert name in [api_key.name for api_key in OrcaCredentials.list_api_keys()]
+    _delete_api_key(org_id=org_id, name=name)
+    assert name not in [api_key.name for api_key in OrcaCredentials.list_api_keys()]
+
+
+def test_delete_org(other_org_id):
+    _create_api_key(org_id=other_org_id, name="test")
+    assert len(_list_api_keys(other_org_id)) >= 1
+    _delete_org(other_org_id)
+    assert len(_list_api_keys(other_org_id)) == 0