orca-sdk 0.0.95__py3-none-any.whl → 0.0.97__py3-none-any.whl

orca_sdk/_generated_api_client/models/telemetry_sort_options.py

@@ -11,12 +11,15 @@ The main change is:
 # flake8: noqa: C901
 
 from enum import Enum
-from typing import Any, List, Literal, Type, TypeVar, Union, cast
+from typing import Any, List, Type, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.telemetry_field_type_0_item_type_0 import TelemetryFieldType0ItemType0
 from ..models.telemetry_field_type_0_item_type_2 import TelemetryFieldType0ItemType2
+from ..models.telemetry_field_type_1_item_type_0 import TelemetryFieldType1ItemType0
+from ..models.telemetry_field_type_1_item_type_1 import TelemetryFieldType1ItemType1
 from ..models.telemetry_sort_options_direction import TelemetrySortOptionsDirection
 
 T = TypeVar("T", bound="TelemetrySortOptions")
@@ -26,25 +29,31 @@ T = TypeVar("T", bound="TelemetrySortOptions")
 class TelemetrySortOptions:
     """
     Attributes:
-        field (Union[List[Union[Literal['count'], Literal['lookup']]], List[Union[Literal['feedback_metrics'],
-            TelemetryFieldType0ItemType2, str]]]):
+        field (Union[List[Union[TelemetryFieldType0ItemType0, TelemetryFieldType0ItemType2, str]],
+            List[Union[TelemetryFieldType1ItemType0, TelemetryFieldType1ItemType1]]]):
         direction (TelemetrySortOptionsDirection):
     """
 
     field: Union[
-        List[Union[Literal["count"], Literal["lookup"]]],
-        List[Union[Literal["feedback_metrics"], TelemetryFieldType0ItemType2, str]],
+        List[Union[TelemetryFieldType0ItemType0, TelemetryFieldType0ItemType2, str]],
+        List[Union[TelemetryFieldType1ItemType0, TelemetryFieldType1ItemType1]],
     ]
     direction: TelemetrySortOptionsDirection
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        field: Union[List[Union[Literal["count"], Literal["lookup"]]], List[Union[Literal["feedback_metrics"], str]]]
+        field: List[str]
         if isinstance(self.field, list):
             field = []
             for componentsschemas_telemetry_field_type_0_item_data in self.field:
-                componentsschemas_telemetry_field_type_0_item: Union[Literal["feedback_metrics"], str]
-                if isinstance(componentsschemas_telemetry_field_type_0_item_data, TelemetryFieldType0ItemType2):
+                componentsschemas_telemetry_field_type_0_item: str
+                if isinstance(componentsschemas_telemetry_field_type_0_item_data, TelemetryFieldType0ItemType0):
+                    componentsschemas_telemetry_field_type_0_item = (
+                        componentsschemas_telemetry_field_type_0_item_data.value
+                        if isinstance(componentsschemas_telemetry_field_type_0_item_data, Enum)
+                        else componentsschemas_telemetry_field_type_0_item_data
+                    )
+                elif isinstance(componentsschemas_telemetry_field_type_0_item_data, TelemetryFieldType0ItemType2):
                     componentsschemas_telemetry_field_type_0_item = (
                         componentsschemas_telemetry_field_type_0_item_data.value
                         if isinstance(componentsschemas_telemetry_field_type_0_item_data, Enum)
@@ -74,8 +83,8 @@ class TelemetrySortOptions:
         def _parse_field(
             data: object,
         ) -> Union[
-            List[Union[Literal["count"], Literal["lookup"]]],
-            List[Union[Literal["feedback_metrics"], TelemetryFieldType0ItemType2, str]],
+            List[Union[TelemetryFieldType0ItemType0, TelemetryFieldType0ItemType2, str]],
+            List[Union[TelemetryFieldType1ItemType0, TelemetryFieldType1ItemType1]],
         ]:
             try:
                 if not isinstance(data, list):
@@ -86,13 +95,15 @@ class TelemetrySortOptions:
 
                     def _parse_componentsschemas_telemetry_field_type_0_item(
                         data: object,
-                    ) -> Union[Literal["feedback_metrics"], TelemetryFieldType0ItemType2, str]:
-                        componentsschemas_telemetry_field_type_0_item_type_0 = cast(Literal["feedback_metrics"], data)
-                        if componentsschemas_telemetry_field_type_0_item_type_0 != "feedback_metrics":
-                            raise ValueError(
-                                f"/components/schemas/TelemetryField_type_0_item_type_0 must match const 'feedback_metrics', got '{componentsschemas_telemetry_field_type_0_item_type_0}'"
-                            )
-                        return componentsschemas_telemetry_field_type_0_item_type_0
+                    ) -> Union[TelemetryFieldType0ItemType0, TelemetryFieldType0ItemType2, str]:
+                        try:
+                            if not isinstance(data, str):
+                                raise TypeError()
+                            componentsschemas_telemetry_field_type_0_item_type_0 = TelemetryFieldType0ItemType0(data)
+
+                            return componentsschemas_telemetry_field_type_0_item_type_0
+                        except:  # noqa: E722
+                            pass
                         try:
                             if not isinstance(data, str):
                                 raise TypeError()
@@ -101,7 +112,7 @@ class TelemetrySortOptions:
                             return componentsschemas_telemetry_field_type_0_item_type_2
                         except:  # noqa: E722
                             pass
-                        return cast(Union[Literal["feedback_metrics"], TelemetryFieldType0ItemType2, str], data)
+                        return cast(Union[TelemetryFieldType0ItemType0, TelemetryFieldType0ItemType2, str], data)
 
                     componentsschemas_telemetry_field_type_0_item = (
                         _parse_componentsschemas_telemetry_field_type_0_item(
@@ -122,18 +133,19 @@ class TelemetrySortOptions:
 
                 def _parse_componentsschemas_telemetry_field_type_1_item(
                     data: object,
-                ) -> Union[Literal["count"], Literal["lookup"]]:
-                    componentsschemas_telemetry_field_type_1_item_type_0 = cast(Literal["lookup"], data)
-                    if componentsschemas_telemetry_field_type_1_item_type_0 != "lookup":
-                        raise ValueError(
-                            f"/components/schemas/TelemetryField_type_1_item_type_0 must match const 'lookup', got '{componentsschemas_telemetry_field_type_1_item_type_0}'"
-                        )
-                    return componentsschemas_telemetry_field_type_1_item_type_0
-                    componentsschemas_telemetry_field_type_1_item_type_1 = cast(Literal["count"], data)
-                    if componentsschemas_telemetry_field_type_1_item_type_1 != "count":
-                        raise ValueError(
-                            f"/components/schemas/TelemetryField_type_1_item_type_1 must match const 'count', got '{componentsschemas_telemetry_field_type_1_item_type_1}'"
-                        )
+                ) -> Union[TelemetryFieldType1ItemType0, TelemetryFieldType1ItemType1]:
+                    try:
+                        if not isinstance(data, str):
+                            raise TypeError()
+                        componentsschemas_telemetry_field_type_1_item_type_0 = TelemetryFieldType1ItemType0(data)
+
+                        return componentsschemas_telemetry_field_type_1_item_type_0
+                    except:  # noqa: E722
+                        pass
+                    if not isinstance(data, str):
+                        raise TypeError()
+                    componentsschemas_telemetry_field_type_1_item_type_1 = TelemetryFieldType1ItemType1(data)
+
                     return componentsschemas_telemetry_field_type_1_item_type_1
 
                 componentsschemas_telemetry_field_type_1_item = _parse_componentsschemas_telemetry_field_type_1_item(

orca_sdk/_generated_api_client/models/unauthenticated_error_response.py

@@ -10,11 +10,14 @@ The main change is:
 
 # flake8: noqa: C901
 
-from typing import Any, Literal, Type, TypeVar, cast
+from enum import Enum
+from typing import Any, Type, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.unauthenticated_error_response_status_code import UnauthenticatedErrorResponseStatusCode
+
 T = TypeVar("T", bound="UnauthenticatedErrorResponse")
 
 
@@ -22,14 +25,14 @@ T = TypeVar("T", bound="UnauthenticatedErrorResponse")
 class UnauthenticatedErrorResponse:
     """
     Attributes:
-        status_code (Literal[401]):
+        status_code (UnauthenticatedErrorResponseStatusCode):
     """
 
-    status_code: Literal[401]
+    status_code: UnauthenticatedErrorResponseStatusCode
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        status_code = self.status_code
+        status_code = self.status_code.value if isinstance(self.status_code, Enum) else self.status_code
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -44,9 +47,7 @@ class UnauthenticatedErrorResponse:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         d = src_dict.copy()
-        status_code = cast(Literal[401], d.pop("status_code"))
-        if status_code != 401:
-            raise ValueError(f"status_code must match const 401, got '{status_code}'")
+        status_code = UnauthenticatedErrorResponseStatusCode(d.pop("status_code"))
 
         unauthenticated_error_response = cls(
             status_code=status_code,

orca_sdk/_generated_api_client/models/unauthenticated_error_response_status_code.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class UnauthenticatedErrorResponseStatusCode(IntEnum):
+    VALUE_401 = 401
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/unauthorized_error_response.py

@@ -10,11 +10,14 @@ The main change is:
 
 # flake8: noqa: C901
 
-from typing import Any, Literal, Type, TypeVar, cast
+from enum import Enum
+from typing import Any, Type, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.unauthorized_error_response_status_code import UnauthorizedErrorResponseStatusCode
+
 T = TypeVar("T", bound="UnauthorizedErrorResponse")
 
 
@@ -22,16 +25,16 @@ T = TypeVar("T", bound="UnauthorizedErrorResponse")
 class UnauthorizedErrorResponse:
     """
     Attributes:
-        status_code (Literal[403]):
+        status_code (UnauthorizedErrorResponseStatusCode):
         reason (str):
     """
 
-    status_code: Literal[403]
+    status_code: UnauthorizedErrorResponseStatusCode
     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
+        status_code = self.status_code.value if isinstance(self.status_code, Enum) else self.status_code
 
         reason = self.reason
 
@@ -49,9 +52,7 @@ class UnauthorizedErrorResponse:
     @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}'")
+        status_code = UnauthorizedErrorResponseStatusCode(d.pop("status_code"))
 
         reason = d.pop("reason")
 

orca_sdk/_generated_api_client/models/unauthorized_error_response_status_code.py

@@ -0,0 +1,8 @@
+from enum import IntEnum
+
+
+class UnauthorizedErrorResponseStatusCode(IntEnum):
+    VALUE_403 = 403
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/update_org_plan_request.py

@@ -0,0 +1,73 @@
+"""
+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 enum import Enum
+from typing import Any, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.update_org_plan_request_tier import UpdateOrgPlanRequestTier
+
+T = TypeVar("T", bound="UpdateOrgPlanRequest")
+
+
+@_attrs_define
+class UpdateOrgPlanRequest:
+    """
+    Attributes:
+        tier (UpdateOrgPlanRequestTier):
+    """
+
+    tier: UpdateOrgPlanRequestTier
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tier = self.tier.value if isinstance(self.tier, Enum) else self.tier
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tier": tier,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        tier = UpdateOrgPlanRequestTier(d.pop("tier"))
+
+        update_org_plan_request = cls(
+            tier=tier,
+        )
+
+        update_org_plan_request.additional_properties = d
+        return update_org_plan_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/models/update_org_plan_request_tier.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class UpdateOrgPlanRequestTier(str, Enum):
+    CANCELLED = "CANCELLED"
+    ENTERPRISE = "ENTERPRISE"
+    FREE = "FREE"
+    PRO = "PRO"
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_shared/metrics.py

@@ -24,7 +24,7 @@ def softmax(logits: np.ndarray, axis: int = -1) -> np.ndarray:
 
 
 # We don't want to depend on transformers just for the eval_pred type in orca_sdk
-def transform_eval_pred(eval_pred: Any) -> tuple[NDArray[np.int64], NDArray[np.float32]]:
+def transform_eval_pred(eval_pred: Any) -> tuple[NDArray, NDArray[np.float32]]:
     # convert results from Trainer compute_metrics param for use in calculate_classification_metrics
     logits, references = eval_pred  # transformers.trainer_utils.EvalPrediction
     if isinstance(logits, tuple):

orca_sdk/classification_model.py

@@ -35,7 +35,10 @@ from ._generated_api_client.models import (
 from ._generated_api_client.models import (
     PredictionSortItemItemType1 as PredictionSortDirection,
 )
-from ._generated_api_client.models import PredictiveModelUpdate, RACHeadType
+from ._generated_api_client.models import (
+    PredictiveModelUpdate,
+    RACHeadType,
+)
 from ._generated_api_client.types import UNSET as CLIENT_UNSET
 from ._shared.metrics import ClassificationMetrics, calculate_classification_metrics
 from ._utils.common import UNSET, CreateMode, DropMode

orca_sdk/classification_model_test.py

@@ -374,3 +374,56 @@ def test_explain(writable_memoryset: LabeledMemoryset):
             raise e
     finally:
         ClassificationModel.drop("test_model_for_explain")
+
+
+@skip_in_ci("We don't have Anthropic API key in CI")
+def test_action_recommendation(writable_memoryset: LabeledMemoryset):
+    """Test getting action recommendations for predictions"""
+
+    writable_memoryset.analyze(
+        {"name": "neighbor", "neighbor_counts": [1, 3]},
+        lookup_count=3,
+    )
+
+    model = ClassificationModel.create(
+        "test_model_for_action",
+        writable_memoryset,
+        num_classes=2,
+        memory_lookup_count=3,
+        description="This is a test model for action recommendations",
+    )
+
+    # Make a prediction with expected label to simulate incorrect prediction
+    prediction = model.predict("Do you love soup?", expected_labels=1)
+
+    try:
+        # Get action recommendation
+        action, rationale = prediction.recommend_action()
+
+        assert action is not None
+        assert rationale is not None
+        assert action in ["remove_duplicates", "detect_mislabels", "add_memories", "finetuning"]
+        assert len(rationale) > 10
+
+        # Test memory suggestions
+        memory_suggestions = prediction.generate_memory_suggestions(num_memories=2)
+
+        assert memory_suggestions is not None
+        assert len(memory_suggestions) == 2
+
+        for suggestion in memory_suggestions:
+            assert isinstance(suggestion, dict)
+            assert "value" in suggestion
+            assert "label" in suggestion
+            assert isinstance(suggestion["value"], str)
+            assert len(suggestion["value"]) > 0
+            assert isinstance(suggestion["label"], int)
+            assert 0 <= suggestion["label"] < len(model.memoryset.label_names)
+
+    except Exception as e:
+        if "ANTHROPIC_API_KEY" in str(e):
+            logging.info("Skipping agent tests because ANTHROPIC_API_KEY is not set")
+        else:
+            raise e
+    finally:
+        ClassificationModel.drop("test_model_for_action")

orca_sdk/credentials.py

@@ -106,6 +106,20 @@ class OrcaCredentials:
         """
         delete_api_key(name_or_id=name)
 
+    @staticmethod
+    def set_headers(headers: dict[str, str]):
+        """
+        Add or override default HTTP headers for all Orca API requests.
+
+        Args:
+            **kwargs: Header names with their string values
+
+        Notes:
+            New keys are merged into the existing headers, this will overwrite headers with the
+            same name, but leave other headers untouched.
+        """
+        set_headers(get_headers() | headers)
+
     @staticmethod
     def set_api_key(api_key: str, check_validity: bool = True):
         """
@@ -121,6 +135,6 @@ class OrcaCredentials:
         Raises:
             ValueError: if the API key is invalid and `check_validity` is True
         """
-        set_headers(get_headers() | {"Api-Key": api_key})
+        OrcaCredentials.set_headers({"Api-Key": api_key})
         if check_validity:
             check_authentication()